https://spx.com.my/new_static/detail-bundle.ba5f3677.js

1/**!
2
3 @license
4 handlebars v4.7.8
5
6Copyright (C) 2011-2019 by Yehuda Katz
7
8Permission is hereby granted, free of charge, to any person obtaining a copy
9of this software and associated documentation files (the "Software"), to deal
10in the Software without restriction, including without limitation the rights
11to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12copies of the Software, and to permit persons to whom the Software is
13furnished to do so, subject to the following conditions:
14
15The above copyright notice and this permission notice shall be included in
16all copies or substantial portions of the Software.
17
18THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24THE SOFTWARE.
25
26*/
27!function(a,b){"object"==typeof exports&&"object"==typeof module?module.exports=b():"function"==typeof define&&define.amd?define([],b):"object"==typeof exports?exports.Handlebars=b():a.Handlebars=b()}(this,function(){return function(a){function b(d){if(c[d])return c[d].exports;var e=c[d]={exports:{},id:d,loaded:!1};return a[d].call(e.exports,e,e.exports,b),e.loaded=!0,e.exports}var c={};return b.m=a,b.c=c,b.p="",b(0)}([function(a,b,c){"use strict";function d(){var a=new h.HandlebarsEnvironment;return n.extend(a,h),a.SafeString=j["default"],a.Exception=l["default"],a.Utils=n,a.escapeExpression=n.escapeExpression,a.VM=p,a.template=function(b){return p.template(b,a)},a}var e=c(1)["default"],f=c(2)["default"];b.__esModule=!0;var g=c(3),h=e(g),i=c(76),j=f(i),k=c(5),l=f(k),m=c(4),n=e(m),o=c(77),p=e(o),q=c(82),r=f(q),s=d();s.create=d,r["default"](s),s["default"]=s,b["default"]=s,a.exports=b["default"]},function(a,b){"use strict";b["default"]=function(a){if(a&&a.__esModule)return a;var b={};if(null!=a)for(var c in a)Object.prototype.hasOwnProperty.call(a,c)&&(b[c]=a[c]);return b["default"]=a,b},b.__esModule=!0},function(a,b){"use strict";b["default"]=function(a){return a&&a.__esModule?a:{"default":a}},b.__esModule=!0},function(a,b,c){"use strict";function d(a,b,c){this.helpers=a||{},this.partials=b||{},this.decorators=c||{},i.registerDefaultHelpers(this),j.registerDefaultDecorators(this)}var e=c(2)["default"];b.__esModule=!0,b.HandlebarsEnvironment=d;var f=c(4),g=c(5),h=e(g),i=c(9),j=c(69),k=c(71),l=e(k),m=c(72),n="4.7.8";b.VERSION=n;var o=8;b.COMPILER_REVISION=o;var p=7;b.LAST_COMPATIBLE_COMPILER_REVISION=p;var q={1:"<= 1.0.rc.2",2:"== 1.0.0-rc.3",3:"== 1.0.0-rc.4",4:"== 1.x.x",5:"== 2.0.0-alpha.x",6:">= 2.0.0-beta.1",7:">= 4.0.0 <4.3.0",8:">= 4.3.0"};b.REVISION_CHANGES=q;var r="[object Object]";d.prototype={constructor:d,logger:l["default"],log:l["default"].log,registerHelper:function(a,b){if(f.toString.call(a)===r){if(b)throw new h["default"]("Arg not supported with multiple helpers");f.extend(this.helpers,a)}else this.helpers[a]=b},unregisterHelper:function(a){delete this.helpers[a]},registerPartial:function(a,b){if(f.toString.call(a)===r)f.extend(this.partials,a);else{if("undefined"==typeof b)throw new h["default"]('Attempting to register a partial called "'+a+'" as undefined');this.partials[a]=b}},unregisterPartial:function(a){delete this.partials[a]},registerDecorator:function(a,b){if(f.toString.call(a)===r){if(b)throw new h["default"]("Arg not supported with multiple decorators");f.extend(this.decorators,a)}else this.decorators[a]=b},unregisterDecorator:function(a){delete this.decorators[a]},resetLoggedPropertyAccesses:function(){m.resetLoggedProperties()}};var s=l["default"].log;b.log=s,b.createFrame=f.createFrame,b.logger=l["default"]},function(a,b){"use strict";function c(a){return k[a]}function d(a){for(var b=1;b<arguments.length;b++)for(var c in arguments[b])Object.prototype.hasOwnProperty.call(arguments[b],c)&&(a[c]=arguments[b][c]);return a}function e(a,b){for(var c=0,d=a.length;c<d;c++)if(a[c]===b)return c;return-1}function f(a){if("string"!=typeof a){if(a&&a.toHTML)return a.toHTML();if(null==a)return"";if(!a)return a+"";a=""+a}return m.test(a)?a.replace(l,c):a}

27function g(a){return!a&&0!==a||!(!p(a)||0!==a.length)}function h(a){var b=d({},a);return b._parent=a,b}function i(a,b){return a.path=b,a}function j(a,b){return(a?a+".":"")+b}b.__esModule=!0,b.extend=d,b.indexOf=e,b.escapeExpression=f,b.isEmpty=g,b.createFrame=h,b.blockParams=i,b.appendContextPath=j;var k={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#x27;","`":"&#x60;","=":"&#x3D;"},l=/[&<>"'`=]/g,m=/[&<>"'`=]/,n=Object.prototype.toString;b.toString=n;var o=function(a){return"function"==typeof a};o(/x/)&&(b.isFunction=o=function(a){return"function"==typeof a&&"[object Function]"===n.call(a)}),b.isFunction=o;var p=Array.isArray||function(a){return!(!a||"object"!=typeof a)&&"[object Array]"===n.call(a)};b.isArray=p},function(a,b,c){"use strict";function d(a,b){var c=b&&b.loc,g=void 0,h=void 0,i=void 0,j=void 0;c&&(g=c.start.line,h=c.end.line,i=c.start.column,j=c.end.column,a+=" - "+g+":"+i);for(var k=Error.prototype.constructor.call(this,a),l=0;l<f.length;l++)this[f[l]]=k[f[l]];Error.captureStackTrace&&Error.captureStackTrace(this,d);try{c&&(this.lineNumber=g,this.endLineNumber=h,e?(Object.defineProperty(this,"column",{value:i,enumerable:!0}),Object.defineProperty(this,"endColumn",{value:j,enumerable:!0})):(this.column=i,this.endColumn=j))}catch(m){}}var e=c(6)["default"];b.__esModule=!0;var f=["description","fileName","lineNumber","endLineNumber","message","name","number","stack"];d.prototype=new Error,b["default"]=d,a.exports=b["default"]},function(a,b,c){a.exports={"default":c(7),__esModule:!0}},function(a,b,c){var d=c(8);a.exports=function(a,b,c){return d.setDesc(a,b,c)}},function(a,b){var c=Object;a.exports={create:c.create,getProto:c.getPrototypeOf,isEnum:{}.propertyIsEnumerable,getDesc:c.getOwnPropertyDescriptor,setDesc:c.defineProperty,setDescs:c.defineProperties,getKeys:c.keys,getNames:c.getOwnPropertyNames,getSymbols:c.getOwnPropertySymbols,each:[].forEach}},function(a,b,c){"use strict";function d(a){h["default"](a),j["default"](a),l["default"](a),n["default"](a),p["default"](a),r["default"](a),t["default"](a)}function e(a,b,c){a.helpers[b]&&(a.hooks[b]=a.helpers[b],c||delete a.helpers[b]

27)}var f=c(2)["default"];b.__esModule=!0,b.registerDefaultHelpers=d,b.moveHelperToHooks=e;var g=c(10),h=f(g),i=c(11),j=f(i),k=c(64),l=f(k),m=c(65),n=f(m),o=c(66),p=f(o),q=c(67),r=f(q),s=c(68),t=f(s)},function(a,b,c){"use strict";b.__esModule=!0;var d=c(4);b["default"]=function(a){a.registerHelper("blockHelperMissing",function(b,c){var e=c.inverse,f=c.fn;if(b===!0)return f(this);if(b===!1||null==b)return e(this);if(d.isArray(b))return b.length>0?(c.ids&&(c.ids=[c.name]),a.helpers.each(b,c)):e(this);if(c.data&&c.ids){var g=d.createFrame(c.data);g.contextPath=d.appendContextPath(c.data.contextPath,c.name),c={data:g}}return f(b,c)})},a.exports=b["default"]},function(a,b,c){"use strict";var d=c(12)["default"],e=c(42)["default"],f=c(54)["default"],g=c(59)["default"],h=c(2)["default"];b.__esModule=!0;var i=c(4),j=c(5),k=h(j);b["default"]=function(a){a.registerHelper("each",function(a,b){function c(b,c,d){n&&(n.key=b,n.index=c,n.first=0===c,n.last=!!d,o&&(n.contextPath=o+b)),m+=h(a[b],{data:n,blockParams:i.blockParams([a[b],b],[o+b,null])})}if(!b)throw new k["default"]("Must pass iterator to #each");var h=b.fn,j=b.inverse,l=0,m="",n=void 0,o=void 0;if(b.data&&b.ids&&(o=i.appendContextPath(b.data.contextPath,b.ids[0])+"."),i.isFunction(a)&&(a=a.call(this)),b.data&&(n=i.createFrame(b.data)),a&&"object"==typeof a)if(i.isArray(a))for(var p=a.length;l<p;l++)l in a&&c(l,l,l===a.length-1);else if("function"==typeof d&&a[e]){for(var q=[],r=f(a),s=r.next();!s.done;s=r.next())q.push(s.value);a=q;for(var p=a.length;l<p;l++)c(l,l,l===a.length-1)}else!function(){var b=void 0;g(a).forEach(function(a){void 0!==b&&c(b,l-1),b=a,l++}),void 0!==b&&c(b,l-1,!0)}();return 0===l&&(m=j(this)),m})},a.exports=b["default"]},function(a,b,c){a.exports={"default":c(13),__esModule:!0}},function(a,b,c){c(14),c(41),a.exports=c(20).Symbol},function(a,b,c){"use strict";var d=c(8),e=c(15),f=c(16),g=c(17),h=c(19),i=c(23),j=c(18),k=c(26),l=c(27),m=c(29),n=c(28),o=c(30),p=c(35),q=c(36),r=c(37),s=c(38),t=c(31),u=c(25),v=d.getDesc,w=d.setDesc,x=d.create,y=p.get,z=e.Symbol,A=e.JSON,B=A&&A.stringify,C=!1,D=n("_hidden"),E=d.isEnum,F=k("symbol-registry"),G=k("symbols"),H="function"==typeof z,I=Object.prototype,J=g&&j(function(){return 7!=x(w({},"a",{get:function(){return w(this,"a",{value:7}).a}})).a})?function(a,b,c){var d=v(I,b);d&&delete I[b],w(a,b,c),d&&a!==I&&w(I,b,d)}:w,K=function(a){var b=G[a]=x(z.prototype);return b._k=a,g&&C&&J(I,a,{configurable:!0,set:function(b){f(this,D)&&f(this[D],a)&&(this[D][a]=!1),J(this,a,u(1,b))}}),b},L=function(a){return"symbol"==typeof a},M=function(a,b,c){return c&&f(G,b)?(c.enumerable?(f(a,D)&&a[D][b]&&(a[D][b]=!1),c=x(c,{enumerable:u(0,!1)})):(f(a,D)||w(a,D,u(1,{})),a[D][b]=!0),J(a,b,c)):w(a,b,c)},N=function(a,b){s(a);for(var c,d=q(b=t(b)),e=0,f=d.length;f>e;)M(a,c=d[e++],b[c]);return a},O=function(a,b){return void 0===b?x(a):N(x(a),b)},P=function(a){var b=E.call(this,a);return!(b||!f(this,a)||!f(G,a)||f(this,D)&&this[D][a])||b},Q=function(a,b){var c=v(a=t(a),b);return!c||!f(G,b)||f(a,D)&&a[D][b]||(c.enumerable=!0),c},R=function(a){for(var b,c=y(t(a)),d=[],e=0;c.length>e;)f(G,b=c[e++])||b==D||d.push(b);return d},S=function(a){for(var b,c=y(t(a)),d=[],e=0;c.length>e;)f(G,b=c[e++])&&d.push(G[b]);return d},T=function(a){if(void 0!==a&&!L(a)){for(var b,c,d=[a],e=1,f=arguments;f.length>e;)d.push(f[e++]);return b=d[1],"function"==typeof b&&(c=b),!c&&r(b)||(b=function(a,b){if(c&&(b=c.call(this,a,b)),!L(b))return b}),d[1]=b,B.apply(A,d)}},U=j(function(){var a=z();return"[null]"!=B([a])||"{}"!=B({a:a})||"{}"!=B(Object(a))});H||(z=function(){if(L(this))throw TypeError("Symbol is not a constructor");return K(m(arguments.length>0?arguments[0]:void 0))},i(z.prototype,"toString",function(){return this._k}),L=function(a){return a instanceof z},d.create=O,d.isEnum=P,d.getDesc=Q,d.setDesc=M,d.setDescs=N,d.getNames=p.get=R,d.getSymbols=S,g&&!c(40)&&i(I,"propertyIsEnumerable",P,!0));var V={"for":function(a){return f(F,a+="")?F[a]:F[a]=z(a)},keyFor:function(a){return o(F,a)},useSetter:function(){C=!0},useSimple:function(){C=!1}};d.each.call("hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables".split(","),function(a){var b=n(a);V[a]=H?b:K(b)}),C=!0,h(h.G+h.W,{Symbol:z}),h(h.S,"Symbol",V),h(h.S+h.F*!H,"Object",{create:O,defineProperty:M,defineProperties:N,getOwnPropertyDescriptor:Q,getOwnPropertyNames:R,getOwnPropertySymbols:S}),A&&h(h.S+h.F*(!H||U),"JSON",{stringify:T}),l(z,"Symbol"),l(Math,"Math",!0),l(e.JSON,"JSON",!0)},function(a,b){var c=a.exports="undefined"!=typeof window&&window.Math==Math?window:"undefined"!=typeof self&&self.Math==Math?self:Function("return this")();"number"==typeof __g&&(__g=c)},function(a,b){var c={}.hasOwnProperty;a.exports=function(a,b){return c.call(a,b)}},function(a,b,c){a.exports=!c(18)(function(){return 7!=Object.defineProperty({},"a",{get:function(){return 7}}).a})},function(a,b){a.exports=function(a){try{return!!a()}catch(b){return!0}}},function(a,b,c){var d=c(15),e=c(20),f=c(21),g="prototype",h=function(a,b,c){var i,j,k,l=a&h.F,m=a&h.G,n=a&h.S,o=a&h.P,p=a&h.B,q=a&h.W,r=m?e:e[b]||(e[b]={}),s=m?d:n?d[b]:(d[b]||{})[g];m&&(c=b);for(i in c)j=!l&&s&&i in s,j&&i in r||(k=j?s[i]:c[i],r[i]=m&&"function"!=typeof s[i]?c[i]:p&&j?f(k,d):q&&s[i]==k?function(a){var b=function(b){return this instanceof a?new a(b):a(b)};return b[g]=a[g],b}(k):o&&"function"==typeof k?f(Function.call,k):k,o&&((r[g]||(r[g]={}))[i]=k))};h.F=1,h.G=2,h.S=4,h.P=8,h.B=16,h.W=32,a.exports=h},function(a,b){var c=a.exports={version:"1.2.6"};"number"==typeof __e&&(__e=c)},function(a,b,c){var d=c(22);a.exports=function(a,b,c){if(d(a),void 0===b)return a;switch(c){case 1:return function(c){return a.call(b,c)};case 2:return function(c,d){return a.call(b,c,d)};case 3:return function(c,d,e){return a.call(b,c,d,e)}}return function(){return a.apply(b,arguments)}}},function(a,b){a.exports=function(a){if("function"!=typeof a)throw TypeError(a+" is not a function!");return a}},function(a,b,c){a.exports=c(24)},function(a,b,c){var d=c(8),e=c(25);a.exports=c(17)?function(a,b,c){return d.setDesc(a,b,e(1,c))}:function(a,b,c){return a[b]=c,a}},function(a,b){a.exports=function(a,b){return{enumerable:!(1&a),configurable:!(2&a),writable:!(4&a),value:b}}},function(a,b,c){var d=c(15),e="__core-js_shared__",f=d[e]||(d[e]={});a.exports=function(a){return f[a]||(f[a]={})}},function(a,b,c){var d=c(8).setDesc,e=c(16),f=c(28)("toStringTag");a.exports=function(a,b,c){a&&!e(a=c?a:a.prototype,f)&&d(a,f,{configurable:!0,value:b})}},function(a,b,c){var d=c(26)("wks"),e=c(29),f=c(15).Symbol;a.exports=function(a){return d[a]||(d[a]=f&&f[a]||(f||e)("Symbol."+a))}},function(a,b){var c=0,d=Math.random();a.exports=function(a){return"Symbol(".concat(void 0===a?"":a,")_",(++c+d).toString(36))}},function(a,b,c){var d=c(8),e=c(31);a.exports=function(a,b){for(var c,f=e(a),g=d.getKeys(f),h=g.length,i=0;h>i;)if(f[c=g[i++]]===b)return c}},function(a,b,c){var d=c(32),e=c(34);a.exports=function(a){return d(e(a))}},function(a,b,c){var d=c(33);a.exports=Object("z").propertyIsEnumerable(0)?Object:function(a){return"String"==d(a)?a.split(""):Object(a)}},function(a,b){var c={}.toString;a.exports=function(a){return c.call(a).slice(8,-1)}},function(a,b){a.exports=function(a){if(void 0==a)throw TypeError("Can't call method on  "+a);return a}},function(a,b,c){var d=c(31),e=c(8).getNames,f={}.toString,g="object"==typeof window&&Object.getOwnPropertyNames?Object.getOwnPropertyNames(window):[],h=function(a){try{return e(a)}catch(b){return g.slice()}};a.exports.get=function(a){return g&&"[object Window]"==f.call(a)?h(a):e(d(a))}},function(a,b,c){var d=c(8);a.exports=function(a){var b=d.getKeys(a),c=d.getSymbols;if(c)for(var e,f=c(a),g=d.isEnum,h=0;f.length>h;)g.call(a,e=f[h++])&&b.push(e);return b}},function(a,b,c){var d=c(33);a.exports=Array.isArray||function(a){return"Array"==d(a)}},function(a,b,c){var d=c(39);a.exports=function(a){if(!d(a))throw TypeError(a+" is not an object!");return a}},function(a,b){a.exports=function(a){return"object"==typeof a?null!==a:"function"==typeof a}},function(a,b){a.exports=!0},function(a,b){},function(a,b,c){a.exports={"default":c(43),__esModule:!0}},function(a,b,c){c(44),c(50),a.exports=c(28)("iterator")},function(a,b,c){"use strict";var d=c(45)(!0);c(47)(String,"String",function(a){this._t=String(a),this._i=0},function(){var a,b=this._t,c=this._i;return c>=b.length?{value:void 0,done:!0}:(a=d(b,c),this._i+=a.length,{value:a,done:!1})})},function(a,b,c){var d=c(46),e=c(34);a.exports=function(a){return function(b,c){var f,g,h=String(e(b)),i=d(c),j=h.length;return i<0||i>=j?a?"":void 0:(f=h.charCodeAt(i),f<55296||f>56319||i+1===j||(g=h.charCodeAt(i+1))<56320||g>57343?a?h.charAt(i):f:a?h.slice(i,i+2):(f-55296<<10)+(g-56320)+65536)}}},function(a,b){var c=Math.ceil,d=Math.floor;a.exports=function(a){return isNaN(a=+a)?0:(a>0?d:c)(a)}},function(a,b,c){"use strict";var d=c(40),e=c(19),f=c(23),g=c(24),h=c(16),i=c(48),j=c(49),k=c(27),l=c(8).getProto,m=c(28)("iterator"),n=!([].keys&&"next"in[].keys()),o="@@iterator",p="keys",q="values",r=function(){return this};a.exports=function(a,b,c,s,t,u,v){j(c,b,s);var w,x,y=function(a){if(!n&&a in C)return C[a];switch(a){case p:return function(){return new c(this,a)};case q:return function(){return new c(this,a)}}return function(){return new c(this,a)}},z=b+" Iterator",A=t==q,B=!1,C=a.prototype,D=C[m]||C[o]||t&&C[t],E=D||y(t);if(D){var F=l(E.call(new a));k(F,z,!0),!d&&h(C,o)&&g(F,m,r),A&&D.name!==q&&(B=!0,E=function(){return D.call(this)})}if(d&&!v||!n&&!B&&C[m]||g(C,m,E),i[b]=E,i[z]=r,t)if(w={values:A?E:y(q),keys:u?E:y(p),entries:A?y("entries"):E},v)for(x in w)x in C||f(C,x,w[x]);else e(e.P+e.F*(n||B),b,w);return w}},function(a,b){a.exports={}},function(a,b,c){"use strict";var d=c(8),e=c(25),f=c(27),g={};c(24)(g,c(28)("iterator"),function(){return this}),a.exports=function(a,b,c){a.prototype=d.create(g,{next:e(1,c)}),f(a,b+" Iterator")}},function(a,b,c){c(51);var d=c(48);d.NodeList=d.HTMLCollection=d.Array},function(a,b,c){"use strict";var d=c(52),e=c(53),f=c(48),g=c(31);a.exports=c(47)(Array,"Array",function(a,b){this._t=g(a),this._i=0,this._k=b},function(){var a=this._t,b=this._k,c=this._i++;return!a||c>=a.length?(this._t=void 0,e(1)):"keys"==b?e(0,c):"values"==b?e(0,a[c]):e(0,[c,a[c]])},"values"),f.Arguments=f.Array,d("keys"),d("values"),d("entries")},function(a,b){a.exports=function(){}},function(a,b){a.exports=function(a,b){return{value:b,done:!!a}}},function(a,b,c){a.exports={"default":c(55),__esModule:!0}},function(a,b,c){c(50),c(44),a.exports=c(56)},function(a,b,c){var d=c(38),e=c(57);a.exports=c(20).getIterator=function(a){var b=e(a);if("function"!=typeof b)throw TypeError(a+" is not iterable!");return d(b.call(a))}},function(a,b,c){var d=c(58),e=c(28)("iterator"),f=c(48);a.exports=c(20).getIteratorMethod=function(a){if(void 0!=a)return a[e]||a["@@iterator"]||f[d(a)]}},function(a,b,c){var d=c(33),e=c(28)("toStringTag"),f="Arguments"==d(function(){return arguments}());a.exports=function(a){var b,c,g;return void 0===a?"Undefined":null===a?"Null":"string"==typeof(c=(b=Object(a))[e])?c:f?d(b):"Object"==(g=d(b))&&"function"==typeof b.callee?"Arguments":g}},function(a,b,c){a.exports={"default":c(60),__esModule:!0}},function(a,b,c){c(61),a.exports=c(20).Object.keys},function(a,b,c){var d=c(62);c(63)("keys",function(a){return function(b){return a(d(b))}})},function(a,b,c){var d=c(34);a.exports=function(a){return Object(d(a))}},function(a,b,c){var d=c(19),e=c(20),f=c(18);a.exports=function(a,b){var c=(e.Object||{})[a]||Object[a],g={};g[a]=b(c),d(d.S+d.F*f(function(){c(1)}),"Object",g)}},function(a,b,c){"use strict";var d=c(2)["default"];b.__esModule=!0;var e=c(5),f=d(e);b["default"]=function(a){a.registerHelper("helperMissing",function(){if(1!==arguments.length)throw new f["default"]('Missing helper: "'+arguments[arguments.length-1].name+'"')})},a.exports=b["default"]},function(a,b,c){"use strict";var d=c(2)["default"];b.__esModule=!0;var e=c(4),f=c(5),g=d(f);b["default"]=function(a){a.registerHelper("if",function(a,b){if(2!=arguments.length)throw new g["default"]("#if requires exactly one argument");return e.isFunction(a)&&(a=a.call(this)),!b.hash.includeZero&&!a||e.isEmpty(a)?b.inverse(this):b.fn(this)}),a.registerHelper("unless",function(b,c){if(2!=arguments.length)throw new g["default"]("#unless requires exactly one argument");return a.helpers["if"].call(this,b,{fn:c.inverse,inverse:c.fn,hash:c.hash})})},a.exports=b["default"]},function(a,b){"use strict";b.__esModule=!0,b["default"]=function(a){a.registerHelper("log",function(){for(var b=[void 0],c=arguments[arguments.length-1],d=0;d<arguments.length-1;d++)b.push(arguments[d]);var e=1;null!=c.hash.level?e=c.hash.level:c.data&&null!=c.data.level&&(e=c.data.level),b[0]=e,a.log.apply(a,b)})},a.exports=b["default"]},function(a,b){"use strict";b.__esModule=!0,b["default"]=function(a){a.registerHelper("lookup",function(a,b,c){return a?c.lookupProperty(a,b):a})},a.exports=b["default"]},function(a,b,c){"use strict";var d=c(2)["default"];b.__esModule=!0;var e=c(4),f=c(5),g=d(f);b["default"]=function(a){a.registerHelper("with",function(a,b){if(2!=arguments.length)throw new g["default"]("#with requires exactly one argument");e.isFunction(a)&&(a=a.call(this));var c=b.fn;if(e.isEmpty(a))return b.inverse(this);var d=b.data;return b.data&&b.ids&&(d=e.createFrame(b.data),d.contextPath=e.appendContextPath(b.data.contextPath,b.ids[0])),c(a,{data:d,blockParams:e.blockParams([a],[d&&d.contextPath])})})},a.exports=b["default"]},function(a,b,c){"use strict";function d(a){g["default"](a)}var e=c(2)["default"];b.__esModule=!0,b.registerDefaultDecorators=d;var f=c(70),g=e(f)},function(a,b,c){"use strict";b.__esModule=!0;var d=c(4);b["default"]=function(a){a.registerDecorator("inline",function(a,b,c,e){var f=a;return b.partials||(b.partials={},f=function(e,f){var g=c.partials;c.partials=d.extend({},g,b.partials);var h=a(e,f);return c.partials=g,h}),b.partials[e.args[0]]=e.fn,f})},a.exports=b["default"]},function(a,b,c){"use strict";b.__esModule=!0;var d=c(4),e={methodMap:["debug","info","warn","error"],level:"info",lookupLevel:function(a){if("string"==typeof a){var b=d.indexOf(e.methodMap,a.toLowerCase());a=b>=0?b:parseInt(a,10)}return a},log:function(a){if(a=e.lookupLevel(a),"undefined"!=typeof console&&e.lookupLevel(e.level)<=a){var b=e.methodMap[a];console[b]||(b="log");for(var c=arguments.length,d=Array(c>1?c-1:0),f=1;f<c;f++)d[f-1]=arguments[f];console[b].apply(console,d)}}};b["default"]=e,a.exports=b["default"]},function(a,b,c){"use strict";function d(a){var b=i(null);b.

265"'\/]/g, s => _entityMap[s]);
266      }
267      return data;
268    };
269    class RegExpCache {
270      constructor(capacity) {
271        this.capacity = capacity;
272        this.regExpMap = new Map();
273        this.regExpQueue = [];
274      }
275      getRegExp(pattern) {
276        const regExpFromCache = this.regExpMap.get(pattern);
277        if (regExpFromCache !== undefined) {
278          return regExpFromCache;
279        }
280        const regExpNew = new RegExp(pattern);
281        if (this.regExpQueue.length === this.capacity) {
282          this.regExpMap.delete(this.regExpQueue.shift());
283        }
284        this.regExpMap.set(pattern, regExpNew);
285        this.regExpQueue.push(pattern);
286        return regExpNew;
287      }
288    }
289    const chars = [' ', ',', '?', '!', ';'];
290    const looksLikeObjectPathRegExpCache = new RegExpCache(20);
291    const looksLikeObjectPath = (key, nsSeparator, keySeparator) => {
292      nsSeparator = nsSeparator || '';
293      keySeparator = keySeparator || '';
294      const possibleChars = chars.filter(c => nsSeparator.indexOf(c) < 0 && keySeparator.indexOf(c) < 0);
295      if (possibleChars.length === 0) return true;
296      const r = looksLikeObjectPathRegExpCache.getRegExp(`(${possibleChars.map(c => c === '?' ? '\\?' : c).join('|')})`);
297      let matched = !r.test(key);
298      if (!matched) {
299        const ki = key.indexOf(keySeparator);
300        if (ki > 0 && !r.test(key.substring(0, ki))) {
301          matched = true;
302        }
303      }
304      return matched;
305    };
306    const deepFind = (obj, path, keySeparator = '.') => {
307      if (!obj) return undefined;
308      if (obj[path]) {
309        if (!Object.prototype.hasOwnProperty.call(obj, path)) return undefined;
310        return obj[path];
311      }
312      const tokens = path.split(keySeparator);
313      let current = obj;
314      for (let i = 0; i < tokens.length;) {
315        if (!current || typeof current !== 'object') {
316          return undefined;
317        }
318        let next;
319        let nextPath = '';
320        for (let j = i; j < tokens.length; ++j) {
321          if (j !== i) {
322            nextPath += keySeparator;
323          }
324          nextPath += tokens[j];
325          next = current[nextPath];
326          if (next !== undefined) {
327            if (['string', 'number', 'boolean'].indexOf(typeof next) > -1 && j < tokens.length - 1) {
328              continue;
329            }
330            i += j - i + 1;
331            break;
332          }
333        }
334        current = next;
335      }
336      return current;
337    };
338    const getCleanedCode = code => code?.replace(/_/g, '-');
339
340    const consoleLogger = {
341      type: 'logger',
342      log(args) {
343        this.output('log', args);
344      },
345      warn(args) {
346        this.output('warn', args);
347      },
348      error(args) {
349        this.output('error', args);
350      },
351      output(type, args) {
352        console?.[type]?.apply?.(console, args);
353      }
354    };
355    class Logger {
356      constructor(concreteLogger, options = {}) {
357        this.init(concreteLogger, options);
358      }
359      init(concreteLogger, options = {}) {
360        this.prefix = options.prefix || 'i18next:';
361        this.logger = concreteLogger || consoleLogger;
362        this.options = options;
363        this.debug = options.debug;
364      }
365      log(...args) {
366        return this.forward(args, 'log', '', true);
367      }
368      warn(...args) {
369        return this.forward(args, 'warn', '', true);
370      }
371      error(...args) {
372        return this.forward(args, 'error', '');
373      }
374      deprecate(...args) {
375        return this.forward(args, 'warn', 'WARNING DEPRECATED: ', true);
376      }
377      forward(args, lvl, prefix, debugOnly) {
378        if (debugOnly && !this.debug) return null;
379        if (isString(args[0])) args[0] = `${prefix}${this.prefix} ${args[0]}`;
380        return this.logger[lvl](args);
381      }
382      create(moduleName) {
383        return new Logger(this.logger, {
384          ...{
385            prefix: `${this.prefix}:${moduleName}:`
386          },
387          ...this.options
388        });
389      }
390      clone(options) {
391        options = options || this.options;
392        options.prefix = options.prefix || this.prefix;
393        return new Logger(this.logger, options);
394      }
395    }
396    var baseLogger = new Logger();
397
398    class EventEmitter {
399      constructor() {
400        this.observers = {};
401      }
402      on(events, listener) {
403        events.split(' ').forEach(event => {
404          if (!this.observers[event]) this.observers[event] = new Map();
405          const numListeners = this.observers[event].get(listener) || 0;
406          this.observers[event].set(listener, numListeners + 1);
407        });
408        return this;
409      }
410      off(event, listener) {
411        if (!this.observers[event]) return;
412        if (!listener) {
413          delete this.observers[event];
414          return;
415        }
416        this.observers[event].delete(listener);
417      }
418      emit(event, ...args) {
419        if (this.observers[event]) {
420          const cloned = Array.from(this.observers[event].entries());
421          cloned.forEach(([observer, numTimesAdded]) => {
422            for (let i = 0; i < numTimesAdded; i++) {
423              observer(...args);
424            }
425          });
426        }
427        if (this.observers['*']) {
428          const cloned = Array.from(this.observers['*'].entries());
429          cloned.forEach(([observer, numTimesAdded]) => {
430            for (let i = 0; i < numTimesAdded; i++) {
431              observer.apply(observer, [event, ...args]);
432            }
433          });
434        }
435      }
436    }
437

438    class ResourceStore extends EventEmitter {
439      constructor(data, options = {
440        ns: ['translation'],
441        defaultNS: 'translation'
442      }) {
443        super();
444        this.data = data || {};
445        this.options = options;
446        if (this.options.keySeparator === undefined) {
447          this.options.keySeparator = '.';
448        }
449        if (this.options.ignoreJSONStructure === undefined) {
450          this.options.ignoreJSONStructure = true;
451        }
452      }
453      addNamespaces(ns) {
454        if (this.options.ns.indexOf(ns) < 0) {
455          this.options.ns.push(ns);
456        }
457      }
458      removeNamespaces(ns) {
459        const index = this.options.ns.indexOf(ns);
460        if (index > -1) {
461          this.options.ns.splice(index, 1);
462        }
463      }
464      getResource(lng, ns, key, options = {}) {
465        const keySeparator = options.keySeparator !== undefined ? options.keySeparator : this.options.keySeparator;
466        const ignoreJSONStructure = options.ignoreJSONStructure !== undefined ? options.ignoreJSONStructure : this.options.ignoreJSONStructure;
467        let path;
468        if (lng.indexOf('.') > -1) {
469          path = lng.split('.');
470        } else {
471          path = [lng, ns];
472          if (key) {
473            if (Array.isArray(key)) {
474              path.push(...key);
475            } else if (isString(key) && keySeparator) {
476              path.push(...key.split(keySeparator));
477            } else {
478              path.push(key);
479            }
480          }
481        }
482        const result = getPath(this.data, path);
483        if (!result && !ns && !key && lng.indexOf('.') > -1) {
484          lng = path[0];
485          ns = path[1];
486          key = path.slice(2).join('.');
487        }
488        if (result || !ignoreJSONStructure || !isString(key)) return result;
489        return deepFind(this.data?.[lng]?.[ns], key, keySeparator);
490      }
491      addResource(lng, ns, key, value, options = {
492        silent: false
493      }) {
494        const keySeparator = options.keySeparator !== undefined ? options.keySeparator : this.options.keySeparator;
495        let path = [lng, ns];
496        if (key) path = path.concat(keySeparator ? key.split(keySeparator) : key);
497        if (lng.indexOf('.') > -1) {
498          path = lng.split('.');
499          value = ns;
500          ns = path[1];
501        }
502        this.addNamespaces(ns);
503        setPath(this.data, path, value);
504        if (!options.silent) this.emit('added', lng, ns, key, value);
505      }
506      addResources(lng, ns, resources, options = {
507        silent: false
508      }) {
509        for (const m in resources) {
510          if (isString(resources[m]) || Array.isArray(resources[m])) this.addResource(lng, ns, m, resources[m], {
511            silent: true
512          });
513        }
514        if (!options.silent) this.emit('added', lng, ns, resources);
515      }
516      addResourceBundle(lng, ns, resources, deep, overwrite, options = {
517        silent: false,
518        skipCopy: false
519      }) {
520        let path = [lng, ns];
521        if (lng.indexOf('.') > -1) {
522          path = lng.split('.');
523          deep = resources;
524          resources = ns;
525          ns = path[1];
526        }
527        this.addNamespaces(ns);
528        let pack = getPath(this.data, path) || {};
529        if (!options.skipCopy) resources = JSON.parse(JSON.stringify(resources));
530        if (deep) {
531          deepExtend(pack, resources, overwrite);
532        } else {
533          pack = {
534            ...pack,
535            ...resources
536          };
537        }
538        setPath(this.data, path, pack);
539        if (!options.silent) this.emit('added', lng, ns, resources);
540      }
541      removeResourceBundle(lng, ns) {
542        if (this.hasResourceBundle(lng, ns)) {
543          delete this.data[lng][ns];
544        }
545        this.removeNamespaces(ns);
546        this.emit('removed', lng, ns);
547      }
548      hasResourceBundle(lng, ns) {
549        return this.getResource(lng, ns) !== undefined;
550      }
551      getResourceBundle(lng, ns) {
552        if (!ns) ns = this.options.defaultNS;
553        return this.getResource(lng, ns);
554      }
555      getDataByLanguage(lng) {
556        return this.data[lng];
557      }
558      hasLanguageSomeTranslations(lng) {
559        const data = this.getDataByLanguage(lng);
560        const n = data && Object.keys(data) || [];
561        return !!n.find(v => data[v] && Object.keys(data[v]).length > 0);
562      }
563      toJSON() {
564        return this.data;
565      }
566    }
567
568    var postProcessor = {
569      processors: {},
570      addPostProcessor(module) {
571        this.processors[module.name] = module;
572      },
573      handle(processors, value, key, options, translator) {

574        processors.forEach(processor => {
575          value = this.processors[processor]?.process(value, key, options, translator) ?? value;
576        });
577        return value;
578      }
579    };
580
581    const PATH_KEY = Symbol('i18next/PATH_KEY');
582    function createProxy() {
583      const state = [];
584      const handler = Object.create(null);
585      let proxy;
586      handler.get = (target, key) => {
587        proxy?.revoke?.();
588        if (key === PATH_KEY) return state;
589        state.push(key);
590        proxy = Proxy.revocable(target, handler);
591        return proxy.proxy;
592      };
593      return Proxy.revocable(Object.create(null), handler).proxy;
594    }
595    function keysFromSelector(selector, opts) {
596      const {
597        [PATH_KEY]: path
598      } = selector(createProxy());
599      const keySeparator = opts?.keySeparator ?? '.';
600      const nsSeparator = opts?.nsSeparator ?? ':';
601      if (path.length > 1 && nsSeparator) {
602        const ns = opts?.ns;
603        const nsArray = Array.isArray(ns) ? ns : null;
604        if (nsArray && nsArray.length > 1 && nsArray.slice(1).includes(path[0])) {
605          return `${path[0]}${nsSeparator}${path.slice(1).join(keySeparator)}`;
606        }
607      }
608      return path.join(keySeparator);
609    }
610
611    const checkedLoadedFor = {};
612    const shouldHandleAsObject = res => !isString(res) && typeof res !== 'boolean' && typeof res !== 'number';
613    class Translator extends EventEmitter {
614      constructor(services, options = {}) {
615        super();
616        copy(['resourceStore', 'languageUtils', 'pluralResolver', 'interpolator', 'backendConnector', 'i18nFormat', 'utils'], services, this);
617        this.options = options;
618        if (this.options.keySeparator === undefined) {
619          this.options.keySeparator = '.';
620        }
621        this.logger = baseLogger.create('translator');
622      }
623      changeLanguage(lng) {
624        if (lng) this.language = lng;
625      }
626      exists(key, o = {
627        interpolation: {}
628      }) {
629        const opt = {
630          ...o
631        };
632        if (key == null) return false;
633        const resolved = this.resolve(key, opt);
634        if (resolved?.res === undefined) return false;
635        const isObject = shouldHandleAsObject(resolved.res);
636        if (opt.returnObjects === false && isObject) {
637          return false;
638        }
639        return true;
640      }
641      extractFromKey(key, opt) {
642        let nsSeparator = opt.nsSeparator !== undefined ? opt.nsSeparator : this.options.nsSeparator;
643        if (nsSeparator === undefined) nsSeparator = ':';
644        const keySeparator = opt.keySeparator !== undefined ? opt.keySeparator : this.options.keySeparator;
645        let namespaces = opt.ns || this.options.defaultNS || [];
646        const wouldCheckForNsInKey = nsSeparator && key.indexOf(nsSeparator) > -1;
647        const seemsNaturalLanguage = !this.options.userDefinedKeySeparator && !opt.keySeparator && !this.options.userDefinedNsSeparator && !opt.nsSeparator && !looksLikeObjectPath(key, nsSeparator, keySeparator);
648        if (wouldCheckForNsInKey && !seemsNaturalLanguage) {
649          const m = key.match(this.interpolator.nestingRegexp);
650          if (m && m.length > 0) {
651            return {
652              key,
653              namespaces: isString(namespaces) ? [namespaces] : namespaces
654            };
655          }
656          const parts = key.split(nsSeparator);
657          if (nsSeparator !== keySeparator || nsSeparator === keySeparator && this.options.ns.indexOf(parts[0]) > -1) namespaces = parts.shift();
658          key = parts.join(keySeparator);
659        }
660        return {
661          key,
662          namespaces: isString(namespaces) ? [namespaces] : namespaces
663        };
664      }
665      translate(keys, o, lastKey) {
666        let opt = typeof o === 'object' ? {
667          ...o
668        } : o;
669        if (typeof opt !== 'object' && this.options.overloadTranslationOptionHandler) {
670          opt = this.options.overloadTranslationOptionHandler(arguments);
671        }
672        if (typeof opt === 'object') opt = {
673          ...opt
674        };
675        if (!opt) opt = {};
676        if (keys == null) return '';
677        if (typeof keys === 'function') keys = keysFromSelector(keys, {
678          ...this.options,
679          ...opt
680        });
681        if (!Array.isArray(keys)) keys = [String(keys)];
682        keys = keys.map(k => typeof k === 'function' ? keysFromSelector(k, {
683          ...this.options,
684          ...opt
685        }) : String(k));
686        const returnDetails = opt.returnDetails !== undefined ? opt.returnDetails : this.options.returnDetails;

687        const keySeparator = opt.keySeparator !== undefined ? opt.keySeparator : this.options.keySeparator;
688        const {
689          key,
690          namespaces
691        } = this.extractFromKey(keys[keys.length - 1], opt);
692        const namespace = namespaces[namespaces.length - 1];
693        let nsSeparator = opt.nsSeparator !== undefined ? opt.nsSeparator : this.options.nsSeparator;
694        if (nsSeparator === undefined) nsSeparator = ':';
695        const lng = opt.lng || this.language;
696        const appendNamespaceToCIMode = opt.appendNamespaceToCIMode || this.options.appendNamespaceToCIMode;
697        if (lng?.toLowerCase() === 'cimode') {
698          if (appendNamespaceToCIMode) {
699            if (returnDetails) {
700              return {
701                res: `${namespace}${nsSeparator}${key}`,
702                usedKey: key,
703                exactUsedKey: key,
704                usedLng: lng,
705                usedNS: namespace,
706                usedParams: this.getUsedParamsDetails(opt)
707              };
708            }
709            return `${namespace}${nsSeparator}${key}`;
710          }
711          if (returnDetails) {
712            return {
713              res: key,
714              usedKey: key,
715              exactUsedKey: key,
716              usedLng: lng,
717              usedNS: namespace,
718              usedParams: this.getUsedParamsDetails(opt)
719            };
720          }
721          return key;
722        }
723        const resolved = this.resolve(keys, opt);
724        let res = resolved?.res;
725        const resUsedKey = resolved?.usedKey || key;
726        const resExactUsedKey = resolved?.exactUsedKey || key;
727        const noObject = ['[object Number]', '[object Function]', '[object RegExp]'];
728        const joinArrays = opt.joinArrays !== undefined ? opt.joinArrays : this.options.joinArrays;
729        const handleAsObjectInI18nFormat = !this.i18nFormat || this.i18nFormat.handleAsObject;
730        const needsPluralHandling = opt.count !== undefined && !isString(opt.count);
731        const hasDefaultValue = Translator.hasDefaultValue(opt);
732        const defaultValueSuffix = needsPluralHandling ? this.pluralResolver.getSuffix(lng, opt.count, opt) : '';
733        const defaultValueSuffixOrdinalFallback = opt.ordinal && needsPluralHandling ? this.pluralResolver.getSuffix(lng, opt.count, {
734          ordinal: false
735        }) : '';
736        const needsZeroSuffixLookup = needsPluralHandling && !opt.ordinal && opt.count === 0;
737        const defaultValue = needsZeroSuffixLookup && opt[`defaultValue${this.options.pluralSeparator}zero`] || opt[`defaultValue${defaultValueSuffix}`] || opt[`defaultValue${defaultValueSuffixOrdinalFallback}`] || opt.defaultValue;
738        let resForObjHndl = res;
739        if (handleAsObjectInI18nFormat && !res && hasDefaultValue) {
740          resForObjHndl = defaultValue;
741        }
742        const handleAsObject = shouldHandleAsObject(resForObjHndl);
743        const resType = Object.prototype.toString.apply(resForObjHndl);
744        if (handleAsObjectInI18nFormat && resForObjHndl && handleAsObject && noObject.indexOf(resType) < 0 && !(isString(joinArrays) && Array.isArray(resForObjHndl))) {
745          if (!opt.returnObjects && !this.options.returnObjects) {
746            if (!this.options.returnedObjectHandler) {
747              this.logger.warn('accessing an object - but returnObjects options is not enabled!');
748            }
749            const r = this.options.returnedObjectHandler ? this.options.returnedObjectHandler(resUsedKey, resForObjHndl, {
750              ...opt,
751              ns: namespaces
752            }) : `key '${key} (${this.language})' returned an object instead of string.`;
753            if (returnDetails) {
754              resolved.res = r;
755              resolved.usedParams = this.getUsedParamsDetails(opt);
756              return resolved;
757            }
758            return r;
759          }
760          if (keySeparator) {
761            const resTypeIsArray = Array.isArray(resForObjHndl);
762            const copy = resTypeIsArray ? [] : {};
763            const newKeyToUse = resTypeIsArray ? resExactUsedKey : resUsedKey;
764            for (const m in resForObjHndl) {
765              if (Object.prototype.hasOwnProperty.call(resForObjHndl, m)) {
766                const deepKey = `${newKeyToUse}${keySeparator}${m}`;
767                if (hasDefaultValue && !res) {
768                  copy[m] = this.translate(deepKey, {
769                    ...opt,
770                    defaultValue: shouldHandleAsObject(defaultValue) ? defaultValue[m] : undefined,
771                    ...{
772                      joinArrays: false,
773                      ns: namespaces
774                    }
775                  });
776                } else {
777                  copy[m] = this.translate(deepKey, {
778                    ...opt,
779                    ...{
780                      joinArrays: false,
781                      ns: namespaces
782                    }
783                  });
784                }
785                if (copy[m] === deepKey) copy[m] = resForObjHndl[m];
786              }
787            }
788            res = copy;
789          }
790        } else if (handleAsObjectInI18nFormat && isString(joinArrays) && Array.isArray(res)) {
791          res = res.join(joinArrays);
792          if (res) res = this.extendTranslation(res, keys, opt, lastKey);
793        } else {
794          let usedDefault = false;
795          let usedKey = false;
796          if (!this.isValidLookup(res) && hasDefaultValue) {
797            usedDefault = true;
798            res = defaultValue;
799          }
800          if (!this.isValidLookup(res)) {
801            usedKey = true;
802            res = key;
803          }
804          const missingKeyNoValueFallbackToKey = opt.missingKeyNoValueFallbackToKey || this.options.missingKeyNoValueFallbackToKey;
805          const resForMissing = missingKeyNoValueFallbackToKey && usedKey ? undefined : res;
806          const updateMissing = hasDefaultValue && defaultValue !== res && this.options.updateMissing;
807          if (usedKey || usedDefault || updateMissing) {
808            this.logger.log(updateMissing ? 'updateKey' : 'missingKey', lng, namespace, key, updateMissing ? defaultValue : res);
809            if (keySeparator) {
810              const fk = this.resolve(key, {
811                ...opt,
812                keySeparator: false
813              });
814              if (fk && fk.res) this.logger.warn('Seems the loaded translations were in flat JSON format instead of nested. Either set keySeparator: false on init or make sure your translations are published in nested format.');
815            }
816            let lngs = [];
817            const fallbackLngs = this.languageUtils.getFallbackCodes(this.options.fallbackLng, opt.lng || this.language);
818            if (this.options.saveMissingTo === 'fallback' && fallbackLngs && fallbackLngs[0]) {
819              for (let i = 0; i < fallbackLngs.length; i++) {
820                lngs.push(fallbackLngs[i]);
821              }
822            } else if (this.options.saveMissingTo === 'all') {
823              lngs = this.languageUtils.toResolveHierarchy(opt.lng || this.language);
824            } else {
825              lngs.push(opt.lng || this.language);
826            }
827            const send = (l, k, specificDefaultValue) => {
828              const defaultForMissing = hasDefaultValue && specificDefaultValue !== res ? specificDefaultValue : resForMissing;
829              if (this.options.missingKeyHandler) {
830                this.options.missingKeyHandler(l, namespace, k, defaultForMissing, updateMissing, opt);
831              } else if (this.backendConnector?.saveMissing) {
832                this.backendConnector.saveMissing(l, namespace, k, defaultForMissing, updateMissing, opt);
833              }
834              this.emit('missingKey', l, namespace, k, res);
835            };
836            if (this.options.saveMissing) {
837              if (this.options.saveMissingPlurals && needsPluralHandling) {
838                lngs.forEach(language => {
839                  const suffixes = this.pluralResolver.getSuffixes(language, opt);
840                  if (needsZeroSuffixLookup && opt[`defaultValue${this.options.pluralSeparator}zero`] && suffixes.indexOf(`${this.options.pluralSeparator}zero`) < 0) {
841                    suffixes.push(`${this.options.pluralSeparator}zero`);
842                  }
843                  suffixes.forEach(suffix => {
844                    send([language], key + suffix, opt[`defaultValue${suffix}`] || defaultValue);
845                  });
846                });
847              } else {
848                send(lngs, key, defaultValue);
849              }
850            }
851          }
852          res = this.extendTranslation(res, keys, opt, resolved, lastKey);
853          if (usedKey && res === key && this.options.appendNamespaceToMissingKey) {
854            res = `${namespace}${nsSeparator}${key}`;
855          }
856          if ((usedKey || usedDefault) && this.options.parseMissingKeyHandler) {
857            res = this.options.parseMissingKeyHandler(this.options.appendNamespaceToMissingKey ? `${namespace}${nsSeparator}${key}` : key, usedDefault ? res : undefined, opt);
858          }
859        }
860        if (returnDetails) {
861          resolved.res = res;
862          resolved.usedParams = this.getUsedParamsDetails(opt);
863          return resolved;
864        }
865        return res;
866      }
867      extendTranslation(res, key, opt, resolved, lastKey) {
868        if (this.i18nFormat?.parse) {
869          res = this.i18nFormat.parse(res, {
870            ...this.options.interpolation.defaultVariables,
871            ...opt
872          }, opt.lng || this.language || resolved.usedLng, resolved.usedNS, resolved.usedKey, {
873            resolved
874          });
875        } else if (!opt.skipInterpolation) {
876          if (opt.interpolation) this.interpolator.init({
877            ...opt,
878            ...{
879              interpolation: {
880                ...this.options.interpolation,
881                ...opt.interpolation
882              }
883            }
884          });
885          const skipOnVariables = isString(res) && (opt?.interpolation?.ski

885pOnVariables !== undefined ? opt.interpolation.skipOnVariables : this.options.interpolation.skipOnVariables);
886          let nestBef;
887          if (skipOnVariables) {
888            const nb = res.match(this.interpolator.nestingRegexp);
889            nestBef = nb && nb.length;
890          }
891          let data = opt.replace && !isString(opt.replace) ? opt.replace : opt;
892          if (this.options.interpolation.defaultVariables) data = {
893            ...this.options.interpolation.defaultVariables,
894            ...data
895          };
896          res = this.interpolator.interpolate(res, data, opt.lng || this.language || resolved.usedLng, opt);
897          if (skipOnVariables) {
898            const na = res.match(this.interpolator.nestingRegexp);
899            const nestAft = na && na.length;
900            if (nestBef < nestAft) opt.nest = false;
901          }
902          if (!opt.lng && resolved && resolved.res) opt.lng = this.language || resolved.usedLng;
903          if (opt.nest !== false) res = this.interpolator.nest(res, (...args) => {
904            if (lastKey?.[0] === args[0] && !opt.context) {
905              this.logger.warn(`It seems you are nesting recursively key: ${args[0]} in key: ${key[0]}`);
906              return null;
907            }
908            return this.translate(...args, key);
909          }, opt);
910          if (opt.interpolation) this.interpolator.reset();
911        }
912        const postProcess = opt.postProcess || this.options.postProcess;
913        const postProcessorNames = isString(postProcess) ? [postProcess] : postProcess;
914        if (res != null && postProcessorNames?.length && opt.applyPostProcessor !== false) {
915          res = postProcessor.handle(postProcessorNames, res, key, this.options && this.options.postProcessPassResolved ? {
916            i18nResolved: {
917              ...resolved,
918              usedParams: this.getUsedParamsDetails(opt)
919            },
920            ...opt
921          } : opt, this);
922        }
923        return res;
924      }
925      resolve(keys, opt = {}) {
926        let found;
927        let usedKey;
928        let exactUsedKey;
929        let usedLng;
930        let usedNS;
931        if (isString(keys)) keys = [keys];
932        if (Array.isArray(keys)) keys = keys.map(k => typeof k === 'function' ? keysFromSelector(k, {
933          ...this.options,
934          ...opt
935        }) : k);
936        keys.forEach(k => {
937          if (this.isValidLookup(found)) return;
938          const extracted = this.extractFromKey(k, opt);
939          const key = extracted.key;
940          usedKey = key;
941          let namespaces = extracted.namespaces;
942          if (this.options.fallbackNS) namespaces = namespaces.concat(this.options.fallbackNS);
943          const needsPluralHandling = opt.count !== undefined && !isString(opt.count);
944          const needsZeroSuffixLookup = needsPluralHandling && !opt.ordinal && opt.count === 0;
945          const needsContextHandling = opt.context !== undefined && (isString(opt.context) || typeof opt.context === 'number') && opt.context !== '';
946          const codes = opt.lngs ? opt.lngs : this.languageUtils.toResolveHierarchy(opt.lng || this.language, opt.fallbackLng);
947          namespaces.forEach(ns => {
948            if (this.isValidLookup(found)) return;
949            usedNS = ns;
950            if (!checkedLoadedFor[`${codes[0]}-${ns}`] && this.utils?.hasLoadedNamespace && !this.utils?.hasLoadedNamespace(usedNS)) {
951              checkedLoadedFor[`${codes[0]}-${ns}`] = true;
952              this.logger.warn(`key "${usedKey}" for languages "${codes.join(', ')}" won't get resolved as namespace "${usedNS}" was not yet loaded`, 'This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!');
953            }
954            codes.forEach(code => {
955              if (this.isValidLookup(found)) return;
956              usedLng = code;
957              const finalKeys = [key];
958              if (this.i18nFormat?.addLookupKeys) {
959                this.i18nFormat.addLookupKeys(finalKeys, key, code, ns, opt);
960              } else {
961                let pluralSuffix;
962                if (needsPluralHandling) pluralSuffix = this.pluralResolver.getSuffix(code, opt.count, opt);
963                const zeroSuffix = `${this.options.pluralSeparator}zero`;
964                const ordinalPrefix = `${this.options.pluralSeparator}ordinal${this.options.pluralSeparator}`;
965                if (needsPluralHandling) {
966                  if (opt.ordinal && pluralSuffix.indexOf(ordinalPrefix) === 0) {
967                    finalKeys.push(key + pluralSuffix.replace(ordinalPrefix, this.options.pluralSeparator));
968                  }
969                  finalKeys.push(key + pluralSuffix);
970                  if (needsZeroSuffixLookup) {
971                    finalKeys.push(key + zeroSuffix);
972                  }
973                }
974                if (needsContextHandling) {
975                  const contextKey = `${key}${this.options.contextSeparator || '_'}${opt.context}`;
976                  finalKeys.push(contextKey);
977                  if (needsPluralHandling) {
978                    if (opt.ordinal && pluralSuffix.indexOf(ordinalPrefix) === 0) {
979                      finalKeys.push(contextKey + pluralSuffix.replace(ordinalPrefix, this.options.pluralSeparator));
980                    }
981                    finalKeys.push(contextKey + pluralSuffix);
982                    if (needsZeroSuffixLookup) {
983                      finalKeys.push(contextKey + zeroSuffix);
984                    }
985                  }
986                }
987              }
988              let possibleKey;
989              while (possibleKey = finalKeys.pop()) {
990                if (!this.isValidLookup(found)) {
991                  exactUsedKey = possibleKey;
992                  found = this.getResource(code, ns, possibleKey, opt);
993                }
994              }
995            });
996          });
997        });
998        return {
999          res: found,
1000          usedKey,
1001          exactUsedKey,
1002          usedLng,
1003          usedNS
1004        };
1005      }
1006      isValidLookup(res) {
1007        return res !== undefined && !(!this.options.returnNull && res === null) && !(!this.options.returnEmptyString && res === '');
1008      }
1009      getResource(code, ns, key, options = {}) {
1010        if (this.i18nFormat?.getResource) return this.i18nFormat.getResource(code, ns, key, options);
1011        return this.resourceStore.getResource(code, ns, key, options);
1012      }
1013      getUsedParamsDetails(options = {}) {
1014        const optionsKeys = ['defaultValue', 'ordinal', 'context', 'replace', 'lng', 'lngs', 'fallbackLng', 'ns', 'keySeparator', 'nsSeparator', 'returnObjects', 'returnDetails', 'joinArrays', 'postProcess', 'interpolation'];
1015        const useOptionsReplaceForData = options.replace && !isString(options.replace);
1016        let data = useOptionsReplaceForData ? options.replace : options;
1017        if (useOptionsReplaceForData && typeof options.count !== 'undefined') {
1018          data.count = options.count;
1019        }
1020        if (this.options.interpolation.defaultVariables) {
1021          data = {
1022            ...this.options.interpolation.defaultVariables,
1023            ...data
1024          };
1025        }
1026        if (!useOptionsReplaceForData) {
1027          data = {
1028            ...data
1029          };
1030          for (const key of optionsKeys) {
1031            delete data[key];
1032          }
1033        }
1034        return data;
1035      }
1036      static hasDefaultValue(options) {
1037        const prefix = 'defaultValue';
1038        for (const option in options) {
1039          if (Object.prototype.hasOwnProperty.call(options, option) && prefix === option.substring(0, prefix.length) && undefined !== options[option]) {
1040            return true;
1041          }
1042        }
1043        return false;

1044      }
1045    }
1046
1047    class LanguageUtil {
1048      constructor(options) {
1049        this.options = options;
1050        this.supportedLngs = this.options.supportedLngs || false;
1051        this.logger = baseLogger.create('languageUtils');
1052      }
1053      getScriptPartFromCode(code) {
1054        code = getCleanedCode(code);
1055        if (!code || code.indexOf('-') < 0) return null;
1056        const p = code.split('-');
1057        if (p.length === 2) return null;
1058        p.pop();
1059        if (p[p.length - 1].toLowerCase() === 'x') return null;
1060        return this.formatLanguageCode(p.join('-'));
1061      }
1062      getLanguagePartFromCode(code) {
1063        code = getCleanedCode(code);
1064        if (!code || code.indexOf('-') < 0) return code;
1065        const p = code.split('-');
1066        return this.formatLanguageCode(p[0]);
1067      }
1068      formatLanguageCode(code) {
1069        if (isString(code) && code.indexOf('-') > -1) {
1070          let formattedCode;
1071          try {
1072            formattedCode = Intl.getCanonicalLocales(code)[0];
1073          } catch (e) {}
1074          if (formattedCode && this.options.lowerCaseLng) {
1075            formattedCode = formattedCode.toLowerCase();
1076          }
1077          if (formattedCode) return formattedCode;
1078          if (this.options.lowerCaseLng) {
1079            return code.toLowerCase();
1080          }
1081          return code;
1082        }
1083        return this.options.cleanCode || this.options.lowerCaseLng ? code.toLowerCase() : code;
1084      }
1085      isSupportedCode(code) {
1086        if (this.options.load === 'languageOnly' || this.options.nonExplicitSupportedLngs) {
1087          code = this.getLanguagePartFromCode(code);
1088        }
1089        return !this.supportedLngs || !this.supportedLngs.length || this.supportedLngs.indexOf(code) > -1;
1090      }
1091      getBestMatchFromCodes(codes) {
1092        if (!codes) return null;
1093        let found;
1094        codes.forEach(code => {
1095          if (found) return;
1096          const cleanedLng = this.formatLanguageCode(code);
1097          if (!this.options.supportedLngs || this.isSupportedCode(cleanedLng)) found = cleanedLng;
1098        });
1099        if (!found && this.options.supportedLngs) {
1100          codes.forEach(code => {
1101            if (found) return;
1102            const lngScOnly = this.getScriptPartFromCode(code);
1103            if (this.isSupportedCode(lngScOnly)) return found = lngScOnly;
1104            const lngOnly = this.getLanguagePartFromCode(code);
1105            if (this.isSupportedCode(lngOnly)) return found = lngOnly;
1106            found = this.options.supportedLngs.find(supportedLng => {
1107              if (supportedLng === lngOnly) return supportedLng;
1108              if (supportedLng.indexOf('-') < 0 && lngOnly.indexOf('-') < 0) return;
1109              if (supportedLng.indexOf('-') > 0 && lngOnly.indexOf('-') < 0 && supportedLng.substring(0, supportedLng.indexOf('-')) === lngOnly) return supportedLng;
1110              if (supportedLng.indexOf(lngOnly) === 0 && lngOnly.length > 1) return supportedLng;
1111            });
1112          });
1113        }
1114        if (!found) found = this.getFallbackCodes(this.options.fallbackLng)[0];
1115        return found;
1116      }
1117      getFallbackCodes(fallbacks, code) {
1118        if (!fallbacks) return [];
1119        if (typeof fallbacks === 'function') fallbacks = fallbacks(code);
1120        if (isString(fallbacks)) fallbacks = [fallbacks];
1121        if (Array.isArray(fallbacks)) return fallbacks;
1122        if (!code) return fallbacks.default || [];
1123        let found = fallbacks[code];
1124        if (!found) found = fallbacks[this.getScriptPartFromCode(code)];
1125        if (!found) found = fallbacks[this.formatLanguageCode(code)];
1126        if (!found) found = fallbacks[this.getLanguagePartFromCode(code)];
1127        if (!found) found = fallbacks.default;
1128        return found || [];
1129      }
1130      toResolveHierarchy(code, fallbackCode) {
1131        const fallbackCodes = this.getFallbackCodes((fallbackCode === false ? [] : fallbackCode) || this.options.fallbackLng || [], code);
1132        const codes = [];
1133        const addCode = c => {
1134          if (!c) return;
1135          if (this.isSupportedCode(c)) {
1136            codes.push(c);
1137          } else {
1138            this.logger.warn(`rejecting language code not found in supportedLngs: ${c}`);
1139          }
1140        };
1141        if (isString(code) && (code.indexOf('-') > -1 || code.indexOf('_') > -1)) {
1142          if (this.options.load !== 'languageOnly') addCode(this.formatLanguageCode(code));
1143          if (this.options.load !== 'languageOnly' && this.options.load !== 'currentOnly') addCode(this.getScriptPartFromCode(code));
1144          if (this.options.load !== 'currentOnly') addCode(this.getLanguagePartFromCode(code));
1145        } else if (isString(code)) {
1146          addCode(this.formatLanguageCode(code));
1147        }

1148        fallbackCodes.forEach(fc => {
1149          if (codes.indexOf(fc) < 0) addCode(this.formatLanguageCode(fc));
1150        });
1151        return codes;
1152      }
1153    }
1154
1155    const suffixesOrder = {
1156      zero: 0,
1157      one: 1,
1158      two: 2,
1159      few: 3,
1160      many: 4,
1161      other: 5
1162    };
1163    const dummyRule = {
1164      select: count => count === 1 ? 'one' : 'other',
1165      resolvedOptions: () => ({
1166        pluralCategories: ['one', 'other']
1167      })
1168    };
1169    class PluralResolver {
1170      constructor(languageUtils, options = {}) {
1171        this.languageUtils = languageUtils;
1172        this.options = options;
1173        this.logger = baseLogger.create('pluralResolver');
1174        this.pluralRulesCache = {};
1175      }
1176      clearCache() {
1177        this.pluralRulesCache = {};
1178      }
1179      getRule(code, options = {}) {
1180        const cleanedCode = getCleanedCode(code === 'dev' ? 'en' : code);
1181        const type = options.ordinal ? 'ordinal' : 'cardinal';
1182        const cacheKey = JSON.stringify({
1183          cleanedCode,
1184          type
1185        });
1186        if (cacheKey in this.pluralRulesCache) {
1187          return this.pluralRulesCache[cacheKey];
1188        }
1189        let rule;
1190        try {
1191          rule = new Intl.PluralRules(cleanedCode, {
1192            type
1193          });
1194        } catch (err) {
1195          if (typeof Intl === 'undefined') {
1196            this.logger.error('No Intl support, please use an Intl polyfill!');
1197            return dummyRule;
1198          }
1199          if (!code.match(/-|_/)) return dummyRule;
1200          const lngPart = this.languageUtils.getLanguagePartFromCode(code);
1201          rule = this.getRule(lngPart, options);
1202        }
1203        this.pluralRulesCache[cacheKey] = rule;
1204        return rule;
1205      }
1206      needsPlural(code, options = {}) {
1207        let rule = this.getRule(code, options);
1208        if (!rule) rule = this.getRule('dev', options);
1209        return rule?.resolvedOptions().pluralCategories.length > 1;
1210      }
1211      getPluralFormsOfKey(code, key, options = {}) {
1212        return this.getSuffixes(code, options).map(suffix => `${key}${suffix}`);
1213      }
1214      getSuffixes(code, options = {}) {
1215        let rule = this.getRule(code, options);
1216        if (!rule) rule = this.getRule('dev', options);
1217        if (!rule) return [];
1218        return rule.resolvedOptions().pluralCategories.sort((pluralCategory1, pluralCategory2) => suffixesOrder[pluralCategory1] - suffixesOrder[pluralCategory2]).map(pluralCategory => `${this.options.prepend}${options.ordinal ? `ordinal${this.options.prepend}` : ''}${pluralCategory}`);
1219      }
1220      getSuffix(code, count, options = {}) {
1221        const rule = this.getRule(code, options);
1222        if (rule) {
1223          return `${this.options.prepend}${options.ordinal ? `ordinal${this.options.prepend}` : ''}${rule.select(count)}`;
1224        }
1225        this.logger.warn(`no plural rule found for: ${code}`);
1226        return this.getSuffix('dev', count, options);
1227      }
1228    }
1229
1230    const deepFindWithDefaults = (data, defaultData, key, keySeparator = '.', ignoreJSONStructure = true) => {
1231      let path = getPathWithDefaults(data, defaultData, key);
1232      if (!path && ignoreJSONStructure && isString(key)) {

1233        path = deepFind(data, key, keySeparator);
1234        if (path === undefined) path = deepFind(defaultData, key, keySeparator);
1235      }
1236      return path;
1237    };
1238    const regexSafe = val => val.replace(/\$/g, '$$$$');
1239    class Interpolator {
1240      constructor(options = {}) {
1241        this.logger = baseLogger.create('interpolator');
1242        this.options = options;
1243        this.format = options?.interpolation?.format || (value => value);
1244        this.init(options);
1245      }
1246      init(options = {}) {
1247        if (!options.interpolation) options.interpolation = {
1248          escapeValue: true
1249        };
1250        const {
1251          escape: escape$1$1,
1252          escapeValue,
1253          useRawValueToEscape,
1254          prefix,
1255          prefixEscaped,
1256          suffix,
1257          suffixEscaped,
1258          formatSeparator,
1259          unescapeSuffix,
1260          unescapePrefix,
1261          nestingPrefix,
1262          nestingPrefixEscaped,
1263          nestingSuffix,
1264          nestingSuffixEscaped,
1265          nestingOptionsSeparator,
1266          maxReplaces,
1267          alwaysFormat
1268        } = options.interpolation;
1269        this.escape = escape$1$1 !== undefined ? escape$1$1 : escape$1;
1270        this.escapeValue = escapeValue !== undefined ? escapeValue : true;
1271        this.useRawValueToEscape = useRawValueToEscape !== undefined ? useRawValueToEscape : false;

1272        this.prefix = prefix ? regexEscape(prefix) : prefixEscaped || '{{';
1273        this.suffix = suffix ? regexEscape(suffix) : suffixEscaped || '}}';
1274        this.formatSeparator = formatSeparator || ',';
1275        this.unescapePrefix = unescapeSuffix ? '' : unescapePrefix || '-';
1276        this.unescapeSuffix = this.unescapePrefix ? '' : unescapeSuffix || '';
1277        this.nestingPrefix = nestingPrefix ? regexEscape(nestingPrefix) : nestingPrefixEscaped || regexEscape('$t(');
1278        this.nestingSuffix = nestingSuffix ? regexEscape(nestingSuffix) : nestingSuffixEscaped || regexEscape(')');
1279        this.nestingOptionsSeparator = nestingOptionsSeparator || ',';
1280        this.maxReplaces = maxReplaces || 1000;
1281        this.alwaysFormat = alwaysFormat !== undefined ? alwaysFormat : false;
1282        this.resetRegExp();
1283      }
1284      reset() {
1285        if (this.options) this.init(this.options);
1286      }
1287      resetRegExp() {
1288        const getOrResetRegExp = (existingRegExp, pattern) => {
1289          if (existingRegExp?.source === pattern) {
1290            existingRegExp.lastIndex = 0;
1291            return existingRegExp;
1292          }
1293          return new RegExp(pattern, 'g');
1294        };
1295        this.regexp = getOrResetRegExp(this.regexp, `${this.prefix}(.+?)${this.suffix}`);
1296        this.regexpUnescape = getOrResetRegExp(this.regexpUnescape, `${this.prefix}${this.unescapePrefix}(.+?)${this.unescapeSuffix}${this.suffix}`);
1297        this.nestingRegexp = getOrResetRegExp(this.nestingRegexp, `${this.nestingPrefix}((?:[^()"']+|"[^"]*"|'[^']*'|\\((?:[^()]|"[^"]*"|'[^']*')*\\))*?)${this.nestingSuffix}`);
1298      }
1299      interpolate(str, data, lng, options) {
1300        let match;
1301        let value;
1302        let replaces;
1303        const defaultData = this.options && this.options.interpolation && this.options.interpolation.defaultVariables || {};
1304        const handleFormat = key => {
1305          if (key.indexOf(this.formatSeparator) < 0) {
1306            const path = deepFindWithDefaults(data, defaultData, key, this.options.keySeparator, this.options.ignoreJSONStructure);
1307            return this.alwaysFormat ? this.format(path, undefined, lng, {
1308              ...options,
1309              ...data,
1310              interpolationkey: key
1311            }) : path;
1312          }
1313          const p = key.split(this.formatSeparator);
1314          const k = p.shift().trim();
1315          const f = p.join(this.formatSeparator).trim();
1316          return this.format(deepFindWithDefaults(data, defaultData, k, this.options.keySeparator, this.options.ignoreJSONStructure), f, lng, {
1317            ...options,
1318            ...data,
1319            interpolationkey: k
1320          });
1321        };
1322        this.resetRegExp();
1323        const missingInterpolationHandler = options?.missingInterpolationHandler || this.options.missingInterpolationHandler;
1324        const skipOnVariables = options?.interpolation?.skipOnVariables !== undefined ? options.interpolation.skipOnVariables : this.options.interpolation.skipOnVariables;
1325        const todos = [{
1326          regex: this.regexpUnescape,
1327          safeValue: val => regexSafe(val)
1328        }, {
1329          regex: this.regexp,
1330          safeValue: val => this.escapeValue ? regexSafe(this.escape(val)) : regexSafe(val)
1331        }];
1332        todos.forEach(todo => {
1333          replaces = 0;
1334          while (match = todo.regex.exec(str)) {
1335            const matchedVar = match[1].trim();
1336            value = handleFormat(matchedVar);
1337            if (value === undefined) {
1338              if (typeof missingInterpolationHandler === 'function') {
1339                const temp = missingInterpolationHandler(str, match, options);
1340                value = isString(temp) ? temp : '';
1341              } else if (options && Object.prototype.hasOwnProperty.call(options, matchedVar)) {
1342                value = '';
1343              } else if (skipOnVariables) {
1344                value = match[0];
1345                continue;
1346              } else {
1347                this.logger.warn(`missed to pass in variable ${matchedVar} for interpolating ${str}`);
1348                value = '';
1349              }
1350            } else if (!isString(value) && !this.useRawValueToEscape) {
1351              value = makeString(value);
1352            }
1353            const safeValue = todo.safeValue(value);
1354            str = str.replace(match[0], safeValue);
1355            if (skipOnVariables) {
1356              todo.regex.lastIndex += value.length;
1357              todo.regex.lastIndex -= match[0].length;
1358            } else {
1359              todo.regex.lastIndex = 0;
1360            }
1361            replaces++;
1362            if (replaces >= this.maxReplaces) {
1363              break;
1364            }
1365          }
1366        });
1367        return str;
1368      }
1369      nest(str, fc, options = {}) {
1370        let match;
1371        let value;
1372        let clonedOptions;
1373        const handleHasOptions = (key, inheritedOptions) => {
1374          const sep = this.nestingOptionsSeparator;
1375          if (key.indexOf(sep) < 0) return key;
1376          const c = key.split(new RegExp(`${regexEscape(sep)}[ ]*{`));
1377          let optionsString = `{${c[1]}`;
1378          key = c[0];
1379          optionsString = this.interpolate(optionsString, clonedOptions);
1380          const matchedSingleQuotes = optionsString.match(/'/g);
1381          const matchedDoubleQuotes = optionsString.match(/"/g);
1382          if ((matchedSingleQuotes?.length ?? 0) % 2 === 0 && !matchedDoubleQuotes || (matchedDoubleQuotes?.length ?? 0) % 2 !== 0) {
1383            optionsString = optionsString.replace(/'/g, '"');
1384          }
1385          try {
1386            clonedOptions = JSON.parse(optionsString);
1387            if (inheritedOptions) clonedOptions = {
1388              ...inheritedOptions,
1389              ...clonedOptions
1390            };
1391          } catch (e) {
1392            this.logger.warn(`failed parsing options string in nesting for key ${key}`, e);
1393            return `${key}${sep}${optionsString}`;
1394          }
1395          if (clonedOptions.defaultValue && clonedOptions.defaultValue.indexOf(this.prefix) > -1) delete clonedOptions.defaultValue;
1396          return key;
1397        };
1398        while (match = this.nestingRegexp.exec(str)) {
1399          let formatters = [];
1400          clonedOptions = {
1401            ...options
1402          };
1403          clonedOptions = clonedOptions.replace && !isString(clonedOptions.replace) ? clonedOptions.replace : clonedOptions;
1404          clonedOptions.applyPostProcessor = false;

1405          delete clonedOptions.defaultValue;
1406          const keyEndIndex = /{.*}/.test(match[1]) ? match[1].lastIndexOf('}') + 1 : match[1].indexOf(this.formatSeparator);
1407          if (keyEndIndex !== -1) {
1408            formatters = match[1].slice(keyEndIndex).split(this.formatSeparator).map(elem => elem.trim()).filter(Boolean);
1409            match[1] = match[1].slice(0, keyEndIndex);
1410          }
1411          value = fc(handleHasOptions.call(this, match[1].trim(), clonedOptions), clonedOptions);
1412          if (value && match[0] === str && !isString(value)) return value;
1413          if (!isString(value)) value = makeString(value);
1414          if (!value) {
1415            this.logger.warn(`missed to resolve ${match[1]} for nesting ${str}`);
1416            value = '';
1417          }
1418          if (formatters.length) {
1419            value = formatters.reduce((v, f) => this.format(v, f, options.lng, {
1420              ...options,
1421              interpolationkey: match[1].trim()
1422            }), value.trim());
1423          }
1424          str = str.replace(match[0], value);
1425          this.regexp.lastIndex = 0;
1426        }
1427        return str;
1428      }
1429    }
1430
1431    const parseFormatStr = formatStr => {
1432      let formatName = formatStr.toLowerCase().trim();
1433      const formatOptions = {};
1434      if (formatStr.indexOf('(') > -1) {
1435        const p = formatStr.split('(');
1436        formatName = p[0].toLowerCase().trim();
1437        const optStr = p[1].substring(0, p[1].length - 1);
1438        if (formatName === 'currency' && optStr.indexOf(':') < 0) {
1439          if (!formatOptions.currency) formatOptions.currency = optStr.trim();
1440        } else if (formatName === 'relativetime' && optStr.indexOf(':') < 0) {
1441          if (!formatOptions.range) formatOptions.range = optStr.trim();
1442        } else {
1443          const opts = optStr.split(';');
1444          opts.forEach(opt => {
1445            if (opt) {
1446              const [key, ...rest] = opt.split(':');
1447              const val = rest.join(':').trim().replace(/^'+|'+$/g, '');
1448              const trimmedKey = key.trim();
1449              if (!formatOptions[trimmedKey]) formatOptions[trimmedKey] = val;
1450              if (val === 'false') formatOptions[trimmedKey] = false;
1451              if (val === 'true') formatOptions[trimmedKey] = true;
1452              if (!isNaN(val)) formatOptions[trimmedKey] = parseInt(val, 10);
1453            }
1454          });
1455        }
1456      }
1457      return {
1458        formatName,
1459        formatOptions
1460      };
1461    };
1462    const createCachedFormatter = fn => {
1463      const cache = {};
1464      return (v, l, o) => {
1465        let optForCache = o;
1466        if (o && o.interpolationkey && o.formatParams && o.formatParams[o.interpolationkey] && o[o.interpolationkey]) {
1467          optForCache = {
1468            ...optForCache,
1469            [o.interpolationkey]: undefined
1470          };
1471        }
1472        const key = l + JSON.stringify(optForCache);
1473        let frm = cache[key];
1474        if (!frm) {
1475          frm = fn(getCleanedCode(l), o);
1476          cache[key] = frm;
1477        }
1478        return frm(v);
1479      };
1480    };
1481    const createNonCachedFormatter = fn => (v, l, o) => fn(getCleanedCode(l), o)(v);
1482    class Formatter {
1483      constructor(options = {}) {
1484        this.logger = baseLogger.create('formatter');
1485        this.options = options;
1486        this.init(options);
1487      }
1488      init(services, options = {
1489        interpolation: {}
1490      }) {
1491        this.formatSeparator = options.interpolation.formatSeparator || ',';
1492        const cf = options.cacheInBuiltFormats ? createCachedFormatter : createNonCachedFormatter;
1493        this.formats = {
1494          number: cf((lng, opt) => {
1495            const formatter = new Intl.NumberFormat(lng, {
1496              ...opt
1497            });
1498            return val => formatter.format(val);
1499          }),
1500          currency: cf((lng, opt) => {
1501            const formatter = new Intl.NumberFormat(lng, {
1502              ...opt,
1503              style: 'currency'
1504            });
1505            return val => formatter.format(val);
1506          }),
1507          datetime: cf((lng, opt) => {
1508            const formatter = new Intl.DateTimeFormat(lng, {
1509              ...opt
1510            });
1511            return val => formatter.format(val);
1512          }),
1513          relativetime: cf((lng, opt) => {
1514            const formatter = new Intl.RelativeTimeFormat(lng, {
1515              ...opt
1516            });
1517            return val => formatter.format(val, opt.range || 'day');
1518          }),
1519          list: cf((lng, opt) => {
1520            const formatter = new Intl.ListFormat(lng, {
1521              ...opt
1522            });
1523            return val => formatter.format(val);
1524          })
1525        };
1526      }
1527      add(name, fc) {
1528        this.formats[name.toLowerCase().trim()] = fc;
1529      }
1530      addCached(name, fc) {
1531        this.formats[name.toLowerCase().trim()] = createCachedFormatter(fc);
1532      }
1533      format(value, format, lng, options = {}) {
1534        const formats = format.split(this.formatSeparator);
1535        if (formats.length > 1 && formats[0].indexOf('(') > 1 && formats[0].indexOf(')') < 0 && formats.find(f => f.indexOf(')') > -1)) {
1536          const lastIndex = formats.findIndex(f => f.indexOf(')') > -1);
1537          formats[0] = [formats[0], ...formats.splice(1, lastIndex)].join(this.formatSeparator);
1538        }
1539        const result = formats.reduce((mem, f) => {
1540          const {
1541            formatName,
1542            formatOptions
1543          } = parseFormatStr(f);
1544          if (this.formats[formatName]) {
1545            let formatted = mem;
1546            try {
1547              const valOptions = options?.formatParams?.[options.interpolationkey] || {};
1548              const l = valOptions.locale || valOptions.lng || options.locale || options.lng || lng;
1549              formatted = this.formats[formatName](mem, l, {
1550                ...formatOptions,
1551                ...options,
1552                ...valOptions
1553              });
1554            } catch (error) {
1555              this.logger.warn(error);
1556            }
1557            return formatted;
1558          } else {
1559            this.logger.warn(`there was no format function for ${formatName}`);
1560          }
1561          return mem;
1562        }, value);
1563        return result;
1564      }
1565    }
1566
1567    const removePending = (q, name) => {
1568      if (q.pending[name] !== undefined) {
1569        delete q.pending[name];
1570        q.pendingCount--;
1571      }
1572    };
1573    class Connector extends EventEmitter {
1574      constructor(backend, store, services, options = {}) {
1575        super();
1576        this.backend = backend;
1577        this.store = store;
1578        this.services = services;
1579        this.languageUtils = services.languageUtils;
1580        this.options = options;
1581        this.logger = baseLogger.create('backendConnector');
1582        this.waitingReads = [];
1583        this.maxParallelReads = options.maxParallelReads || 10;
1584        this.readingCalls = 0;
1585        this.maxRetries = options.maxRetries >= 0 ? options.maxRetries : 5;
1586        this.retryTimeout = options.retryTimeout >= 1 ? options.retryTimeout : 350;
1587        this.state = {};
1588        this.queue = [];
1589        this.backend?.init?.(services, options.backend, options);
1590      }
1591      queueLoad(languages, namespaces, options, callback) {
1592        const toLoad = {};
1593        const pending = {};
1594        const toLoadLanguages = {};
1595        const toLoadNamespaces = {};
1596        languages.forEach(lng => {
1597          let hasAllNamespaces = true;
1598          namespaces.forEach(ns => {
1599            const name = `${lng}|${ns}`;
1600            if (!options.reload && this.store.hasResourceBundle(lng, ns)) {
1601              this.state[name] = 2;
1602            } else if (this.state[name] < 0) ; else if (this.state[name] === 1) {
1603              if (pending[name] === undefined) pending[name] = true;
1604            } else {
1605              this.state[name] = 1;
1606              hasAllNamespaces = false;
1607              if (pending[name] === undefined) pending[name] = true;
1608              if (toLoad[name] === undefined) toLoad[name] = true;
1609              if (toLoadNamespaces[ns] === undefined) toLoadNamespaces[ns] = true;
1610            }
1611          });
1612          if (!hasAllNamespaces) toLoadLanguages[lng] = true;
1613        });
1614        if (Object.keys(toLoad).length || Object.keys(pending).length) {
1615          this.queue.push({
1616            pending,
1617            pendingCount: Object.keys(pending).length,
1618            loaded: {},
1619            errors: [],
1620            callback
1621          });
1622        }
1623        return {
1624          toLoad: Object.keys(toLoad),
1625          pending: Object.keys(pending),
1626          toLoadLanguages: Object.keys(toLoadLanguages),
1627          toLoadNamespaces: Object.keys(toLoadNamespaces)
1628        };
1629      }
1630      loaded(name, err, data) {
1631        const s = name.split('|');
1632        const lng = s[0];
1633        const ns = s[1];
1634        if (err) this.emit('failedLoading', lng, ns, err);
1635        if (!err && data) {
1636          this.store.addResourceBundle(lng, ns, data, undefined, undefined, {
1637            skipCopy: true
1638          });
1639        }
1640        this.state[name] = err ? -1 : 2;
1641        if (err && data) this.state[name] = 0;
1642        const loaded = {};
1643        this.queue.forEach(q => {
1644          pushPath(q.loaded, [lng], ns);
1645          removePending(q, name);
1646          if (err) q.errors.push(err);
1647          if (q.pendingCount === 0 && !q.done) {
1648            Object.keys(q.loaded).forEach(l => {
1649              if (!loaded[l]) loaded[l] = {};
1650              const loadedKeys = q.loaded[l];
1651              if (loadedKeys.length) {
1652                loadedKeys.forEach(n => {
1653                  if (loaded[l][n] === undefined) loaded[l][n] = true;
1654                });
1655              }
1656            });
1657            q.done = true;
1658            if (q.errors.length) {
1659              q.callback(q.errors);
1660            } else {
1661              q.callback();
1662            }
1663          }
1664        });
1665        this.emit('loaded', loaded);
1666        this.queue = this.queue.filter(q => !q.done);
1667      }
1668      read(lng, ns, fcName, tried = 0, wait = this.retryTimeout, callback) {
1669        if (!lng.length) return callback(null, {});
1670        if (this.readingCalls >= this.maxParallelReads) {
1671          this.waitingReads.push({
1672            lng,
1673            ns,
1674            fcName,
1675            tried,
1676            wait,
1677            callback
1678          });
1679          return;
1680        }
1681        this.readingCalls++;
1682        const resolver = (err, data) => {
1683          this.readingCalls--;
1684          if (this.waitingReads.length > 0) {
1685            const next = this.waitingReads.shift();
1686            this.read(next.lng, next.ns, next.fcName, next.tried, next.wait, next.callback);
1687          }
1688          if (err && data && tried < this.maxRetries) {
1689            setTimeout(() => {
1690              this.read.call(this, lng, ns, fcName, tried + 1, wait * 2, callback);
1691            }, wait);
1692            return;
1693          }
1694          callback(err, data);
1695        };
1696        const fc = this.backend[fcName].bind(this.backend);
1697        if (fc.length === 2) {
1698          try {
1699            const r = fc(lng, ns);
1700            if (r && typeof r.then === 'function') {
1701              r.then(data => resolver(null, data)).catch(resolver);
1702            } else {
1703              resolver(null, r);
1704            }
1705          } catch (err) {
1706            resolver(err);
1707          }
1708          return;
1709        }
1710        return fc(lng, ns, resolver);
1711      }
1712      prepareLoading(languages, namespaces, options = {}, callback) {
1713        if (!this.backend) {
1714          this.logger.warn('No backend was added via i18next.use. Will not load resources.');
1715          return callback && callback();
1716        }
1717        if (isString(languages)) languages = this.languageUtils.toResolveHierarchy(languages);
1718        if (isString(namespaces)) namespaces = [namespaces];
1719        const toLoad = this.queueLoad(languages, namespaces, options, callback);
1720        if (!toLoad.toLoad.length) {
1721          if (!toLoad.pending.length) callback();
1722          return null;
1723        }
1724        toLoad.toLoad.forEach(name => {
1725          this.loadOne(name);
1726        });
1727      }
1728      load(languages, namespaces, callback) {
1729        this.prepareLoading(languages, namespaces, {}, callback);
1730      }
1731      reload(languages, namespaces, callback) {
1732        this.prepareLoading(languages, namespaces, {
1733          reload: true
1734        }, callback);
1735      }
1736      loadOne(name, prefix = '') {
1737        const s = name.split('|');
1738        const lng = s[0];
1739        const ns = s[1];
1740        this.read(lng, ns, 'read', undefined, undefined, (err, data) => {
1741          if (err) this.logger.warn(`${prefix}loading namespace ${ns} for language ${lng} failed`, err);
1742          if (!err && data) this.logger.log(`${prefix}loaded namespace ${ns} for language ${lng}`, data);
1743          this.loaded(name, err, data);
1744        });
1745      }
1746      saveMissing(languages, namespace, key, fallbackValue, isUpdate, options = {}, clb = () => {}) {
1747        if (this.services?.utils?.hasLoadedNamespace && !this.services?.utils?.hasLoadedNamespace(namespace)) {
1748          this.logger.warn(`did not save key "${key}" as the namespace "${namespace}" was not yet loaded`, 'This means something IS WRONG in your setup. You access the t function before i18next.init / i18next.loadNamespace / i18next.changeLanguage was done. Wait for the callback or Promise to resolve before accessing it!!!');
1749          return;
1750        }
1751        if (key === undefined || key === null || key === '') return;
1752        if (this.backend?.create) {
1753          const opts = {
1754            ...options,
1755            isUpdate
1756          };
1757          const fc = this.backend.create.bind(this.backend);
1758          if (fc.length < 6) {
1759            try {
1760              let r;
1761              if (fc.length === 5) {
1762                r = fc(languages, namespace, key, fallbackValue, opts);
1763              } else {
1764                r = fc(languages, namespace, key, fallbackValue);
1765              }
1766              if (r && typeof r.then === 'function') {
1767                r.then(data => clb(null, data)).catch(clb);
1768              } else {
1769                clb(null, r);
1770              }
1771            } catch (err) {
1772              clb(err);
1773            }
1774          } else {
1775            fc(languages, namespace, key, fallbackValue, clb, opts);
1776          }
1777        }
1778        if (!languages || !languages[0]) return;
1779        this.store.addResource(languages[0], namespace, key, fallbackValue);
1780      }
1781    }
1782
1783    const get$1 = () => ({
1784      debug: false,
1785      initAsync: true,
1786      ns: ['translation'],
1787      defaultNS: ['translation'],
1788      fallbackLng: ['dev'],
1789      fallbackNS: false,
1790      supportedLngs: false,
1791      nonExplicitSupportedLngs: false,
1792      load: 'all',
1793      preload: false,
1794      simplifyPluralSuffix: true,
1795      keySeparator: '.',
1796      nsSeparator: ':',
1797      pluralSeparator: '_',
1798      contextSeparator: '_',
1799      partialBundledLanguages: false,
1800      saveMissing: false,
1801      updateMissing: false,
1802      saveMissingTo: 'fallback',
1803      saveMissingPlurals: true,
1804      missingKeyHandler: false,
1805      missingInterpolationHandler: false,
1806      postProcess: false,
1807      postProcessPassResolved: false,
1808      returnNull: false,
1809      returnEmptyString: true,
1810      returnObjects: false,
1811      joinArrays: false,
1812      returnedObjectHandler: false,
1813      parseMissingKeyHandler: false,
1814      appendNamespaceToMissingKey: false,
1815      appendNamespaceToCIMode: false,
1816      overloadTranslationOptionHandler: args => {
1817        let ret = {};
1818        if (typeof args[1] === 'object') ret = args[1];
1819        if (isString(args[1])) ret.defaultValue = args[1];
1820        if (isString(args[2])) ret.tDescription = args[2];
1821        if (typeof args[2] === 'object' || typeof args[3] === 'object') {
1822          const options = args[3] || args[2];

1823          Object.keys(options).forEach(key => {
1824            ret[key] = options[key];
1825          });
1826        }
1827        return ret;
1828      },
1829      interpolation: {
1830        escapeValue: true,
1831        format: value => value,
1832        prefix: '{{',
1833        suffix: '}}',
1834        formatSeparator: ',',
1835        unescapePrefix: '-',
1836        nestingPrefix: '$t(',
1837        nestingSuffix: ')',
1838        nestingOptionsSeparator: ',',
1839        maxReplaces: 1000,
1840        skipOnVariables: true
1841      },
1842      cacheInBuiltFormats: true
1843    });
1844    const transformOptions = options => {
1845      if (isString(options.ns)) options.ns = [options.ns];
1846      if (isString(options.fallbackLng)) options.fallbackLng = [options.fallbackLng];
1847      if (isString(options.fallbackNS)) options.fallbackNS = [options.fallbackNS];
1848      if (options.supportedLngs?.indexOf?.('cimode') < 0) {
1849        options.supportedLngs = options.supportedLngs.concat(['cimode']);
1850      }
1851      if (typeof options.initImmediate === 'boolean') options.initAsync = options.initImmediate;
1852      return options;
1853    };
1854
1855    const noop = () => {};
1856    const bindMemberFunctions = inst => {
1857      const mems = Object.getOwnPropertyNames(Object.getPrototypeOf(inst));
1858      mems.forEach(mem => {
1859        if (typeof inst[mem] === 'function') {
1860          inst[mem] = inst[mem].bind(inst);
1861        }
1862      });
1863    };
1864    const SUPPORT_NOTICE_KEY = '__i18next_supportNoticeShown';
1865    const getSupportNoticeShown = () => {
1866      if (typeof globalThis !== 'undefined' && !!globalThis[SUPPORT_NOTICE_KEY]) return true;
1867      if (typeof process !== 'undefined' && process.env && process.env.I18NEXT_NO_SUPPORT_NOTICE) return true;
1868      if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'production') return true;
1869      return false;
1870    };
1871    const setSupportNoticeShown = () => {
1872      if (typeof globalThis !== 'undefined') globalThis[SUPPORT_NOTICE_KEY] = true;
1873    };
1874    const usesLocize = inst => {
1875      if (inst?.modules?.backend?.name?.indexOf('Locize') > 0) return true;
1876      if (inst?.modules?.backend?.constructor?.name?.indexOf('Locize') > 0) return true;
1877      if (inst?.options?.backend?.backends) {
1878        if (inst.options.backend.backends.some(b => b?.name?.indexOf('Locize') > 0 || b?.constructor?.name?.indexOf('Locize') > 0)) return true;
1879      }
1880      if (inst?.options?.backend?.projectId) return true;
1881      if (inst?.options?.backend?.backendOptions) {
1882        if (inst.options.backend.backendOptions.some(b => b?.projectId)) return true;
1883      }
1884      return false;
1885    };
1886    class I18n extends EventEmitter {
1887      constructor(options = {}, callback) {
1888        super();
1889        this.options = transformOptions(options);
1890        this.services = {};
1891        this.logger = baseLogger;
1892        this.modules = {
1893          external: []
1894        };
1895        bindMemberFunctions(this);
1896        if (callback && !this.isInitialized && !options.isClone) {
1897          if (!this.options.initAsync) {
1898            this.init(options, callback);
1899            return this;
1900          }
1901          setTimeout(() => {
1902            this.init(options, callback);
1903          }, 0);
1904        }
1905      }
1906      init(options = {}, callback) {
1907        this.isInitializing = true;
1908        if (typeof options === 'function') {
1909          callback = options;
1910          options = {};
1911        }
1912        if (options.defaultNS == null && options.ns) {
1913          if (isString(options.ns)) {
1914            options.defaultNS = options.ns;
1915          } else if (options.ns.indexOf('translation') < 0) {
1916            options.defaultNS = options.ns[0];
1917          }
1918        }
1919        const defOpts = get$1();
1920        this.options = {
1921          ...defOpts,
1922          ...this.options,
1923          ...transformOptions(options)
1924        };
1925        this.options.interpolation = {
1926          ...defOpts.interpolation,
1927          ...this.options.interpolation
1928        };
1929        if (options.keySeparator !== undefined) {
1930          this.options.userDefinedKeySeparator = options.keySeparator;
1931        }
1932        if (options.nsSeparator !== undefined) {
1933          this.options.userDefinedNsSeparator = options.nsSeparator;
1934        }
1935        if (typeof this.options.overloadTranslationOptionHandler !== 'function') {
1936          this.options.overloadTranslationOptionHandler = defOpts.overloadTranslationOptionHandler;
1937        }
1938        if (this.options.showSupportNotice !== false && !usesLocize(this) && !getSupportNoticeShown()) {
1939          if (typeof console !== 'undefined' && typeof console.info !== 'undefined') console.info('🌐 i18next is made possible by our own product, Locize — consider powering your project with managed localization (AI, CDN, integrations): https://locize.com 💙');
1940          setSupportNoticeShown();
1941        }
1942        const createClassOnDemand = ClassOrObject => {
1943          if (!ClassOrObject) return null;
1944          if (typeof ClassOrObject === 'function') return new ClassOrObject();
1945          return ClassOrObject;
1946        };
1947        if (!this.options.isClone) {
1948          if (this.modules.logger) {
1949            baseLogger.init(createClassOnDemand(this.modules.logger), this.options);
1950          } else {
1951            baseLogger.init(null, this.options);
1952          }
1953          let formatter;
1954          if (this.modules.formatter) {
1955            formatter = this.modules.formatter;
1956          } else {
1957            formatter = Formatter;
1958          }
1959          const lu = new LanguageUtil(this.options);
1960          this.store = new ResourceStore(this.options.resources, this.options);
1961          const s = this.services;

1962          s.logger = baseLogger;
1963          s.resourceStore = this.store;
1964          s.languageUtils = lu;
1965          s.pluralResolver = new PluralResolver(lu, {
1966            prepend: this.options.pluralSeparator,
1967            simplifyPluralSuffix: this.options.simplifyPluralSuffix
1968          });
1969          const usingLegacyFormatFunction = this.options.interpolation.format && this.options.interpolation.format !== defOpts.interpolation.format;
1970          if (usingLegacyFormatFunction) {
1971            this.logger.deprecate(`init: you are still using the legacy format function, please use the new approach: https://www.i18next.com/translation-function/formatting`);
1972          }
1973          if (formatter && (!this.options.interpolation.format || this.options.interpolation.format === defOpts.interpolation.format)) {
1974            s.formatter = createClassOnDemand(formatter);
1975            if (s.formatter.init) s.formatter.init(s, this.options);
1976            this.options.interpolation.format = s.formatter.format.bind(s.formatter);
1977          }
1978          s.interpolator = new Interpolator(this.options);
1979          s.utils = {
1980            hasLoadedNamespace: this.hasLoadedNamespace.bind(this)
1981          };
1982          s.backendConnector = new Connector(createClassOnDemand(this.modules.backend), s.resourceStore, s, this.options);
1983          s.backendConnector.on('*', (event, ...args) => {
1984            this.emit(event, ...args);
1985          });
1986          if (this.modules.languageDetector) {
1987            s.languageDetector = createClassOnDemand(this.modules.languageDetector);
1988            if (s.languageDetector.init) s.languageDetector.init(s, this.options.detection, this.options);
1989          }
1990          if (this.modules.i18nFormat) {
1991            s.i18nFormat = createClassOnDemand(this.modules.i18nFormat);
1992            if (s.i18nFormat.init) s.i18nFormat.init(this);
1993          }
1994          this.translator = new Translator(this.services, this.options);
1995          this.translator.on('*', (event, ...args) => {
1996            this.emit(event, ...args);
1997          });
1998          this.modules.external.forEach(m => {
1999            if (m.init) m.init(this);
2000          });
2001        }
2002        this.format = this.options.interpolation.format;
2003        if (!callback) callback = noop;
2004        if (this.options.fallbackLng && !this.services.languageDetector && !this.options.lng) {
2005          const codes = this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);
2006          if (codes.length > 0 && codes[0] !== 'dev') this.options.lng = codes[0];
2007        }
2008        if (!this.services.languageDetector && !this.options.lng) {
2009          this.logger.warn('init: no languageDetector is used and no lng is defined');
2010        }
2011        const storeApi = ['getResource', 'hasResourceBundle', 'getResourceBundle', 'getDataByLanguage'];
2012        storeApi.forEach(fcName => {
2013          this[fcName] = (...args) => this.store[fcName](...args);
2014        });
2015        const storeApiChained = ['addResource', 'addResources', 'addResourceBundle', 'removeResourceBundle'];
2016        storeApiChained.forEach(fcName => {
2017          this[fcName] = (...args) => {
2018            this.store[fcName](...args);
2019            return this;
2020          };
2021        });
2022        const deferred = defer();
2023        const load = () => {
2024          const finish = (err, t) => {
2025            this.isInitializing = false;
2026            if (this.isInitialized && !this.initializedStoreOnce) this.logger.warn('init: i18next is already initialized. You should call init just once!');
2027            this.isInitialized = true;
2028            if (!this.options.isClone) this.logger.log('initialized', this.options);
2029            this.emit('initialized', this.options);
2030            deferred.resolve(t);
2031            callback(err, t);
2032          };
2033          if (this.languages && !this.isInitialized) return finish(null, this.t.bind(this));
2034          this.changeLanguage(this.options.lng, finish);
2035        };
2036        if (this.options.resources || !this.options.initAsync) {
2037          load();
2038        } else {
2039          setTimeout(load, 0);
2040        }
2041        return deferred;
2042      }
2043      loadResources(language, callback = noop) {
2044        let usedCallback = callback;
2045        const usedLng = isString(language) ? language : this.language;
2046        if (typeof language === 'function') usedCallback = language;
2047        if (!this.options.resources || this.options.partialBundledLanguages) {
2048          if (usedLng?.toLowerCase() === 'cimode' && (!this.options.preload || this.options.preload.length === 0)) return usedCallback();
2049          const toLoad = [];
2050          const append = lng => {
2051            if (!lng) return;
2052            if (lng === 'cimode') return;
2053            const lngs = this.services.languageUtils.toResolveHierarchy(lng);

2054            lngs.forEach(l => {
2055              if (l === 'cimode') return;
2056              if (toLoad.indexOf(l) < 0) toLoad.push(l);
2057            });
2058          };
2059          if (!usedLng) {
2060            const fallbacks = this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);
2061            fallbacks.forEach(l => append(l));
2062          } else {
2063            append(usedLng);
2064          }
2065          this.options.preload?.forEach?.(l => append(l));
2066          this.services.backendConnector.load(toLoad, this.options.ns, e => {
2067            if (!e && !this.resolvedLanguage && this.language) this.setResolvedLanguage(this.language);
2068            usedCallback(e);
2069          });
2070        } else {
2071          usedCallback(null);
2072        }
2073      }
2074      reloadResources(lngs, ns, callback) {
2075        const deferred = defer();
2076        if (typeof lngs === 'function') {
2077          callback = lngs;
2078          lngs = undefined;
2079        }
2080        if (typeof ns === 'function') {
2081          callback = ns;
2082          ns = undefined;
2083        }
2084        if (!lngs) lngs = this.languages;
2085        if (!ns) ns = this.options.ns;
2086        if (!callback) callback = noop;
2087        this.services.backendConnector.reload(lngs, ns, err => {
2088          deferred.resolve();
2089          callback(err);
2090        });
2091        return deferred;
2092      }
2093      use(module) {
2094        if (!module) throw new Error('You are passing an undefined module! Please check the object you are passing to i18next.use()');
2095        if (!module.type) throw new Error('You are passing a wrong module! Please check the object you are passing to i18next.use()');
2096        if (module.type === 'backend') {
2097          this.modules.backend = module;
2098        }
2099        if (module.type === 'logger' || module.log && module.warn && module.error) {
2100          this.modules.logger = module;
2101        }
2102        if (module.type === 'languageDetector') {
2103          this.modules.languageDetector = module;
2104        }
2105        if (module.type === 'i18nFormat') {
2106          this.modules.i18nFormat = module;
2107        }
2108        if (module.type === 'postProcessor') {
2109          postProcessor.addPostProcessor(module);
2110        }
2111        if (module.type === 'formatter') {
2112          this.modules.formatter = module;
2113        }
2114        if (module.type === '3rdParty') {
2115          this.modules.external.push(module);
2116        }
2117        return this;
2118      }
2119      setResolvedLanguage(l) {
2120        if (!l || !this.languages) return;
2121        if (['cimode', 'dev'].indexOf(l) > -1) return;
2122        for (let li = 0; li < this.languages.length; li++) {
2123          const lngInLngs = this.languages[li];
2124          if (['cimode', 'dev'].indexOf(lngInLngs) > -1) continue;
2125          if (this.store.hasLanguageSomeTranslations(lngInLngs)) {
2126            this.resolvedLanguage = lngInLngs;
2127            break;
2128          }
2129        }
2130        if (!this.resolvedLanguage && this.languages.indexOf(l) < 0 && this.store.hasLanguageSomeTranslations(l)) {
2131          this.resolvedLanguage = l;
2132          this.languages.unshift(l);
2133        }
2134      }
2135      changeLanguage(lng, callback) {
2136        this.isLanguageChangingTo = lng;
2137        const deferred = defer();
2138        this.emit('languageChanging', lng);
2139        const setLngProps = l => {
2140          this.language = l;
2141          this.languages = this.services.languageUtils.toResolveHierarchy(l);
2142          this.resolvedLanguage = undefined;
2143          this.setResolvedLanguage(l);
2144        };
2145        const done = (err, l) => {
2146          if (l) {
2147            if (this.isLanguageChangingTo === lng) {
2148              setLngProps(l);
2149              this.translator.changeLanguage(l);
2150              this.isLanguageChangingTo = undefined;
2151              this.emit('languageChanged', l);
2152              this.logger.log('languageChanged', l);
2153            }
2154          } else {
2155            this.isLanguageChangingTo = undefined;
2156          }
2157          deferred.resolve((...args) => this.t(...args));
2158          if (callback) callback(err, (...args) => this.t(...args));
2159        };
2160        const setLng = lngs => {
2161          if (!lng && !lngs && this.services.languageDetector) lngs = [];
2162          const fl = isString(lngs) ? lngs : lngs && lngs[0];
2163          const l = this.store.hasLanguageSomeTranslations(fl) ? fl : this.services.languageUtils.getBestMatchFromCodes(isString(lngs) ? [lngs] : lngs);
2164          if (l) {
2165            if (!this.language) {
2166              setLngProps(l);
2167            }
2168            if (!this.translator.language) this.translator.changeLanguage(l);
2169            this.services.languageDetector?.cacheUserLanguage?.(l);
2170          }
2171          this.loadResources(l, err => {
2172            done(err, l);
2173          });
2174        };
2175        if (!lng && this.services.languageDetector && !this.services.languageDetector.async) {
2176          setLng(this.services.languageDetector.detect());
2177        } else if (!lng && this.services.languageDetector && this.services.languageDetector.async) {
2178          if (this.services.languageDetector.detect.length === 0) {
2179            this.services.languageDetector.detect().then(setLng);
2180          } else {
2181            this.services.languageDetector.detect(setLng);
2182          }
2183        } else {
2184          setLng(lng);
2185        }
2186        return deferred;
2187      }
2188      getFixedT(lng, ns, keyPrefix) {
2189        const fixedT = (key, opts, ...rest) => {
2190          let o;
2191          if (typeof opts !== 'object') {
2192            o = this.options.overloadTranslationOptionHandler([key, opts].concat(rest));
2193          } else {
2194            o = {
2195              ...opts
2196            };
2197          }
2198          o.lng = o.lng || fixedT.lng;
2199          o.lngs = o.lngs || fixedT.lngs;
2200          o.ns = o.ns || fixedT.ns;
2201          if (o.keyPrefix !== '') o.keyPrefix = o.keyPrefix || keyPrefix || fixedT.keyPrefix;
2202          const selectorOpts = {
2203            ...this.options,
2204            ...o
2205          };
2206          if (typeof o.keyPrefix === 'function') o.keyPrefix = keysFromSelector(o.keyPrefix, selectorOpts);
2207          const keySeparator = this.options.keySeparator || '.';
2208          let resultKey;
2209          if (o.keyPrefix && Array.isArray(key)) {
2210            resultKey = key.map(k => {
2211              if (typeof k === 'function') k = keysFromSelector(k, selectorOpts);
2212              return `${o.keyPrefix}${keySeparator}${k}`;
2213            });
2214          } else {
2215            if (typeof key === 'function') key = keysFromSelector(key, selectorOpts);
2216            resultKey = o.keyPrefix ? `${o.keyPrefix}${keySeparator}${key}` : key;
2217          }
2218          return this.t(resultKey, o);
2219        };
2220        if (isString(lng)) {
2221          fixedT.lng = lng;
2222        } else {
2223          fixedT.lngs = lng;
2224        }
2225        fixedT.ns = ns;
2226        fixedT.keyPrefix = keyPrefix;
2227        return fixedT;
2228      }
2229      t(...args) {
2230        return this.translator?.translate(...args);
2231      }
2232      exists(...args) {
2233        return this.translator?.exists(...args);
2234      }
2235      setDefaultNamespace(ns) {
2236        this.options.defaultNS = ns;
2237      }
2238      hasLoadedNamespace(ns, options = {}) {
2239        if (!this.isInitialized) {
2240          this.logger.warn('hasLoadedNamespace: i18next was not initialized', this.languages);
2241          return false;
2242        }
2243        if (!this.languages || !this.languages.length) {
2244          this.logger.warn('hasLoadedNamespace: i18n.languages were undefined or empty', this.languages);
2245          return false;
2246        }
2247        const lng = options.lng || this.resolvedLanguage || this.languages[0];
2248        const fallbackLng = this.options ? this.options.fallbackLng : false;
2249        const lastLng = this.languages[this.languages.length - 1];
2250        if (lng.toLowerCase() === 'cimode') return true;
2251        const loadNotPending = (l, n) => {
2252          const loadState = this.services.backendConnector.state[`${l}|${n}`];
2253          return loadState === -1 || loadState === 0 || loadState === 2;
2254        };
2255        if (options.precheck) {
2256          const preResult = options.precheck(this, loadNotPending);
2257          if (preResult !== undefined) return preResult;
2258        }
2259        if (this.hasResourceBundle(lng, ns)) return true;
2260        if (!this.services.backendConnector.backend || this.options.resources && !this.options.partialBundledLanguages) return true;
2261        if (loadNotPending(lng, ns) && (!fallbackLng || loadNotPending(lastLng, ns))) return true;
2262        return false;
2263      }
2264      loadNamespaces(ns, callback) {
2265        const deferred = defer();
2266        if (!this.options.ns) {
2267          if (callback) callback();
2268          return Promise.resolve();
2269        }
2270        if (isString(ns)) ns = [ns];
2271        ns.forEach(n => {
2272          if (this.options.ns.indexOf(n) < 0) this.options.ns.push(n);
2273        });
2274        this.loadResources(err => {
2275          deferred.resolve();
2276          if (callback) callback(err);
2277        });
2278        return deferred;
2279      }
2280      loadLanguages(lngs, callback) {
2281        const deferred = defer();
2282        if (isString(lngs)) lngs = [lngs];
2283        const preloaded = this.options.preload || [];
2284        const newLngs = lngs.filter(lng => preloaded.indexOf(lng) < 0 && this.services.languageUtils.isSupportedCode(lng));
2285        if (!newLngs.length) {
2286          if (callback) callback();
2287          return Promise.resolve();
2288        }
2289        this.options.preload = preloaded.concat(newLngs);
2290        this.loadResources(err => {
2291          deferred.resolve();
2292          if (callback) callback(err);
2293        });
2294        return deferred;
2295      }
2296      dir(lng) {
2297        if (!lng) lng = this.resolvedLanguage || (this.languages?.length > 0 ? this.languages[0] : this.language);
2298        if (!lng) return 'rtl';
2299        try {
2300          const l = new Intl.Locale(lng);
2301          if (l && l.getTextInfo) {
2302            const ti = l.getTextInfo();
2303            if (ti && ti.direction) return ti.direction;
2304          }
2305        } catch (e) {}
2306        const rtlLngs = ['ar', 'shu', 'sqr', 'ssh', 'xaa', 'yhd', 'yud', 'aao', 'abh', 'abv', 'acm', 'acq', 'acw', 'acx', 'acy', 'adf', 'ads', 'aeb', 'aec', 'afb', 'ajp', 'apc', 'apd', 'arb', 'arq', 'ars', 'ary', 'arz', 'auz', 'avl', 'ayh', 'ayl', 'ayn', 'ayp', 'bbz', 'pga', 'he', 'iw', 'ps', 'pbt', 'pbu', 'pst', 'prp', 'prd', 'ug', 'ur', 'ydd', '