https://adviceskeleton.com/contact/assets/index-DEp0NvQu.js

1var __defProp = Object.defineProperty;
2var __defProps = Object.defineProperties;
3var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
4var __getOwnPropNames = Object.getOwnPropertyNames;
5var __getOwnPropSymbols = Object.getOwnPropertySymbols;
6var __hasOwnProp = Object.prototype.hasOwnProperty;
7var __propIsEnum = Object.prototype.propertyIsEnumerable;
8var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
9var __typeError = (msg) => {
10  throw TypeError(msg);
11};
12var __pow = Math.pow;
13var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
14var __spreadValues = (a, b) => {
15  for (var prop in b || (b = {}))
16    if (__hasOwnProp.call(b, prop))
17      __defNormalProp(a, prop, b[prop]);
18  if (__getOwnPropSymbols)
19    for (var prop of __getOwnPropSymbols(b)) {
20      if (__propIsEnum.call(b, prop))
21        __defNormalProp(a, prop, b[prop]);
22    }
23  return a;
24};
25var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
26var __restKey = (key) => typeof key === "symbol" ? key : key + "";
27var __objRest = (source, exclude) => {
28  var target = {};
29  for (var prop in source)
30    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
31      target[prop] = source[prop];
32  if (source != null && __getOwnPropSymbols)
33    for (var prop of __getOwnPropSymbols(source)) {
34      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
35        target[prop] = source[prop];
36    }
37  return target;
38};
39var __commonJS = (cb, mod) => function __require() {
40  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
41};
42var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
43var __async = (__this, __arguments, generator) => {
44  return new Promise((resolve, reject) => {
45    var fulfilled = (value) => {
46      try {
47        step(generator.next(value));
48      } catch (e) {
49        reject(e);
50      }
51    };
52    var rejected = (value) => {
53      try {
54        step(generator.throw(value));
55      } catch (e) {
56        reject(e);
57      }
58    };
59    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
60    step((generator = generator.apply(__this, __arguments)).next());
61  });
62};
63var __await = function(promise, isYieldStar) {
64  this[0] = promise;
65  this[1] = isYieldStar;
66};
67var __asyncGenerator = (__this, __arguments, generator) => {
68  var resume = (k, v, yes, no) => {
69    try {
70      var x = generator[k](v), isAwait = (v = x.value) instanceof __await, done = x.done;
71      Promise.resolve(isAwait ? v[0] : v).then((y) => isAwait ? resume(k === "return" ? k : "next", v[1] ? { done: y.done, value: y.value } : y, yes, no) : yes({ value: y, done })).catch((e) => resume("throw", e, yes, no));
72    } catch (e) {
73      no(e);
74    }
75  }, method = (k) => it[k] = (x) => new Promise((yes, no) => resume(k, x, yes, no)), it = {};
76  return generator = generator.apply(__this, __arguments), it[__knownSymbol("asyncIterator")] = () => it, method("next"), method("throw"), method("return"), it;
77};
78var __yieldStar = (value) => {
79  var obj = value[__knownSymbol("asyncIterator")], isAwait = false, method, it = {};
80  if (obj == null) {
81    obj = value[__knownSymbol("iterator")]();
82    method = (k) => it[k] = (x) => obj[k](x);
83  } else {
84    obj = obj.call(value);
85    method = (k) => it[k] = (v) => {
86      if (isAwait) {
87        isAwait = false;
88        if (k === "throw") throw v;
89        return v;
90      }
91      isAwait = true;
92      return {
93        done: false,
94        value: new __await(new Promise((resolve) => {
95          var x = obj[k](v);
96          if (!(x instanceof Object)) __typeError("Object expected");
97          resolve(x);
98        }), 1)
99      };
100    };
101  }
102  return it[__knownSymbol("iterator")] = () => it, method("next"), "throw" in obj ? method("throw") : it.throw = (x) => {
103    throw x;
104  }, "return" in obj && method("return"), it;
105};
106var __forAwait = (obj, it, method) => (it = obj[__knownSymbol("asyncIterator")]) ? it.call(obj) : (obj = obj[__knownSymbol("iterator")](), it = {}, method = (key, fn) => (fn = obj[key]) && (it[key] = (arg) => new Promise((yes, no, done) => (arg = fn.call(obj, arg), done = arg.done, Promise.resolve(arg.value).then((value) => yes({ value, done }), no)))), method("next"), method("return"), it);
107var require_index_001 = __commonJS({
108  "assets/index-DEp0NvQu.js"(exports, module) {
109    ;
110    {

111      try {
112        let e2 = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n2 = new e2.Error().stack;
113        n2 && (e2._sentryDebugIds = e2._sentryDebugIds || {}, e2._sentryDebugIds[n2] = "f388482f-4770-4191-a4d9-ac5c6ea60761", e2._sentryDebugIdIdentifier = "sentry-dbid-f388482f-4770-4191-a4d9-ac5c6ea60761");
114      } catch (e2) {
115      }
116    }
117    ;
118    function _mergeNamespaces(n2, m2) {
119      for (var i2 = 0; i2 < m2.length; i2++) {
120        const e2 = m2[i2];
121        if (typeof e2 !== "string" && !Array.isArray(e2)) {
122          for (const k2 in e2) {
123            if (k2 !== "default" && !(k2 in n2)) {
124              const d2 = Object.getOwnPropertyDescriptor(e2, k2);
125              if (d2) {
126                Object.defineProperty(n2, k2, d2.get ? d2 : {
127                  enumerable: true,
128                  get: () => e2[k2]
129                });
130              }
131            }
132          }
133        }
134      }
135      return Object.freeze(Object.defineProperty(n2, Symbol.toStringTag, { value: "Module" }));
136    }
137    (function polyfill() {
138      const relList = document.createElement("link").relList;
139      if (relList && relList.supports && relList.supports("modulepreload")) return;
140      for (const link of document.querySelectorAll('link[rel="modulepreload"]')) processPreload(link);
141      new MutationObserver((mutations) => {
142        for (const mutation of mutations) {
143          if (mutation.type !== "childList") continue;
144          for (const node2 of mutation.addedNodes) if (node2.tagName === "LINK" && node2.rel === "modulepreload") processPreload(node2);
145        }
146      }).observe(document, {
147        childList: true,
148        subtree: true
149      });
150      function getFetchOpts(link) {
151        const fetchOpts = {};
152        if (link.integrity) fetchOpts.integrity = link.integrity;
153        if (link.referrerPolicy) fetchOpts.referrerPolicy = link.referrerPolicy;
154        if (link.crossOrigin === "use-credentials") fetchOpts.credentials = "include";
155        else if (link.crossOrigin === "anonymous") fetchOpts.credentials = "omit";
156        else fetchOpts.credentials = "same-origin";
157        return fetchOpts;
158      }
159      function processPreload(link) {
160        if (link.ep) return;
161        link.ep = true;
162        const fetchOpts = getFetchOpts(link);
163        fetch(link.href, fetchOpts);
164      }
165    })();
166    if (typeof globalThis.__fw_env__ === "string") {
167      globalThis.__fw_env__ = {
168        FW_ENV: void 0,
169        FW_BASE_URL: void 0,
170        FW_BASE_API_URL: void 0,
171        FW_MEMBERSHIPS_API_URL: void 0,
172        FW_AUTH_URL: void 0,
173        FW_SHOP_RENDERER_API_URL: void 0,
174        FW_HERO_URL: void 0,
175        FW_OMNI_URL: void 0
176      };
177    }
178    function getDefaultExportFromCjs(x2) {
179      return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
180    }
181    function getAugmentedNamespace(n2) {
182      if (Object.prototype.hasOwnProperty.call(n2, "__esModule")) return n2;
183      var f2 = n2.default;
184      if (typeof f2 == "function") {
185        var a2 = function a3() {
186          var isInstance = false;
187          try {
188            isInstance = this instanceof a3;
189          } catch (e2) {
190          }
191          if (isInstance) {
192            return Reflect.construct(f2, arguments, this.constructor);
193          }
194          return f2.apply(this, arguments);
195        };
196        a2.prototype = f2.prototype;
197      } else a2 = {};
198      Object.defineProperty(a2, "__esModule", { value: true });
199      Object.keys(n2).forEach(function(k2) {
200        var d2 = Object.getOwnPropertyDescriptor(n2, k2);
201        Object.defineProperty(a2, k2, d2.get ? d2 : {
202          enumerable: true,
203          get: function() {
204            return n2[k2];
205          }
206        });
207      });
208      return a2;
209    }
210    var jsxRuntime = { exports: {} };
211    var reactJsxRuntime_production_min = {};
212    var react = { exports: {} };
213    var react_production_min = {};
214    /**
215     * @license React
216     * react.production.min.js
217     *
218     * Copyright (c) Facebook, Inc. and its affiliates.
219     *
220     * This source code is licensed under the MIT license found in the
221     * LICENSE file in the root directory of this source tree.
222     */
223    var hasRequiredReact_production_min;
224    function requireReact_production_min() {
225      if (hasRequiredReact_production_min) return react_production_min;
226      hasRequiredReact_production_min = 1;
227      var l2 = Symbol.for("react.element"), n2 = Symbol.for("react.portal"), p2 = 

227Symbol.for("react.fragment"), q2 = Symbol.for("react.strict_mode"), r2 = Symbol.for("react.profiler"), t2 = Symbol.for("react.provider"), u2 = Symbol.for("react.context"), v2 = Symbol.for("react.forward_ref"), w2 = Symbol.for("react.suspense"), x2 = Symbol.for("react.memo"), y2 = Symbol.for("react.lazy"), z2 = Symbol.iterator;
228      function A2(a2) {
229        if (null === a2 || "object" !== typeof a2) return null;
230        a2 = z2 && a2[z2] || a2["@@iterator"];
231        return "function" === typeof a2 ? a2 : null;
232      }
233      var B2 = { isMounted: function() {
234        return false;
235      }, enqueueForceUpdate: function() {
236      }, enqueueReplaceState: function() {
237      }, enqueueSetState: function() {
238      } }, C2 = Object.assign, D2 = {};
239      function E2(a2, b2, e2) {
240        this.props = a2;
241        this.context = b2;
242        this.refs = D2;
243        this.updater = e2 || B2;
244      }
245      E2.prototype.isReactComponent = {};
246      E2.prototype.setState = function(a2, b2) {
247        if ("object" !== typeof a2 && "function" !== typeof a2 && null != a2) throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
248        this.updater.enqueueSetState(this, a2, b2, "setState");
249      };
250      E2.prototype.forceUpdate = function(a2) {
251        this.updater.enqueueForceUpdate(this, a2, "forceUpdate");
252      };
253      function F2() {
254      }
255      F2.prototype = E2.prototype;
256      function G2(a2, b2, e2) {
257        this.props = a2;
258        this.context = b2;
259        this.refs = D2;
260        this.updater = e2 || B2;
261      }
262      var H2 = G2.prototype = new F2();
263      H2.constructor = G2;
264      C2(H2, E2.prototype);
265      H2.isPureReactComponent = true;
266      var I2 = Array.isArray, J2 = Object.prototype.hasOwnProperty, K2 = { current: null }, L2 = { key: true, ref: true, __self: true, __source: true };
267      function M2(a2, b2, e2) {
268        var d2, c2 = {}, k2 = null, h2 = null;
269        if (null != b2) for (d2 in void 0 !== b2.ref && (h2 = b2.ref), void 0 !== b2.key && (k2 = "" + b2.key), b2) J2.call(b2, d2) && !L2.hasOwnProperty(d2) && (c2[d2] = b2[d2]);
270        var g2 = arguments.length - 2;
271        if (1 === g2) c2.children = e2;
272        else if (1 < g2) {
273          for (var f2 = Array(g2), m2 = 0; m2 < g2; m2++) f2[m2] = arguments[m2 + 2];
274          c2.children = f2;
275        }
276        if (a2 && a2.defaultProps) for (d2 in g2 = a2.defaultProps, g2) void 0 === c2[d2] && (c2[d2] = g2[d2]);
277        return { $$typeof: l2, type: a2, key: k2, ref: h2, props: c2, _owner: K2.current };
278      }
279      function N2(a2, b2) {
280        return { $$typeof: l2, type: a2.type, key: b2, ref: a2.ref, props: a2.props, _owner: a2._owner };
281      }
282      function O2(a2) {
283        return "object" === typeof a2 && null !== a2 && a2.$$typeof === l2;
284      }
285      function escape2(a2) {
286        var b2 = { "=": "=0", ":": "=2" };
287        return "$" + a2.replace(/[=:]/g, function(a3) {
288          return b2[a3];
289        });
290      }
291      var P2 = /\/+/g;
292      function Q2(a2, b2) {
293        return "object" === typeof a2 && null !== a2 && null != a2.key ? escape2("" + a2.key) : b2.toString(36);
294      }
295      function R2(a2, b2, e2, d2, c2) {
296        var k2 = typeof a2;
297        if ("undefined" === k2 || "boolean" === k2) a2 = null;
298        var h2 = false;
299        if (null === a2) h2 = true;
300        else switch (k2) {
301          case "string":
302          case "number":
303            h2 = true;
304            break;
305          case "object":
306            switch (a2.$$typeof) {
307              case l2:
308              case n2:
309                h2 = true;
310            }
311        }
312        if (h2) return h2 = a2, c2 = c2(h2), a2 = "" === d2 ? "." + Q2(h2, 0) : d2, I2(c2) ? (e2 = "", null != a2 && (e2 = a2.replace(P2, "$&/") + "/"), R2(c2, b2, e2, "", function(a3) {
313          return a3;
314        })) : null != c2 && (O2(c2) && (c2 = N2(c2, e2 + (!c2.key || h2 && h2.key === c2.key ? "" : ("" + c2.key).replace(P2, "$&/") + "/") + a2)), b2.push(c2)), 1;
315        h2 = 0;
316        d2 = "" === d2 ? "." : d2 + ":";
317        if (I2(a2)) for (var g2 = 0; g2 < a2.length; g2++) {
318          k2 = a2[g2];
319          var f2 = d2 + Q2(k2, g2);
320          h2 += R2(k2, b2, e2, f2, c2);
321        }
322        else if (f2 = A2(a2), "function" === typeof f2) for (a2 = f2.call(a2), g2 = 0; !(k2 = a2.next()).done; ) k2 = k2.value, f2 = d2 + Q2(k2, g2++), h2 += R2(k2, b2, e2, f2, c2);
323        else if ("object" === k2) throw b2 = String(a2), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b2 ? "object with keys {" + Object.keys(a2).join(", ") + "}" : b2) + "). If you meant to render a collection of children, use an array instead.");
324        return h2;
325      }
326      function S2(a2, b2, e2) {
327        if (null == a2) return a2;
328        var d2 = [], c2 = 0;
329        R2(a2, d2, "", "", function(a3) {
330          return b2.call(e2, a3, c2++);
331        });
332        return d2;
333      }
334      function T2(a2) {
335        if (-1 === a2._status) {
336          var b2 = a2._result;
337          b2 = b2();
338          b2.then(function(b3) {
339            if (0 === a2._status || -1 === a2._status) a2._status = 1, a2._result = b3;
340          }, function(b3) {
341            if (0 === a2._status || -1 === a2._status) a2._status = 2, a2._result = b3;
342          });
343          -1 === a2._status && (a2._status = 0, a2._result = b2);
344        }
345        if (1 === a2._status) return a2._result.default;
346        throw a2._result;
347      }
348      var U2 = { current: null }, V2 = { transition: null }, W2 = { ReactCurrentDispatcher: U2, ReactCurrentBatchConfig: V2, ReactCurrentOwner: K2 };
349      function X2() {
350        throw Error("act(...) is not supported in production builds of React.");
351      }
352      react_production_min.Children = { map: S2, forEach: function(a2, b2, e2) {
353        S2(a2, function() {
354          b2.apply(this, arguments);
355        }, e2);
356      }, count: function(a2) {
357        var b2 = 0;
358        S2(a2, function() {
359          b2++;
360        });
361        return b2;
362      }, toArray: function(a2) {
363        return S2(a2, function(a3) {
364          return a3;
365        }) || [];
366      }, only: function(a2) {
367        if (!O2(a2)) throw Error("React.Children.only expected to receive a single React element child.");
368        return a2;
369      } };
370      react_production_min.Component = E2;
371      react_production_min.Fragment = p2;
372      react_production_min.Profiler = r2;
373      react_production_min.PureComponent = G2;
374      react_production_min.StrictMode = q2;
375      react_production_min.Suspense = w2;
376      react_production_min.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W2;
377      react_production_min.act = X2;
378      react_production_min.cloneElement = function(a2, b2, e2) {
379        if (null === a2 || void 0 === a2) throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a2 + ".");
380        var d2 = C2({}, a2.props), c2 = a2.key, k2 = a2.ref, h2 = a2._owner;
381        if (null != b2) {
382          void 0 !== b2.ref && (k2 = b2.ref, h2 = K2.current);
383          void 0 !== b2.key && (c2 = "" + b2.key);
384          if (a2.type && a2.type.defaultProps) var g2 = a2.type.defaultProps;
385          for (f2 in b2) J2.call(b2, f2) && !L2.hasOwnProperty(f2) && (d2[f2] = void 0 === b2[f2] && void 0 !== g2 ? g2[f2] : b2[f2]);
386        }
387        var f2 = arguments.length - 2;
388        if (1 === f2) d2.children = e2;
389        else if (1 < f2) {
390          g2 = Array(f2);
391          for (var m2 = 0; m2 < f2; m2++) g2[m2] = arguments[m2 + 2];
392          d2.children = g2;
393        }
394        return { $$typeof: l2, type: a2.type, key: c2, ref: k2, props: d2, _owner: h2 };
395      };
396      react_production_min.createContext = function(a2) {
397        a2 = { $$typeof: u2, _currentValue: a2, _currentValue2: a2, _threadCount: 0, Provider: null, Consumer: null, _defaultValue: null, _globalName: null };
398        a2.Provider = { $$typeof: t2, _context: a2 };
399        return a2.Consumer = a2;
400      };
401      react_production_min.createElement = M2;
402      react_production_min.createFactory = function(a2) {
403        var b2 = M2.bind(null, a2);
404        b2.type = a2;
405        return b2;
406      };
407      react_production_min.createRef = function() {
408        return { current: null };
409      };
410      react_production_min.forwardRef = function(a2) {
411        return { $$typeof: v2, render: a2 };
412      };
413      react_production_min.isValidElement = O2;
414      react_production_min.lazy = function(a2) {
415        return { $$typeof: y2, _payload: { _status: -1, _result: a2 }, _init: T2 };
416      };
417      react_production_min.memo = function(a2, b2) {
418        return { $$typeof: x2, type: a2, compare: void 0 === b2 ? null : b2 };
419      };
420      react_production_min.startTransition = function(a2) {
421        var b2 = V2.transition;
422        V2.transition = {};
423        try {
424          a2();
425        } finally {
426          V2.transition = b2;
427        }
428      };
429      react_production_min.unstable_act = X2;
430      react_production_min.useCallback = function(a2, b2) {
431        return U2.current.useCallback(a2, b2);
432      };
433      react_production_min.useContext = function(a2) {
434        return U2.current.useContext(a2);
435      };
436      react_production_min.useDebugValue = function() {
437      };
438      react_production_min.useDeferredValue = function(a2) {
439        return U2.current.useDeferredValue(a2);
440      };
441      react_production_min.useEffect = function(a2, b2) {
442        return U2.current.useEffect(a2, b2);
443      };
444      react_production_min.useId = function() {
445        return U2.current.useId();
446      };
447      react_production_min.useImperativeHandle = function(a2, b2, e2) {
448        return U2.current.useImperativeHandle(a2, b2, e2);
449      };
450      react_production_min.useInsertionEffect = function(a2, b2) {
451        return U2.current.useInsertionEffect(a2, b2);
452      };
453      react_production_min.useLayoutEffect = function(a2, b2) {
454        return U2.current.useLayoutEffect(a2, b2);
455      };
456      react_production_min.useMemo = function(a2, b2) {
457        return U2.current.useMemo(a2, b2);
458      };
459      react_production_min.useReducer = function(a2, b2, e2) {
460        return U2.current.useReducer(a2, b2, e2);
461      };
462      react_production_min.useRef = function(a2) {
463        return U2.current.useRef(a2);
464      };
465      react_production_min.useState = function(a2) {
466        return U2.current.useState(a2);
467      };
468      react_production_min.useSyncExternalStore = function(a2, b2, e2) {
469        return U2.current.useSyncExternalStore(a2, b2, e2);
470      };
471      react_production_min.useTransition = function() {
472        return U2.current.useTransition();
473      };
474      react_production_min.version = "18.3.1";
475      return react_production_min;
476    }
477    var hasRequiredReact;
478    function requireReact() {
479      if (hasRequiredReact) return react.exports;
480      hasRequiredReact = 1;
481      {
482        react.exports = requireReact_production_min();
483      }
484      return react.exports;
485    }
486    /**
487     * @license React
488     * react-jsx-runtime.production.min.js
489     *
490     * Copyright (c) Facebook, Inc. and its affiliates.
491     *
492     * This source code is licensed under the MIT license found in the
493     * LICENSE file in the root directory of this source tree.
494     */
495    var hasRequiredReactJsxRuntime_production_min;
496    function requireReactJsxRuntime_production_min() {
497      if (hasRequiredReactJsxRuntime_production_min) return reactJsxRuntime_production_min;
498      hasRequiredReactJsxRuntime_production_min = 1;
499      var f2 = requireReact(), k2 = Symbol.for("react.element"), l2 = Symbol.for("react.fragment"), m2 = Object.prototype.hasOwnProperty, n2 = f2.__SECRET_INT

499ERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, p2 = { key: true, ref: true, __self: true, __source: true };
500      function q2(c2, a2, g2) {
501        var b2, d2 = {}, e2 = null, h2 = null;
502        void 0 !== g2 && (e2 = "" + g2);
503        void 0 !== a2.key && (e2 = "" + a2.key);
504        void 0 !== a2.ref && (h2 = a2.ref);
505        for (b2 in a2) m2.call(a2, b2) && !p2.hasOwnProperty(b2) && (d2[b2] = a2[b2]);
506        if (c2 && c2.defaultProps) for (b2 in a2 = c2.defaultProps, a2) void 0 === d2[b2] && (d2[b2] = a2[b2]);
507        return { $$typeof: k2, type: c2, key: e2, ref: h2, props: d2, _owner: n2.current };
508      }
509      reactJsxRuntime_production_min.Fragment = l2;
510      reactJsxRuntime_production_min.jsx = q2;
511      reactJsxRuntime_production_min.jsxs = q2;
512      return reactJsxRuntime_production_min;
513    }
514    var hasRequiredJsxRuntime;
515    function requireJsxRuntime() {
516      if (hasRequiredJsxRuntime) return jsxRuntime.exports;
517      hasRequiredJsxRuntime = 1;
518      {
519        jsxRuntime.exports = requireReactJsxRuntime_production_min();
520      }
521      return jsxRuntime.exports;
522    }
523    var jsxRuntimeExports = requireJsxRuntime();
524    const isString$4 = (obj) => typeof obj === "string";
525    const defer = () => {
526      let res;
527      let rej;
528      const promise = new Promise((resolve, reject) => {
529        res = resolve;
530        rej = reject;
531      });
532      promise.resolve = res;
533      promise.reject = rej;
534      return promise;
535    };
536    const makeString = (object2) => {
537      if (object2 == null) return "";
538      return "" + object2;
539    };
540    const copy$1 = (a2, s2, t2) => {
541      a2.forEach((m2) => {
542        if (s2[m2]) t2[m2] = s2[m2];
543      });
544    };
545    const lastOfPathSeparatorRegExp = /###/g;
546    const cleanKey = (key) => key && key.indexOf("###") > -1 ? key.replace(lastOfPathSeparatorRegExp, ".") : key;
547    const canNotTraverseDeeper = (object2) => !object2 || isString$4(object2);
548    const getLastOfPath = (object2, path, Empty) => {
549      const stack = !isString$4(path) ? path : path.split(".");
550      let stackIndex = 0;
551      while (stackIndex < stack.length - 1) {
552        if (canNotTraverseDeeper(object2)) return {};
553        const key = cleanKey(stack[stackIndex]);
554        if (!object2[key] && Empty) object2[key] = new Empty();
555        if (Object.prototype.hasOwnProperty.call(object2, key)) {
556          object2 = object2[key];
557        } else {
558          object2 = {};
559        }
560        ++stackIndex;
561      }
562      if (canNotTraverseDeeper(object2)) return {};
563      return {
564        obj: object2,
565        k: cleanKey(stack[stackIndex])
566      };
567    };
568    const setPath = (object2, path, newValue) => {
569      const {
570        obj,
571        k: k2
572      } = getLastOfPath(object2, path, Object);
573      if (obj !== void 0 || path.length === 1) {
574        obj[k2] = newValue;
575        return;
576      }
577      let e2 = path[path.length - 1];
578      let p2 = path.slice(0, path.length - 1);
579      let last = getLastOfPath(object2, p2, Object);
580      while (last.obj === void 0 && p2.length) {
581        e2 = `${p2[p2.length - 1]}.${e2}`;
582        p2 = p2.slice(0, p2.length - 1);
583        last = getLastOfPath(object2, p2, Object);
584        if ((last == null ? void 0 : last.obj) && typeof last.obj[`${last.k}.${e2}`] !== "undefined") {
585          last.obj = void 0;
586        }
587      }
588      last.obj[`${last.k}.${e2}`] = newValue;
589    };
590    const pushPath = (object2, path, newValue, concat) => {
591      const {
592        obj,
593        k: k2
594      } = getLastOfPath(object2, path, Object);
595      obj[k2] = obj[k2] || [];
596      obj[k2].push(newValue);
597    };
598    const getPath = (object2, path) => {
599      const {
600        obj,
601        k: k2
602      } = getLastOfPath(object2, path);
603      if (!obj) return void 0;
604      if (!Object.prototype.hasOwnProperty.call(obj, k2)) return void 0;
605      return obj[k2];
606    };
607    const getPathWithDefaults = (data, defaultData, key) => {
608      const value = getPath(data, key);
609      if (value !== void 0) {
610        return value;
611      }
612      return getPath(defaultData, key);
613    };
614    const deepExtend = (target, source, overwrite) => {
615      for (const prop in source) {
616        if (prop !== "__proto__" && prop !== "constructor") {
617          if (prop in target) {
618            if (isString$4(target[prop]) || target[prop] instanceof String || isString$4(source[prop]) || source[prop] instanceof String) {
619              if (overwrite) target[prop] = source[prop];
620            } else {
621              deepExtend(target[prop], source[prop], overwrite);
622            }
623          } else {
624            target[prop] = source[prop];
625          }
626        }
627      }
628      return target;
629    };
630    const regexEscape = (str) => str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
631    var _entityMap = {
632      "&": "&amp;",
633      "<": "&lt;",
634      ">": "&gt;",
635      '"': "&quot;",
636      "'": "&#39;",
637      "/": "&#x2F;"
638    };
639    const escape$1 = (data) => {
640      if (isString$4(data)) {
641        return data.replace(/[&<>

641"'\/]/g, (s2) => _entityMap[s2]);
642      }
643      return data;
644    };
645    class RegExpCache {
646      constructor(capacity) {
647        this.capacity = capacity;
648        this.regExpMap = /* @__PURE__ */ new Map();
649        this.regExpQueue = [];
650      }
651      getRegExp(pattern) {
652        const regExpFromCache = this.regExpMap.get(pattern);
653        if (regExpFromCache !== void 0) {
654          return regExpFromCache;
655        }
656        const regExpNew = new RegExp(pattern);
657        if (this.regExpQueue.length === this.capacity) {
658          this.regExpMap.delete(this.regExpQueue.shift());
659        }
660        this.regExpMap.set(pattern, regExpNew);
661        this.regExpQueue.push(pattern);
662        return regExpNew;
663      }
664    }
665    const chars = [" ", ",", "?", "!", ";"];
666    const looksLikeObjectPathRegExpCache = new RegExpCache(20);
667    const looksLikeObjectPath = (key, nsSeparator, keySeparator) => {
668      nsSeparator = nsSeparator || "";
669      keySeparator = keySeparator || "";
670      const possibleChars = chars.filter((c2) => nsSeparator.indexOf(c2) < 0 && keySeparator.indexOf(c2) < 0);
671      if (possibleChars.length === 0) return true;
672      const r2 = looksLikeObjectPathRegExpCache.getRegExp(`(${possibleChars.map((c2) => c2 === "?" ? "\\?" : c2).join("|")})`);
673      let matched = !r2.test(key);
674      if (!matched) {

675        const ki2 = key.indexOf(keySeparator);
676        if (ki2 > 0 && !r2.test(key.substring(0, ki2))) {
677          matched = true;
678        }
679      }
680      return matched;
681    };
682    const deepFind = (obj, path, keySeparator = ".") => {
683      if (!obj) return void 0;
684      if (obj[path]) {
685        if (!Object.prototype.hasOwnProperty.call(obj, path)) return void 0;
686        return obj[path];
687      }
688      const tokens = path.split(keySeparator);
689      let current = obj;
690      for (let i2 = 0; i2 < tokens.length; ) {
691        if (!current || typeof current !== "object") {
692          return void 0;
693        }
694        let next2;
695        let nextPath = "";
696        for (let j2 = i2; j2 < tokens.length; ++j2) {
697          if (j2 !== i2) {
698            nextPath += keySeparator;
699          }
700          nextPath += tokens[j2];
701          next2 = current[nextPath];
702          if (next2 !== void 0) {
703            if (["string", "number", "boolean"].indexOf(typeof next2) > -1 && j2 < tokens.length - 1) {
704              continue;
705            }
706            i2 += j2 - i2 + 1;
707            break;
708          }
709        }
710        current = next2;
711      }
712      return current;
713    };
714    const getCleanedCode = (code) => code == null ? void 0 : code.replace("_", "-");
715    const consoleLogger = {
716      type: "logger",
717      log(args) {
718        this.output("log", args);
719      },
720      warn(args) {
721        this.output("warn", args);
722      },
723      error(args) {
724        this.output("error", args);
725      },
726      output(type, args) {
727        var _a, _b;
728        (_b = (_a = console == null ? void 0 : console[type]) == null ? void 0 : _a.apply) == null ? void 0 : _b.call(_a, console, args);
729      }
730    };
731    class Logger {
732      constructor(concreteLogger, options2 = {}) {
733        this.init(concreteLogger, options2);
734      }
735      init(concreteLogger, options2 = {}) {
736        this.prefix = options2.prefix || "i18next:";
737        this.logger = concreteLogger || consoleLogger;
738        this.options = options2;
739        this.debug = options2.debug;
740      }
741      log(...args) {
742        return this.forward(args, "log", "", true);
743      }
744      warn(...args) {
745        return this.forward(args, "warn", "", true);
746      }
747      error(...args) {
748        return this.forward(args, "error", "");
749      }
750      deprecate(...args) {
751        return this.forward(args, "warn", "WARNING DEPRECATED: ", true);
752      }
753      forward(args, lvl, prefix2, debugOnly) {
754        if (debugOnly && !this.debug) return null;
755        if (isString$4(args[0])) args[0] = `${prefix2}${this.prefix} ${args[0]}`;
756        return this.logger[lvl](args);
757      }
758      create(moduleName) {
759        return new Logger(this.logger, __spreadValues(__spreadValues({}, {
760          prefix: `${this.prefix}:${moduleName}:`
761        }), this.options));
762      }
763      clone(options2) {
764        options2 = options2 || this.options;
765        options2.prefix = options2.prefix || this.prefix;
766        return new Logger(this.logger, options2);
767      }
768    }
769    var baseLogger = new Logger();
770    class EventEmitter {
771      constructor() {
772        this.observers = {};
773      }
774      on(events, listener) {
775        events.split(" ").forEach((event) => {
776          if (!this.observers[event]) this.observers[event] = /* @__PURE__ */ new Map();
777          const numListeners = this.observers[event].get(listener) || 0;
778          this.observers[event].set(listener, numListeners + 1);
779        });
780        return this;
781      }
782      off(event, listener) {
783        if (!this.observers[event]) return;
784        if (!listener) {
785          delete this.observers[event];
786          return;
787        }
788        this.observers[event].delete(listener);
789      }
790      emit(event, ...args) {
791        if (this.observers[event]) {
792          const cloned = Array.from(this.observers[event].entries());
793          cloned.forEach(([observer, numTimesAdded]) => {
794            for (let i2 = 0; i2 < numTimesAdded; i2++) {
795              observer(...args);
796            }
797          });
798        }
799        if (this.observers["*"]) {
800          const cloned = Array.from(this.observers["*"].entries());
801          cloned.forEach(([observer, numTimesAdded]) => {
802            for (let i2 = 0; i2 < numTimesAdded; i2++) {
803              observer.apply(observer, [event, ...args]);
804            }
805          });
806        }
807      }
808    }

809    class ResourceStore extends EventEmitter {
810      constructor(data, options2 = {
811        ns: ["translation"],
812        defaultNS: "translation"
813      }) {
814        super();
815        this.data = data || {};
816        this.options = options2;
817        if (this.options.keySeparator === void 0) {
818          this.options.keySeparator = ".";
819        }
820        if (this.options.ignoreJSONStructure === void 0) {
821          this.options.ignoreJSONStructure = true;
822        }
823      }
824      addNamespaces(ns) {
825        if (this.options.ns.indexOf(ns) < 0) {
826          this.options.ns.push(ns);
827        }
828      }
829      removeNamespaces(ns) {
830        const index2 = this.options.ns.indexOf(ns);
831        if (index2 > -1) {
832          this.options.ns.splice(index2, 1);
833        }
834      }
835      getResource(lng, ns, key, options2 = {}) {
836        var _a, _b;
837        const keySeparator = options2.keySeparator !== void 0 ? options2.keySeparator : this.options.keySeparator;
838        const ignoreJSONStructure = options2.ignoreJSONStructure !== void 0 ? options2.ignoreJSONStructure : this.options.ignoreJSONStructure;
839        let path;
840        if (lng.indexOf(".") > -1) {
841          path = lng.split(".");
842        } else {
843          path = [lng, ns];
844          if (key) {
845            if (Array.isArray(key)) {
846              path.push(...key);
847            } else if (isString$4(key) && keySeparator) {
848              path.push(...key.split(keySeparator));
849            } else {
850              path.push(key);
851            }
852          }
853        }
854        const result = getPath(this.data, path);
855        if (!result && !ns && !key && lng.indexOf(".") > -1) {
856          lng = path[0];
857          ns = path[1];
858          key = path.slice(2).join(".");
859        }
860        if (result || !ignoreJSONStructure || !isString$4(key)) return result;
861        return deepFind((_b = (_a = this.data) == null ? void 0 : _a[lng]) == null ? void 0 : _b[ns], key, keySeparator);
862      }
863      addResource(lng, ns, key, value, options2 = {
864        silent: false
865      }) {
866        const keySeparator = options2.keySeparator !== void 0 ? options2.keySeparator : this.options.keySeparator;
867        let path = [lng, ns];
868        if (key) path = path.concat(keySeparator ? key.split(keySeparator) : key);
869        if (lng.indexOf(".") > -1) {
870          path = lng.split(".");
871          value = ns;
872          ns = path[1];
873        }
874        this.addNamespaces(ns);
875        setPath(this.data, path, value);
876        if (!options2.silent) this.emit("added", lng, ns, key, value);
877      }
878      addResources(lng, ns, resources, options2 = {
879        silent: false
880      }) {
881        for (const m2 in resources) {
882          if (isString$4(resources[m2]) || Array.isArray(resources[m2])) this.addResource(lng, ns, m2, resources[m2], {
883            silent: true
884          });
885        }
886        if (!options2.silent) this.emit("added", lng, ns, resources);
887      }
888      addResourceBundle(lng, ns, resources, deep, overwrite, options2 = {
889        silent: false,
890        skipCopy: false
891      }) {
892        let path = [lng, ns];
893        if (lng.indexOf(".") > -1) {
894          path = lng.split(".");
895          deep = resources;
896          resources = ns;
897          ns = path[1];
898        }
899        this.addNamespaces(ns);
900        let pack = getPath(this.data, path) || {};
901        if (!options2.skipCopy) resources = JSON.parse(JSON.stringify(resources));
902        if (deep) {
903          deepExtend(pack, resources, overwrite);
904        } else {
905          pack = __spreadValues(__spreadValues({}, pack), resources);
906        }
907        setPath(this.data, path, pack);
908        if (!options2.silent) this.emit("added", lng, ns, resources);
909      }
910      removeResourceBundle(lng, ns) {
911        if (this.hasResourceBundle(lng, ns)) {
912          delete this.data[lng][ns];
913        }
914        this.removeNamespaces(ns);
915        this.emit("removed", lng, ns);
916      }
917      hasResourceBundle(lng, ns) {
918        return this.getResource(lng, ns) !== void 0;
919      }
920      getResourceBundle(lng, ns) {
921        if (!ns) ns = this.options.defaultNS;
922        return this.getResource(lng, ns);
923      }
924      getDataByLanguage(lng) {
925        return this.data[lng];
926      }
927      hasLanguageSomeTranslations(lng) {
928        const data = this.getDataByLanguage(lng);
929        const n2 = data && Object.keys(data) || [];
930        return !!n2.find((v2) => data[v2] && Object.keys(data[v2]).length > 0);
931      }
932      toJSON() {
933        return this.data;
934      }
935    }
936    var postProcessor = {
937      processors: {},
938      addPostProcessor(module2) {
939        this.processors[module2.name] = module2;
940      },
941      handle(processors, value, key, options2, translator) {

942        processors.forEach((processor) => {
943          var _a, _b;
944          value = (_b = (_a = this.processors[processor]) == null ? void 0 : _a.process(value, key, options2, translator)) != null ? _b : value;
945        });
946        return value;
947      }
948    };
949    const PATH_KEY = Symbol("i18next/PATH_KEY");
950    function createProxy() {
951      const state = [];
952      const handler = /* @__PURE__ */ Object.create(null);
953      let proxy;
954      handler.get = (target, key) => {
955        var _a;
956        (_a = proxy == null ? void 0 : proxy.revoke) == null ? void 0 : _a.call(proxy);
957        if (key === PATH_KEY) return state;
958        state.push(key);
959        proxy = Proxy.revocable(target, handler);
960        return proxy.proxy;
961      };
962      return Proxy.revocable(/* @__PURE__ */ Object.create(null), handler).proxy;
963    }
964    function keysFromSelector(selector, opts) {
965      var _a;
966      const {
967        [PATH_KEY]: path
968      } = selector(createProxy());
969      return path.join((_a = opts == null ? void 0 : opts.keySeparator) != null ? _a : ".");
970    }
971    const checkedLoadedFor = {};
972    const shouldHandleAsObject = (res) => !isString$4(res) && typeof res !== "boolean" && typeof res !== "number";
973    class Translator extends EventEmitter {
974      constructor(services, options2 = {}) {
975        super();
976        copy$1(["resourceStore", "languageUtils", "pluralResolver", "interpolator", "backendConnector", "i18nFormat", "utils"], services, this);
977        this.options = options2;
978        if (this.options.keySeparator === void 0) {
979          this.options.keySeparator = ".";
980        }
981        this.logger = baseLogger.create("translator");
982      }
983      changeLanguage(lng) {
984        if (lng) this.language = lng;
985      }
986      exists(key, o2 = {
987        interpolation: {}
988      }) {
989        const opt = __spreadValues({}, o2);
990        if (key == null) return false;
991        const resolved = this.resolve(key, opt);
992        if ((resolved == null ? void 0 : resolved.res) === void 0) return false;
993        const isObject2 = shouldHandleAsObject(resolved.res);
994        if (opt.returnObjects === false && isObject2) {
995          return false;
996        }
997        return true;
998      }
999      extractFromKey(key, opt) {
1000        let nsSeparator = opt.nsSeparator !== void 0 ? opt.nsSeparator : this.options.nsSeparator;
1001        if (nsSeparator === void 0) nsSeparator = ":";
1002        const keySeparator = opt.keySeparator !== void 0 ? opt.keySeparator : this.options.keySeparator;
1003        let namespaces = opt.ns || this.options.defaultNS || [];
1004        const wouldCheckForNsInKey = nsSeparator && key.indexOf(nsSeparator) > -1;
1005        const seemsNaturalLanguage = !this.options.userDefinedKeySeparator && !opt.keySeparator && !this.options.userDefinedNsSeparator && !opt.nsSeparator && !looksLikeObjectPath(key, nsSeparator, keySeparator);
1006        if (wouldCheckForNsInKey && !seemsNaturalLanguage) {
1007          const m2 = key.match(this.interpolator.nestingRegexp);
1008          if (m2 && m2.length > 0) {
1009            return {
1010              key,
1011              namespaces: isString$4(namespaces) ? [namespaces] : namespaces
1012            };
1013          }
1014          const parts = key.split(nsSeparator);
1015          if (nsSeparator !== keySeparator || nsSeparator === keySeparator && this.options.ns.indexOf(parts[0]) > -1) namespaces = parts.shift();
1016          key = parts.join(keySeparator);
1017        }
1018        return {
1019          key,
1020          namespaces: isString$4(namespaces) ? [namespaces] : namespaces
1021        };
1022      }
1023      translate(keys2, o2, lastKey) {
1024        let opt = typeof o2 === "object" ? __spreadValues({}, o2) : o2;
1025        if (typeof opt !== "object" && this.options.overloadTranslationOptionHandler) {
1026          opt = this.options.overloadTranslationOptionHandler(arguments);
1027        }
1028        if (typeof opt === "object") opt = __spreadValues({}, opt);
1029        if (!opt) opt = {};
1030        if (keys2 == null) return "";
1031        if (typeof keys2 === "function") keys2 = keysFromSelector(keys2, __spreadValues(__spreadValues({}, this.options), opt));
1032        if (!Array.isArray(keys2)) keys2 = [String(keys2)];
1033        const returnDetails = opt.returnDetails !== void 0 ? opt.returnDetails : this.options.returnDetails;

1034        const keySeparator = opt.keySeparator !== void 0 ? opt.keySeparator : this.options.keySeparator;
1035        const {
1036          key,
1037          namespaces
1038        } = this.extractFromKey(keys2[keys2.length - 1], opt);
1039        const namespace = namespaces[namespaces.length - 1];
1040        let nsSeparator = opt.nsSeparator !== void 0 ? opt.nsSeparator : this.options.nsSeparator;
1041        if (nsSeparator === void 0) nsSeparator = ":";
1042        const lng = opt.lng || this.language;
1043        const appendNamespaceToCIMode = opt.appendNamespaceToCIMode || this.options.appendNamespaceToCIMode;
1044        if ((lng == null ? void 0 : lng.toLowerCase()) === "cimode") {
1045          if (appendNamespaceToCIMode) {
1046            if (returnDetails) {
1047              return {
1048                res: `${namespace}${nsSeparator}${key}`,
1049                usedKey: key,
1050                exactUsedKey: key,
1051                usedLng: lng,
1052                usedNS: namespace,
1053                usedParams: this.getUsedParamsDetails(opt)
1054              };
1055            }
1056            return `${namespace}${nsSeparator}${key}`;
1057          }
1058          if (returnDetails) {
1059            return {
1060              res: key,
1061              usedKey: key,
1062              exactUsedKey: key,
1063              usedLng: lng,
1064              usedNS: namespace,
1065              usedParams: this.getUsedParamsDetails(opt)
1066            };
1067          }
1068          return key;
1069        }
1070        const resolved = this.resolve(keys2, opt);
1071        let res = resolved == null ? void 0 : resolved.res;
1072        const resUsedKey = (resolved == null ? void 0 : resolved.usedKey) || key;
1073        const resExactUsedKey = (resolved == null ? void 0 : resolved.exactUsedKey) || key;
1074        const noObject = ["[object Number]", "[object Function]", "[object RegExp]"];
1075        const joinArrays = opt.joinArrays !== void 0 ? opt.joinArrays : this.options.joinArrays;
1076        const handleAsObjectInI18nFormat = !this.i18nFormat || this.i18nFormat.handleAsObject;
1077        const needsPluralHandling = opt.count !== void 0 && !isString$4(opt.count);
1078        const hasDefaultValue = Translator.hasDefaultValue(opt);
1079        const defaultValueSuffix = needsPluralHandling ? this.pluralResolver.getSuffix(lng, opt.count, opt) : "";
1080        const defaultValueSuffixOrdinalFallback = opt.ordinal && needsPluralHandling ? this.pluralResolver.getSuffix(lng, opt.count, {
1081          ordinal: false
1082        }) : "";
1083        const needsZeroSuffixLookup = needsPluralHandling && !opt.ordinal && opt.count === 0;
1084        const defaultValue = needsZeroSuffixLookup && opt[`defaultValue${this.options.pluralSeparator}zero`] || opt[`defaultValue${defaultValueSuffix}`] || opt[`defaultValue${defaultValueSuffixOrdinalFallback}`] || opt.defaultValue;
1085        let resForObjHndl = res;
1086        if (handleAsObjectInI18nFormat && !res && hasDefaultValue) {
1087          resForObjHndl = defaultValue;
1088        }
1089        const handleAsObject = shouldHandleAsObject(resForObjHndl);
1090        const resType = Object.prototype.toString.apply(resForObjHndl);
1091        if (handleAsObjectInI18nFormat && resForObjHndl && handleAsObject && noObject.indexOf(resType) < 0 && !(isString$4(joinArrays) && Array.isArray(resForObjHndl))) {
1092          if (!opt.returnObjects && !this.options.returnObjects) {
1093            if (!this.options.returnedObjectHandler) {
1094              this.logger.warn("accessing an object - but returnObjects options is not enabled!");
1095            }
1096            const r2 = this.options.returnedObjectHandler ? this.options.returnedObjectHandler(resUsedKey, resForObjHndl, __spreadProps(__spreadValues({}, opt), {
1097              ns: namespaces
1098            })) : `key '${key} (${this.language})' returned an object instead of string.`;
1099            if (returnDetails) {
1100              resolved.res = r2;
1101              resolved.usedParams = this.getUsedParamsDetails(opt);
1102              return resolved;
1103            }
1104            return r2;
1105          }
1106          if (keySeparator) {
1107            const resTypeIsArray = Array.isArray(resForObjHndl);
1108            const copy2 = resTypeIsArray ? [] : {};
1109            const newKeyToUse = resTypeIsArray ? resExactUsedKey : resUsedKey;
1110            for (const m2 in resForObjHndl) {
1111              if (Object.prototype.hasOwnProperty.call(resForObjHndl, m2)) {
1112                const deepKey = `${newKeyToUse}${keySeparator}${m2}`;
1113                if (hasDefaultValue && !res) {
1114                  copy2[m2] = this.translate(deepKey, __spreadValues(__spreadProps(__spreadValues({}, opt), {
1115                    defaultValue: shouldHandleAsObject(defaultValue) ? defaultValue[m2] : void 0
1116                  }), {

1117                    joinArrays: false,
1118                    ns: namespaces
1119                  }));
1120                } else {
1121                  copy2[m2] = this.translate(deepKey, __spreadValues(__spreadValues({}, opt), {
1122                    joinArrays: false,
1123                    ns: namespaces
1124                  }));
1125                }
1126                if (copy2[m2] === deepKey) copy2[m2] = resForObjHndl[m2];
1127              }
1128            }
1129            res = copy2;
1130          }
1131        } else if (handleAsObjectInI18nFormat && isString$4(joinArrays) && Array.isArray(res)) {
1132          res = res.join(joinArrays);
1133          if (res) res = this.extendTranslation(res, keys2, opt, lastKey);
1134        } else {
1135          let usedDefault = false;
1136          let usedKey = false;
1137          if (!this.isValidLookup(res) && hasDefaultValue) {
1138            usedDefault = true;
1139            res = defaultValue;
1140          }
1141          if (!this.isValidLookup(res)) {
1142            usedKey = true;
1143            res = key;
1144          }
1145          const missingKeyNoValueFallbackToKey = opt.missingKeyNoValueFallbackToKey || this.options.missingKeyNoValueFallbackToKey;
1146          const resForMissing = missingKeyNoValueFallbackToKey && usedKey ? void 0 : res;
1147          const updateMissing = hasDefaultValue && defaultValue !== res && this.options.updateMissing;
1148          if (usedKey || usedDefault || updateMissing) {
1149            this.logger.log(updateMissing ? "updateKey" : "missingKey", lng, namespace, key, updateMissing ? defaultValue : res);
1150            if (keySeparator) {
1151              const fk = this.resolve(key, __spreadProps(__spreadValues({}, opt), {
1152                keySeparator: false
1153              }));
1154              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.");
1155            }
1156            let lngs = [];
1157            const fallbackLngs = this.languageUtils.getFallbackCodes(this.options.fallbackLng, opt.lng || this.language);
1158            if (this.options.saveMissingTo === "fallback" && fallbackLngs && fallbackLngs[0]) {
1159              for (let i2 = 0; i2 < fallbackLngs.length; i2++) {
1160                lngs.push(fallbackLngs[i2]);
1161              }
1162            } else if (this.options.saveMissingTo === "all") {
1163              lngs = this.languageUtils.toResolveHierarchy(opt.lng || this.language);
1164            } else {
1165              lngs.push(opt.lng || this.language);
1166            }
1167            const send = (l2, k2, specificDefaultValue) => {
1168              var _a;
1169              const defaultForMissing = hasDefaultValue && specificDefaultValue !== res ? specificDefaultValue : resForMissing;
1170              if (this.options.missingKeyHandler) {
1171                this.options.missingKeyHandler(l2, namespace, k2, defaultForMissing, updateMissing, opt);
1172              } else if ((_a = this.backendConnector) == null ? void 0 : _a.saveMissing) {
1173                this.backendConnector.saveMissing(l2, namespace, k2, defaultForMissing, updateMissing, opt);
1174              }
1175              this.emit("missingKey", l2, namespace, k2, res);
1176            };
1177            if (this.options.saveMissing) {
1178              if (this.options.saveMissingPlurals && needsPluralHandling) {
1179                lngs.forEach((language) => {
1180                  const suffixes = this.pluralResolver.getSuffixes(language, opt);
1181                  if (needsZeroSuffixLookup && opt[`defaultValue${this.options.pluralSeparator}zero`] && suffixes.indexOf(`${this.options.pluralSeparator}zero`) < 0) {
1182                    suffixes.push(`${this.options.pluralSeparator}zero`);
1183                  }
1184                  suffixes.forEach((suffix) => {
1185                    send([language], key + suffix, opt[`defaultValue${suffix}`] || defaultValue);
1186                  });
1187                });
1188              } else {
1189                send(lngs, key, defaultValue);
1190              }
1191            }
1192          }
1193          res = this.extendTranslation(res, keys2, opt, resolved, lastKey);
1194          if (usedKey && res === key && this.options.appendNamespaceToMissingKey) {
1195            res = `${namespace}${nsSeparator}${key}`;
1196          }
1197          if ((usedKey || usedDefault) && this.options.parseMissingKeyHandler) {
1198            res = this.options.parseMissingKeyHandler(this.options.appendNamespaceToMissingKey ? `${namespace}${nsSeparator}${key}` : key, usedDefault ? res : void 0, opt);
1199          }
1200        }
1201        if (returnDetails) {
1202          resolved.res = res;
1203          resolved.usedParams = this.getUsedParamsDetails(opt);
1204          return resolved;
1205        }
1206        return res;
1207      }
1208      extendTranslation(res, key, opt, resolved, lastKey) {
1209        var _a, _b;
1210        if ((_a = this.i18nFormat) == null ? void 0 : _a.parse) {
1211          res = this.i18nFormat.parse(res, __spreadValues(__spreadValues({}, this.options.interpolation.defaultVariables), opt), opt.lng || this.language || resolved.usedLng, resolved.usedNS, resolved.usedKey, {
1212            resolved
1213          });
1214        } else if (!opt.skipInterpolation) {
1215          if (opt.interpolation) this.interpolator.init(__spreadValues(__spreadValues({}, opt), {
1216            interpolation: __spreadValues(__spreadValues({}, this.options.interpolation), opt.interpolation)
1217          }));
1218          const skipOnVariables = isString$4(res) && (((_b = opt == null ? void 0 : opt.interpolation) == null ? void 0 : _b.skipOnVariables) !== void 0 ? opt.interpolation.skipOnVariables : this.options.interpolation.skipOnVariables);
1219          let nestBef;
1220          if (skipOnVariables) {
1221            const nb = res.match(this.interpolator.nestingRegexp);
1222            nestBef = nb && nb.length;
1223          }
1224          let data = opt.replace && !isString$4(opt.replace) ? opt.replace : opt;
1225          if (this.options.interpolation.defaultVariables) data = __spreadValues(__spreadValues({}, this.options.interpolation.defaultVariables), data);
1226          res = this.interpolator.interpolate(res, data, opt.lng || this.language || resolved.usedLng, opt);
1227          if (skipOnVariables) {
1228            const na2 = res.match(this.interpolator.nestingRegexp);
1229            const nestAft = na2 && na2.length;
1230            if (nestBef < nestAft) opt.nest = false;

1231          }
1232          if (!opt.lng && resolved && resolved.res) opt.lng = this.language || resolved.usedLng;
1233          if (opt.nest !== false) res = this.interpolator.nest(res, (...args) => {
1234            if ((lastKey == null ? void 0 : lastKey[0]) === args[0] && !opt.context) {
1235              this.logger.warn(`It seems you are nesting recursively key: ${args[0]} in key: ${key[0]}`);
1236              return null;
1237            }
1238            return this.translate(...args, key);
1239          }, opt);
1240          if (opt.interpolation) this.interpolator.reset();
1241        }
1242        const postProcess = opt.postProcess || this.options.postProcess;
1243        const postProcessorNames = isString$4(postProcess) ? [postProcess] : postProcess;
1244        if (res != null && (postProcessorNames == null ? void 0 : postProcessorNames.length) && opt.applyPostProcessor !== false) {
1245          res = postProcessor.handle(postProcessorNames, res, key, this.options && this.options.postProcessPassResolved ? __spreadValues({
1246            i18nResolved: __spreadProps(__spreadValues({}, resolved), {
1247              usedParams: this.getUsedParamsDetails(opt)
1248            })
1249          }, opt) : opt, this);
1250        }
1251        return res;
1252      }
1253      resolve(keys2, opt = {}) {
1254        let found;
1255        let usedKey;
1256        let exactUsedKey;
1257        let usedLng;
1258        let usedNS;
1259        if (isString$4(keys2)) keys2 = [keys2];
1260        keys2.forEach((k2) => {
1261          if (this.isValidLookup(found)) return;
1262          const extracted = this.extractFromKey(k2, opt);
1263          const key = extracted.key;
1264          usedKey = key;
1265          let namespaces = extracted.namespaces;
1266          if (this.options.fallbackNS) namespaces = namespaces.concat(this.options.fallbackNS);
1267          const needsPluralHandling = opt.count !== void 0 && !isString$4(opt.count);
1268          const needsZeroSuffixLookup = needsPluralHandling && !opt.ordinal && opt.count === 0;
1269          const needsContextHandling = opt.context !== void 0 && (isString$4(opt.context) || typeof opt.context === "number") && opt.context !== "";
1270          const codes = opt.lngs ? opt.lngs : this.languageUtils.toResolveHierarchy(opt.lng || this.language, opt.fallbackLng);
1271          namespaces.forEach((ns) => {
1272            var _a, _b;
1273            if (this.isValidLookup(found)) return;
1274            usedNS = ns;
1275            if (!checkedLoadedFor[`${codes[0]}-${ns}`] && ((_a = this.utils) == null ? void 0 : _a.hasLoadedNamespace) && !((_b = this.utils) == null ? void 0 : _b.hasLoadedNamespace(usedNS))) {
1276              checkedLoadedFor[`${codes[0]}-${ns}`] = true;
1277              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!!!");
1278            }
1279            codes.forEach((code) => {
1280              var _a2;
1281              if (this.isValidLookup(found)) return;
1282              usedLng = code;
1283              const finalKeys = [key];
1284              if ((_a2 = this.i18nFormat) == null ? void 0 : _a2.addLookupKeys) {
1285                this.i18nFormat.addLookupKeys(finalKeys, key, code, ns, opt);
1286              } else {
1287                let pluralSuffix;
1288                if (needsPluralHandling) pluralSuffix = this.pluralResolver.getSuffix(code, opt.count, opt);
1289                const zeroSuffix = `${this.options.pluralSeparator}zero`;
1290                const ordinalPrefix = `${this.options.pluralSeparator}ordinal${this.options.pluralSeparator}`;
1291                if (needsPluralHandling) {
1292                  if (opt.ordinal && pluralSuffix.indexOf(ordinalPrefix) === 0) {
1293                    finalKeys.push(key + pluralSuffix.replace(ordinalPrefix, this.options.pluralSeparator));
1294                  }
1295                  finalKeys.push(key + pluralSuffix);
1296                  if (needsZeroSuffixLookup) {
1297                    finalKeys.push(key + zeroSuffix);
1298                  }
1299                }
1300                if (needsContextHandling) {
1301                  const contextKey = `${key}${this.options.contextSeparator || "_"}${opt.context}`;
1302                  finalKeys.push(contextKey);
1303                  if (needsPluralHandling) {
1304                    if (opt.ordinal && pluralSuffix.indexOf(ordinalPrefix) === 0) {
1305                      finalKeys.push(contextKey + pluralSuffix.replace(ordinalPrefix, this.options.pluralSeparator));
1306                    }
1307                    finalKeys.push(contextKey + pluralSuffix);
1308                    if (needsZeroSuffixLookup) {
1309                      finalKeys.push(contextKey + zeroSuffix);
1310                    }
1311                  }
1312                }
1313              }
1314              let possibleKey;
1315              while (possibleKey = finalKeys.pop()) {
1316                if (!this.isValidLookup(found)) {
1317                  exactUsedKey = possibleKey;
1318                  found = this.getResource(code, ns, possibleKey, opt);
1319                }
1320              }
1321            });
1322          });
1323        });
1324        return {
1325          res: found,
1326          usedKey,
1327          exactUsedKey,
1328          usedLng,
1329          usedNS
1330        };
1331      }
1332      isValidLookup(res) {
1333        return res !== void 0 && !(!this.options.returnNull && res === null) && !(!this.options.returnEmptyString && res === "");
1334      }
1335      getResource(code, ns, key, options2 = {}) {
1336        var _a;
1337        if ((_a = this.i18nFormat) == null ? void 0 : _a.getResource) return this.i18nFormat.getResource(code, ns, key, options2);
1338        return this.resourceStore.getResource(code, ns, key, options2);
1339      }
1340      getUsedParamsDetails(options2 = {}) {
1341        const optionsKeys = ["defaultValue", "ordinal", "context", "replace", "lng", "lngs", "fallbackLng", "ns", "keySeparator", "nsSeparator", "returnObjects", "returnDetails", "joinArrays", "postProcess", "interpolation"];
1342        const useOptionsReplaceForData = options2.replace && !isString$4(options2.replace);
1343        let data = useOptionsReplaceForData ? options2.replace : options2;
1344        if (useOptionsReplaceForData && typeof options2.count !== "undefined") {
1345          data.count = options2.count;
1346        }
1347        if (this.options.interpolation.defaultVariables) {
1348          data = __spreadValues(__spreadValues({}, this.options.interpolation.defaultVariables), data);
1349        }
1350        if (!useOptionsReplaceForData) {
1351          data = __spreadValues({}, data);
1352          for (const key of optionsKeys) {
1353            delete data[key];
1354          }
1355        }
1356        return data;
1357      }
1358      static hasDefaultValue(options2) {
1359        const prefix2 = "defaultValue";
1360        for (const option in options2) {
1361          if (Object.prototype.hasOwnProperty.call(options2, option) && prefix2 === option.substring(0, prefix2.length) && void 0 !== options2[option]) {
1362            return true;
1363          }
1364        }
1365        return false;

1366      }
1367    }
1368    class LanguageUtil {
1369      constructor(options2) {
1370        this.options = options2;
1371        this.supportedLngs = this.options.supportedLngs || false;
1372        this.logger = baseLogger.create("languageUtils");
1373      }
1374      getScriptPartFromCode(code) {
1375        code = getCleanedCode(code);
1376        if (!code || code.indexOf("-") < 0) return null;
1377        const p2 = code.split("-");
1378        if (p2.length === 2) return null;
1379        p2.pop();
1380        if (p2[p2.length - 1].toLowerCase() === "x") return null;
1381        return this.formatLanguageCode(p2.join("-"));
1382      }
1383      getLanguagePartFromCode(code) {
1384        code = getCleanedCode(code);
1385        if (!code || code.indexOf("-") < 0) return code;
1386        const p2 = code.split("-");
1387        return this.formatLanguageCode(p2[0]);
1388      }
1389      formatLanguageCode(code) {
1390        if (isString$4(code) && code.indexOf("-") > -1) {
1391          let formattedCode;
1392          try {
1393            formattedCode = Intl.getCanonicalLocales(code)[0];
1394          } catch (e2) {
1395          }
1396          if (formattedCode && this.options.lowerCaseLng) {
1397            formattedCode = formattedCode.toLowerCase();
1398          }
1399          if (formattedCode) return formattedCode;
1400          if (this.options.lowerCaseLng) {
1401            return code.toLowerCase();
1402          }
1403          return code;
1404        }
1405        return this.options.cleanCode || this.options.lowerCaseLng ? code.toLowerCase() : code;
1406      }
1407      isSupportedCode(code) {
1408        if (this.options.load === "languageOnly" || this.options.nonExplicitSupportedLngs) {
1409          code = this.getLanguagePartFromCode(code);
1410        }
1411        return !this.supportedLngs || !this.supportedLngs.length || this.supportedLngs.indexOf(code) > -1;
1412      }
1413      getBestMatchFromCodes(codes) {
1414        if (!codes) return null;
1415        let found;
1416        codes.forEach((code) => {
1417          if (found) return;
1418          const cleanedLng = this.formatLanguageCode(code);
1419          if (!this.options.supportedLngs || this.isSupportedCode(cleanedLng)) found = cleanedLng;
1420        });
1421        if (!found && this.options.supportedLngs) {
1422          codes.forEach((code) => {
1423            if (found) return;
1424            const lngScOnly = this.getScriptPartFromCode(code);
1425            if (this.isSupportedCode(lngScOnly)) return found = lngScOnly;
1426            const lngOnly = this.getLanguagePartFromCode(code);
1427            if (this.isSupportedCode(lngOnly)) return found = lngOnly;
1428            found = this.options.supportedLngs.find((supportedLng) => {
1429              if (supportedLng === lngOnly) return supportedLng;
1430              if (supportedLng.indexOf("-") < 0 && lngOnly.indexOf("-") < 0) return;
1431              if (supportedLng.indexOf("-") > 0 && lngOnly.indexOf("-") < 0 && supportedLng.substring(0, supportedLng.indexOf("-")) === lngOnly) return supportedLng;
1432              if (supportedLng.indexOf(lngOnly) === 0 && lngOnly.length > 1) return supportedLng;
1433            });
1434          });
1435        }
1436        if (!found) found = this.getFallbackCodes(this.options.fallbackLng)[0];
1437        return found;
1438      }
1439      getFallbackCodes(fallbacks, code) {
1440        if (!fallbacks) return [];
1441        if (typeof fallbacks === "function") fallbacks = fallbacks(code);
1442        if (isString$4(fallbacks)) fallbacks = [fallbacks];
1443        if (Array.isArray(fallbacks)) return fallbacks;
1444        if (!code) return fallbacks.default || [];
1445        let found = fallbacks[code];
1446        if (!found) found = fallbacks[this.getScriptPartFromCode(code)];
1447        if (!found) found = fallbacks[this.formatLanguageCode(code)];
1448        if (!found) found = fallbacks[this.getLanguagePartFromCode(code)];
1449        if (!found) found = fallbacks.default;
1450        return found || [];
1451      }
1452      toResolveHierarchy(code, fallbackCode) {
1453        const fallbackCodes = this.getFallbackCodes((fallbackCode === false ? [] : fallbackCode) || this.options.fallbackLng || [], code);
1454        const codes = [];
1455        const addCode = (c2) => {
1456          if (!c2) return;
1457          if (this.isSupportedCode(c2)) {
1458            codes.push(c2);
1459          } else {
1460            this.logger.warn(`rejecting language code not found in supportedLngs: ${c2}`);
1461          }
1462        };
1463        if (isString$4(code) && (code.indexOf("-") > -1 || code.indexOf("_") > -1)) {
1464          if (this.options.load !== "languageOnly") addCode(this.formatLanguageCode(code));
1465          if (this.options.load !== "languageOnly" && this.options.load !== "currentOnly") addCode(this.getScriptPartFromCode(code));
1466          if (this.options.load !== "currentOnly") addCode(this.getLanguagePartFromCode(code));
1467        } else if (isString$4(code)) {
1468          addCode(this.formatLanguageCode(code));
1469        }

1470        fallbackCodes.forEach((fc) => {
1471          if (codes.indexOf(fc) < 0) addCode(this.formatLanguageCode(fc));
1472        });
1473        return codes;
1474      }
1475    }
1476    const suffixesOrder = {
1477      zero: 0,
1478      one: 1,
1479      two: 2,
1480      few: 3,
1481      many: 4,
1482      other: 5
1483    };
1484    const dummyRule = {
1485      select: (count2) => count2 === 1 ? "one" : "other",
1486      resolvedOptions: () => ({
1487        pluralCategories: ["one", "other"]
1488      })
1489    };
1490    class PluralResolver {
1491      constructor(languageUtils, options2 = {}) {
1492        this.languageUtils = languageUtils;
1493        this.options = options2;
1494        this.logger = baseLogger.create("pluralResolver");
1495        this.pluralRulesCache = {};
1496      }
1497      addRule(lng, obj) {
1498        this.rules[lng] = obj;
1499      }
1500      clearCache() {
1501        this.pluralRulesCache = {};
1502      }
1503      getRule(code, options2 = {}) {
1504        const cleanedCode = getCleanedCode(code === "dev" ? "en" : code);
1505        const type = options2.ordinal ? "ordinal" : "cardinal";
1506        const cacheKey = JSON.stringify({
1507          cleanedCode,
1508          type
1509        });
1510        if (cacheKey in this.pluralRulesCache) {
1511          return this.pluralRulesCache[cacheKey];
1512        }
1513        let rule;
1514        try {
1515          rule = new Intl.PluralRules(cleanedCode, {
1516            type
1517          });
1518        } catch (err) {
1519          if (!Intl) {
1520            this.logger.error("No Intl support, please use an Intl polyfill!");
1521            return dummyRule;
1522          }
1523          if (!code.match(/-|_/)) return dummyRule;
1524          const lngPart = this.languageUtils.getLanguagePartFromCode(code);
1525          rule = this.getRule(lngPart, options2);
1526        }
1527        this.pluralRulesCache[cacheKey] = rule;
1528        return rule;
1529      }
1530      needsPlural(code, options2 = {}) {
1531        let rule = this.getRule(code, options2);
1532        if (!rule) rule = this.getRule("dev", options2);
1533        return (rule == null ? void 0 : rule.resolvedOptions().pluralCategories.length) > 1;
1534      }
1535      getPluralFormsOfKey(code, key, options2 = {}) {
1536        return this.getSuffixes(code, options2).map((suffix) => `${key}${suffix}`);
1537      }
1538      getSuffixes(code, options2 = {}) {
1539        let rule = this.getRule(code, options2);
1540        if (!rule) rule = this.getRule("dev", options2);
1541        if (!rule) return [];
1542        return rule.resolvedOptions().pluralCategories.sort((pluralCategory1, pluralCategory2) => suffixesOrder[pluralCategory1] - suffixesOrder[pluralCategory2]).map((pluralCategory) => `${this.options.prepend}${options2.ordinal ? `ordinal${this.options.prepend}` : ""}${pluralCategory}`);
1543      }
1544      getSuffix(code, count2, options2 = {}) {
1545        const rule = this.getRule(code, options2);
1546        if (rule) {
1547          return `${this.options.prepend}${options2.ordinal ? `ordinal${this.options.prepend}` : ""}${rule.select(count2)}`;
1548        }
1549        this.logger.warn(`no plural rule found for: ${code}`);
1550        return this.getSuffix("dev", count2, options2);
1551      }
1552    }
1553    const deepFindWithDefaults = (data, defaultData, key, keySeparator = ".", ignoreJSONStructure = true) => {
1554      let path = getPathWithDefaults(data, defaultData, key);
1555      if (!path && ignoreJSONStructure && isString$4(key)) {

1556        path = deepFind(data, key, keySeparator);
1557        if (path === void 0) path = deepFind(defaultData, key, keySeparator);
1558      }
1559      return path;
1560    };
1561    const regexSafe = (val) => val.replace(/\$/g, "$$$$");
1562    class Interpolator {
1563      constructor(options2 = {}) {
1564        var _a;
1565        this.logger = baseLogger.create("interpolator");
1566        this.options = options2;
1567        this.format = ((_a = options2 == null ? void 0 : options2.interpolation) == null ? void 0 : _a.format) || ((value) => value);
1568        this.init(options2);
1569      }
1570      init(options2 = {}) {
1571        if (!options2.interpolation) options2.interpolation = {
1572          escapeValue: true
1573        };
1574        const {
1575          escape: escape$1$1,
1576          escapeValue,
1577          useRawValueToEscape,
1578          prefix: prefix2,
1579          prefixEscaped,
1580          suffix,
1581          suffixEscaped,
1582          formatSeparator,
1583          unescapeSuffix,
1584          unescapePrefix,
1585          nestingPrefix,
1586          nestingPrefixEscaped,
1587          nestingSuffix,
1588          nestingSuffixEscaped,
1589          nestingOptionsSeparator,
1590          maxReplaces,
1591          alwaysFormat
1592        } = options2.interpolation;
1593        this.escape = escape$1$1 !== void 0 ? escape$1$1 : escape$1;
1594        this.escapeValue = escapeValue !== void 0 ? escapeValue : true;
1595        this.useRawValueToEscape = useRawValueToEscape !== void 0 ? useRawValueToEscape : false;

1596        this.prefix = prefix2 ? regexEscape(prefix2) : prefixEscaped || "{{";
1597        this.suffix = suffix ? regexEscape(suffix) : suffixEscaped || "}}";
1598        this.formatSeparator = formatSeparator || ",";
1599        this.unescapePrefix = unescapeSuffix ? "" : unescapePrefix || "-";
1600        this.unescapeSuffix = this.unescapePrefix ? "" : unescapeSuffix || "";
1601        this.nestingPrefix = nestingPrefix ? regexEscape(nestingPrefix) : nestingPrefixEscaped || regexEscape("$t(");
1602        this.nestingSuffix = nestingSuffix ? regexEscape(nestingSuffix) : nestingSuffixEscaped || regexEscape(")");
1603        this.nestingOptionsSeparator = nestingOptionsSeparator || ",";
1604        this.maxReplaces = maxReplaces || 1e3;
1605        this.alwaysFormat = alwaysFormat !== void 0 ? alwaysFormat : false;
1606        this.resetRegExp();
1607      }
1608      reset() {
1609        if (this.options) this.init(this.options);
1610      }
1611      resetRegExp() {
1612        const getOrResetRegExp = (existingRegExp, pattern) => {
1613          if ((existingRegExp == null ? void 0 : existingRegExp.source) === pattern) {
1614            existingRegExp.lastIndex = 0;
1615            return existingRegExp;
1616          }
1617          return new RegExp(pattern, "g");
1618        };
1619        this.regexp = getOrResetRegExp(this.regexp, `${this.prefix}(.+?)${this.suffix}`);
1620        this.regexpUnescape = getOrResetRegExp(this.regexpUnescape, `${this.prefix}${this.unescapePrefix}(.+?)${this.unescapeSuffix}${this.suffix}`);
1621        this.nestingRegexp = getOrResetRegExp(this.nestingRegexp, `${this.nestingPrefix}((?:[^()"']+|"[^"]*"|'[^']*'|\\((?:[^()]|"[^"]*"|'[^']*')*\\))*?)${this.nestingSuffix}`);
1622      }
1623      interpolate(str, data, lng, options2) {
1624        var _a;
1625        let match2;
1626        let value;
1627        let replaces;
1628        const defaultData = this.options && this.options.interpolation && this.options.interpolation.defaultVariables || {};
1629        const handleFormat = (key) => {
1630          if (key.indexOf(this.formatSeparator) < 0) {
1631            const path = deepFindWithDefaults(data, defaultData, key, this.options.keySeparator, this.options.ignoreJSONStructure);
1632            return this.alwaysFormat ? this.format(path, void 0, lng, __spreadProps(__spreadValues(__spreadValues({}, options2), data), {
1633              interpolationkey: key
1634            })) : path;
1635          }
1636          const p2 = key.split(this.formatSeparator);
1637          const k2 = p2.shift().trim();
1638          const f2 = p2.join(this.formatSeparator).trim();
1639          return this.format(deepFindWithDefaults(data, defaultData, k2, this.options.keySeparator, this.options.ignoreJSONStructure), f2, lng, __spreadProps(__spreadValues(__spreadValues({}, options2), data), {
1640            interpolationkey: k2
1641          }));
1642        };
1643        this.resetRegExp();
1644        const missingInterpolationHandler = (options2 == null ? void 0 : options2.missingInterpolationHandler) || this.options.missingInterpolationHandler;
1645        const skipOnVariables = ((_a = options2 == null ? void 0 : options2.interpolation) == null ? void 0 : _a.skipOnVariables) !== void 0 ? options2.interpolation.skipOnVariables : this.options.interpolation.skipOnVariables;
1646        const todos = [{
1647          regex: this.regexpUnescape,
1648          safeValue: (val) => regexSafe(val)
1649        }, {
1650          regex: this.regexp,
1651          safeValue: (val) => this.escapeValue ? regexSafe(this.escape(val)) : regexSafe(val)
1652        }];
1653        todos.forEach((todo) => {
1654          replaces = 0;
1655          while (match2 = todo.regex.exec(str)) {
1656            const matchedVar = match2[1].trim();
1657            value = handleFormat(matchedVar);
1658            if (value === void 0) {
1659              if (typeof missingInterpolationHandler === "function") {
1660                const temp = missingInterpolationHandler(str, match2, options2);
1661                value = isString$4(temp) ? temp : "";
1662              } else if (options2 && Object.prototype.hasOwnProperty.call(options2, matchedVar)) {
1663                value = "";
1664              } else if (skipOnVariables) {
1665                value = match2[0];
1666                continue;
1667              } else {
1668                this.logger.warn(`missed to pass in variable ${matchedVar} for interpolating ${str}`);
1669                value = "";
1670              }
1671            } else if (!isString$4(value) && !this.useRawValueToEscape) {
1672              value = makeString(value);
1673            }
1674            const safeValue = todo.safeValue(value);
1675            str = str.replace(match2[0], safeValue);
1676            if (skipOnVariables) {
1677              todo.regex.lastIndex += value.length;
1678              todo.regex.lastIndex -= match2[0].length;
1679            } else {
1680              todo.regex.lastIndex = 0;
1681            }
1682            replaces++;
1683            if (replaces >= this.maxReplaces) {
1684              break;
1685            }
1686          }
1687        });
1688        return str;
1689      }
1690      nest(str, fc, options2 = {}) {
1691        let match2;
1692        let value;
1693        let clonedOptions;
1694        const handleHasOptions = (key, inheritedOptions) => {
1695          var _a;
1696          const sep = this.nestingOptionsSeparator;
1697          if (key.indexOf(sep) < 0) return key;
1698          const c2 = key.split(new RegExp(`${sep}[ ]*{`));
1699          let optionsString = `{${c2[1]}`;
1700          key = c2[0];
1701          optionsString = this.interpolate(optionsString, clonedOptions);
1702          const matchedSingleQuotes = optionsString.match(/'/g);
1703          const matchedDoubleQuotes = optionsString.match(/"/g);
1704          if (((_a = matchedSingleQuotes == null ? void 0 : matchedSingleQuotes.length) != null ? _a : 0) % 2 === 0 && !matchedDoubleQuotes || matchedDoubleQuotes.length % 2 !== 0) {
1705            optionsString = optionsString.replace(/'/g, '"');
1706          }
1707          try {
1708            clonedOptions = JSON.parse(optionsString);
1709            if (inheritedOptions) clonedOptions = __spreadValues(__spreadValues({}, inheritedOptions), clonedOptions);
1710          } catch (e2) {
1711            this.logger.warn(`failed parsing options string in nesting for key ${key}`, e2);
1712            return `${key}${sep}${optionsString}`;
1713          }
1714          if (clonedOptions.defaultValue && clonedOptions.defaultValue.indexOf(this.prefix) > -1) delete clonedOptions.defaultValue;
1715          return key;
1716        };
1717        while (match2 = this.nestingRegexp.exec(str)) {
1718          let formatters = [];
1719          clonedOptions = __spreadValues({}, options2);
1720          clonedOptions = clonedOptions.replace && !isString$4(clonedOptions.replace) ? clonedOptions.replace : clonedOptions;
1721          clonedOptions.applyPostProcessor = false;

1722          delete clonedOptions.defaultValue;
1723          const keyEndIndex = /{.*}/.test(match2[1]) ? match2[1].lastIndexOf("}") + 1 : match2[1].indexOf(this.formatSeparator);
1724          if (keyEndIndex !== -1) {
1725            formatters = match2[1].slice(keyEndIndex).split(this.formatSeparator).map((elem) => elem.trim()).filter(Boolean);
1726            match2[1] = match2[1].slice(0, keyEndIndex);
1727          }
1728          value = fc(handleHasOptions.call(this, match2[1].trim(), clonedOptions), clonedOptions);
1729          if (value && match2[0] === str && !isString$4(value)) return value;
1730          if (!isString$4(value)) value = makeString(value);
1731          if (!value) {
1732            this.logger.warn(`missed to resolve ${match2[1]} for nesting ${str}`);
1733            value = "";
1734          }
1735          if (formatters.length) {
1736            value = formatters.reduce((v2, f2) => this.format(v2, f2, options2.lng, __spreadProps(__spreadValues({}, options2), {
1737              interpolationkey: match2[1].trim()
1738            })), value.trim());
1739          }
1740          str = str.replace(match2[0], value);
1741          this.regexp.lastIndex = 0;
1742        }
1743        return str;
1744      }
1745    }
1746    const parseFormatStr = (formatStr) => {
1747      let formatName = formatStr.toLowerCase().trim();
1748      const formatOptions = {};
1749      if (formatStr.indexOf("(") > -1) {
1750        const p2 = formatStr.split("(");
1751        formatName = p2[0].toLowerCase().trim();
1752        const optStr = p2[1].substring(0, p2[1].length - 1);
1753        if (formatName === "currency" && optStr.indexOf(":") < 0) {
1754          if (!formatOptions.currency) formatOptions.currency = optStr.trim();
1755        } else if (formatName === "relativetime" && optStr.indexOf(":") < 0) {
1756          if (!formatOptions.range) formatOptions.range = optStr.trim();
1757        } else {
1758          const opts = optStr.split(";");
1759          opts.forEach((opt) => {
1760            if (opt) {
1761              const [key, ...rest] = opt.split(":");
1762              const val = rest.join(":").trim().replace(/^'+|'+$/g, "");
1763              const trimmedKey = key.trim();
1764              if (!formatOptions[trimmedKey]) formatOptions[trimmedKey] = val;
1765              if (val === "false") formatOptions[trimmedKey] = false;
1766              if (val === "true") formatOptions[trimmedKey] = true;
1767              if (!isNaN(val)) formatOptions[trimmedKey] = parseInt(val, 10);
1768            }
1769          });
1770        }
1771      }
1772      return {
1773        formatName,
1774        formatOptions
1775      };
1776    };
1777    const createCachedFormatter = (fn2) => {
1778      const cache = {};
1779      return (v2, l2, o2) => {
1780        let optForCache = o2;
1781        if (o2 && o2.interpolationkey && o2.formatParams && o2.formatParams[o2.interpolationkey] && o2[o2.interpolationkey]) {
1782          optForCache = __spreadProps(__spreadValues({}, optForCache), {
1783            [o2.interpolationkey]: void 0
1784          });
1785        }
1786        const key = l2 + JSON.stringify(optForCache);
1787        let frm = cache[key];
1788        if (!frm) {
1789          frm = fn2(getCleanedCode(l2), o2);
1790          cache[key] = frm;
1791        }
1792        return frm(v2);
1793      };
1794    };
1795    const createNonCachedFormatter = (fn2) => (v2, l2, o2) => fn2(getCleanedCode(l2), o2)(v2);
1796    class Formatter {
1797      constructor(options2 = {}) {
1798        this.logger = baseLogger.create("formatter");
1799        this.options = options2;
1800        this.init(options2);
1801      }
1802      init(services, options2 = {
1803        interpolation: {}
1804      }) {
1805        this.formatSeparator = options2.interpolation.formatSeparator || ",";
1806        const cf = options2.cacheInBuiltFormats ? createCachedFormatter : createNonCachedFormatter;
1807        this.formats = {
1808          number: cf((lng, opt) => {
1809            const formatter = new Intl.NumberFormat(lng, __spreadValues({}, opt));
1810            return (val) => formatter.format(val);
1811          }),
1812          currency: cf((lng, opt) => {
1813            const formatter = new Intl.NumberFormat(lng, __spreadProps(__spreadValues({}, opt), {
1814              style: "currency"
1815            }));
1816            return (val) => formatter.format(val);
1817          }),
1818          datetime: cf((lng, opt) => {
1819            const formatter = new Intl.DateTimeFormat(lng, __spreadValues({}, opt));
1820            return (val) => formatter.format(val);
1821          }),
1822          relativetime: cf((lng, opt) => {
1823            const formatter = new Intl.RelativeTimeFormat(lng, __spreadValues({}, opt));
1824            return (val) => formatter.format(val, opt.range || "day");
1825          }),
1826          list: cf((lng, opt) => {
1827            const formatter = new Intl.ListFormat(lng, __spreadValues({}, opt));
1828            return (val) => formatter.format(val);
1829          })
1830        };
1831      }
1832      add(name, fc) {
1833        this.formats[name.toLowerCase().trim()] = fc;
1834      }
1835      addCached(name, fc) {
1836        this.formats[name.toLowerCase().trim()] = createCachedFormatter(fc);
1837      }
1838      format(value, format, lng, options2 = {}) {
1839        const formats = format.split(this.formatSeparator);
1840        if (formats.length > 1 && formats[0].indexOf("(") > 1 && formats[0].indexOf(")") < 0 && formats.find((f2) => f2.indexOf(")") > -1)) {
1841          const lastIndex = formats.findIndex((f2) => f2.indexOf(")") > -1);
1842          formats[0] = [formats[0], ...formats.splice(1, lastIndex)].join(this.formatSeparator);
1843        }
1844        const result = formats.reduce((mem, f2) => {
1845          var _a;
1846          const {
1847            formatName,
1848            formatOptions
1849          } = parseFormatStr(f2);
1850          if (this.formats[formatName]) {
1851            let formatted = mem;
1852            try {
1853              const valOptions = ((_a = options2 == null ? void 0 : options2.formatParams) == null ? void 0 : _a[options2.interpolationkey]) || {};
1854              const l2 = valOptions.locale || valOptions.lng || options2.locale || options2.lng || lng;
1855              formatted = this.formats[formatName](mem, l2, __spreadValues(__spreadValues(__spreadValues({}, formatOptions), options2), valOptions));
1856            } catch (error) {
1857              this.logger.warn(error);
1858            }
1859            return formatted;
1860          } else {
1861            this.logger.warn(`there was no format function for ${formatName}`);
1862          }
1863          return mem;
1864        }, value);
1865        return result;
1866      }
1867    }
1868    const removePending = (q2, name) => {
1869      if (q2.pending[name] !== void 0) {
1870        delete q2.pending[name];
1871        q2.pendingCount--;
1872      }
1873    };

1874    class Connector extends EventEmitter {
1875      constructor(backend, store, services, options2 = {}) {
1876        var _a, _b;
1877        super();
1878        this.backend = backend;
1879        this.store = store;
1880        this.services = services;
1881        this.languageUtils = services.languageUtils;
1882        this.options = options2;
1883        this.logger = baseLogger.create("backendConnector");
1884        this.waitingReads = [];
1885        this.maxParallelReads = options2.maxParallelReads || 10;
1886        this.readingCalls = 0;
1887        this.maxRetries = options2.maxRetries >= 0 ? options2.maxRetries : 5;
1888        this.retryTimeout = options2.retryTimeout >= 1 ? options2.retryTimeout : 350;
1889        this.state = {};
1890        this.queue = [];
1891        (_b = (_a = this.backend) == null ? void 0 : _a.init) == null ? void 0 : _b.call(_a, services, options2.backend, options2);
1892      }
1893      queueLoad(languages, namespaces, options2, callback) {
1894        const toLoad = {};
1895        const pending = {};
1896        const toLoadLanguages = {};
1897        const toLoadNamespaces = {};

1898        languages.forEach((lng) => {
1899          let hasAllNamespaces = true;
1900          namespaces.forEach((ns) => {
1901            const name = `${lng}|${ns}`;
1902            if (!options2.reload && this.store.hasResourceBundle(lng, ns)) {
1903              this.state[name] = 2;
1904            } else if (this.state[name] < 0) ;
1905            else if (this.state[name] === 1) {
1906              if (pending[name] === void 0) pending[name] = true;
1907            } else {
1908              this.state[name] = 1;
1909              hasAllNamespaces = false;
1910              if (pending[name] === void 0) pending[name] = true;
1911              if (toLoad[name] === void 0) toLoad[name] = true;
1912              if (toLoadNamespaces[ns] === void 0) toLoadNamespaces[ns] = true;
1913            }
1914          });
1915          if (!hasAllNamespaces) toLoadLanguages[lng] = true;
1916        });
1917        if (Object.keys(toLoad).length || Object.keys(pending).length) {
1918          this.queue.push({
1919            pending,
1920            pendingCount: Object.keys(pending).length,
1921            loaded: {},
1922            errors: [],
1923            callback
1924          });
1925        }
1926        return {
1927          toLoad: Object.keys(toLoad),
1928          pending: Object.keys(pending),
1929          toLoadLanguages: Object.keys(toLoadLanguages),
1930          toLoadNamespaces: Object.keys(toLoadNamespaces)
1931        };
1932      }
1933      loaded(name, err, data) {
1934        const s2 = name.split("|");
1935        const lng = s2[0];
1936        const ns = s2[1];
1937        if (err) this.emit("failedLoading", lng, ns, err);
1938        if (!err && data) {
1939          this.store.addResourceBundle(lng, ns, data, void 0, void 0, {
1940            skipCopy: true
1941          });
1942        }
1943        this.state[name] = err ? -1 : 2;
1944        if (err && data) this.state[name] = 0;
1945        const loaded = {};
1946        this.queue.forEach((q2) => {
1947          pushPath(q2.loaded, [lng], ns);
1948          removePending(q2, name);
1949          if (err) q2.errors.push(err);
1950          if (q2.pendingCount === 0 && !q2.done) {
1951            Object.keys(q2.loaded).forEach((l2) => {
1952              if (!loaded[l2]) loaded[l2] = {};
1953              const loadedKeys = q2.loaded[l2];
1954              if (loadedKeys.length) {
1955                loadedKeys.forEach((n2) => {
1956                  if (loaded[l2][n2] === void 0) loaded[l2][n2] = true;
1957                });
1958              }
1959            });
1960            q2.done = true;
1961            if (q2.errors.length) {
1962              q2.callback(q2.errors);
1963            } else {
1964              q2.callback();
1965            }
1966          }
1967        });
1968        this.emit("loaded", loaded);
1969        this.queue = this.queue.filter((q2) => !q2.done);
1970      }
1971      read(lng, ns, fcName, tried = 0, wait = this.retryTimeout, callback) {
1972        if (!lng.length) return callback(null, {});
1973        if (this.readingCalls >= this.maxParallelReads) {
1974          this.waitingReads.push({
1975            lng,
1976            ns,
1977            fcName,
1978            tried,
1979            wait,
1980            callback
1981          });
1982          return;
1983        }
1984        this.readingCalls++;
1985        const resolver = (err, data) => {
1986          this.readingCalls--;
1987          if (this.waitingReads.length > 0) {
1988            const next2 = this.waitingReads.shift();
1989            this.read(next2.lng, next2.ns, next2.fcName, next2.tried, next2.wait, next2.callback);
1990          }
1991          if (err && data && tried < this.maxRetries) {
1992            setTimeout(() => {
1993              this.read.call(this, lng, ns, fcName, tried + 1, wait * 2, callback);
1994            }, wait);
1995            return;
1996          }
1997          callback(err, data);
1998        };
1999        const fc = this.backend[fcName].bind(this.backend);
2000        if (fc.length === 2) {
2001          try {
2002            const r2 = fc(lng, ns);
2003            if (r2 && typeof r2.then === "function") {
2004              r2.then((data) => resolver(null, data)).catch(resolver);
2005            } else {
2006              resolver(null, r2);
2007            }
2008          } catch (err) {
2009            resolver(err);
2010          }
2011          return;
2012        }
2013        return fc(lng, ns, resolver);
2014      }
2015      prepareLoading(languages, namespaces, options2 = {}, callback) {
2016        if (!this.backend) {
2017          this.logger.warn("No backend was added via i18next.use. Will not load resources.");
2018          return callback && callback();
2019        }

2020        if (isString$4(languages)) languages = this.languageUtils.toResolveHierarchy(languages);
2021        if (isString$4(namespaces)) namespaces = [namespaces];
2022        const toLoad = this.queueLoad(languages, namespaces, options2, callback);
2023        if (!toLoad.toLoad.length) {
2024          if (!toLoad.pending.length) callback();
2025          return null;
2026        }
2027        toLoad.toLoad.forEach((name) => {
2028          this.loadOne(name);
2029        });
2030      }
2031      load(languages, namespaces, callback) {
2032        this.prepareLoading(languages, namespaces, {}, callback);
2033      }
2034      reload(languages, namespaces, callback) {
2035        this.prepareLoading(languages, namespaces, {
2036          reload: true
2037        }, callback);
2038      }
2039      loadOne(name, prefix2 = "") {
2040        const s2 = name.split("|");
2041        const lng = s2[0];
2042        const ns = s2[1];
2043        this.read(lng, ns, "read", void 0, void 0, (err, data) => {
2044          if (err) this.logger.warn(`${prefix2}loading namespace ${ns} for language ${lng} failed`, err);
2045          if (!err && data) this.logger.log(`${prefix2}loaded namespace ${ns} for language ${lng}`, data);
2046          this.loaded(name, err, data);
2047        });
2048      }
2049      saveMissing(languages, namespace, key, fallbackValue, isUpdate, options2 = {}, clb = () => {
2050      }) {
2051        var _a, _b, _c, _d, _e2;
2052        if (((_b = (_a = this.services) == null ? void 0 : _a.utils) == null ? void 0 : _b.hasLoadedNamespace) && !((_d = (_c = this.services) == null ? void 0 : _c.utils) == null ? void 0 : _d.hasLoadedNamespace(namespace))) {
2053          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!!!");
2054          return;
2055        }
2056        if (key === void 0 || key === null || key === "") return;
2057        if ((_e2 = this.backend) == null ? void 0 : _e2.create) {
2058          const opts = __spreadProps(__spreadValues({}, options2), {
2059            isUpdate
2060          });
2061          const fc = this.backend.create.bind(this.backend);
2062          if (fc.length < 6) {
2063            try {
2064              let r2;
2065              if (fc.length === 5) {
2066                r2 = fc(languages, namespace, key, fallbackValue, opts);
2067              } else {
2068                r2 = fc(languages, namespace, key, fallbackValue);
2069              }
2070              if (r2 && typeof r2.then === "function") {
2071                r2.then((data) => clb(null, data)).catch(clb);
2072              } else {
2073                clb(null, r2);
2074              }
2075            } catch (err) {
2076              clb(err);
2077            }
2078          } else {
2079            fc(languages, namespace, key, fallbackValue, clb, opts);
2080          }
2081        }
2082        if (!languages || !languages[0]) return;
2083        this.store.addResource(languages[0], namespace, key, fallbackValue);
2084      }
2085    }
2086    const get$1 = () => ({
2087      debug: false,
2088      initAsync: true,
2089      ns: ["translation"],
2090      defaultNS: ["translation"],
2091      fallbackLng: ["dev"],
2092      fallbackNS: false,
2093      supportedLngs: false,
2094      nonExplicitSupportedLngs: false,
2095      load: "all",
2096      preload: false,
2097      simplifyPluralSuffix: true,
2098      keySeparator: ".",
2099      nsSeparator: ":",
2100      pluralSeparator: "_",
2101      contextSeparator: "_",
2102      partialBundledLanguages: false,
2103      saveMissing: false,
2104      updateMissing: false,
2105      saveMissingTo: "fallback",
2106      saveMissingPlurals: true,
2107      missingKeyHandler: false,
2108      missingInterpolationHandler: false,
2109      postProcess: false,
2110      postProcessPassResolved: false,
2111      returnNull: false,
2112      returnEmptyString: true,
2113      returnObjects: false,
2114      joinArrays: false,
2115      returnedObjectHandler: false,
2116      parseMissingKeyHandler: false,
2117      appendNamespaceToMissingKey: false,
2118      appendNamespaceToCIMode: false,
2119      overloadTranslationOptionHandler: (args) => {
2120        let ret = {};
2121        if (typeof args[1] === "object") ret = args[1];
2122        if (isString$4(args[1])) ret.defaultValue = args[1];
2123        if (isString$4(args[2])) ret.tDescription = args[2];
2124        if (typeof args[2] === "object" || typeof args[3] === "object") {
2125          const options2 = args[3] || args[2];
2126          Object.keys(options2).forEach((key) => {
2127            ret[key] = options2[key];
2128          });
2129        }
2130        return ret;
2131      },
2132      interpolation: {
2133        escapeValue: true,
2134        format: (value) => value,
2135        prefix: "{{",
2136        suffix: "}}",
2137        formatSeparator: ",",
2138        unescapePrefix: "-",
2139        nestingPrefix: "$t(",
2140        nestingSuffix: ")",
2141        nestingOptionsSeparator: ",",
2142        maxReplaces: 1e3,
2143        skipOnVariables: true
2144      },
2145      cacheInBuiltFormats: true
2146    });
2147    const transformOptions = (options2) => {
2148      var _a, _b;
2149      if (isString$4(options2.ns)) options2.ns = [options2.ns];
2150      if (isString$4(options2.fallbackLng)) options2.fallbackLng = [options2.fallbackLng];
2151      if (isString$4(options2.fallbackNS)) options2.fallbackNS = [options2.fallbackNS];
2152      if (((_b = (_a = options2.supportedLngs) == null ? void 0 : _a.indexOf) == null ? void 0 : _b.call(_a, "cimode")) < 0) {
2153        options2.supportedLngs = options2.supportedLngs.concat(["cimode"]);
2154      }
2155      if (typeof options2.initImmediate === "boolean") options2.initAsync = options2.initImmediate;
2156      return options2;
2157    };
2158    const noop$8 = () => {
2159    };
2160    const bindMemberFunctions = (inst) => {
2161      const mems = Object.getOwnPropertyNames(Object.getPrototypeOf(inst));

2162      mems.forEach((mem) => {
2163        if (typeof inst[mem] === "function") {
2164          inst[mem] = inst[mem].bind(inst);
2165        }
2166      });
2167    };
2168    class I18n extends EventEmitter {
2169      constructor(options2 = {}, callback) {
2170        super();
2171        this.options = transformOptions(options2);
2172        this.services = {};
2173        this.logger = baseLogger;
2174        this.modules = {
2175          external: []
2176        };
2177        bindMemberFunctions(this);
2178        if (callback && !this.isInitialized && !options2.isClone) {
2179          if (!this.options.initAsync) {
2180            this.init(options2, callback);
2181            return this;
2182          }
2183          setTimeout(() => {
2184            this.init(options2, callback);
2185          }, 0);
2186        }
2187      }
2188      init(options2 = {}, callback) {
2189        this.isInitializing = true;
2190        if (typeof options2 === "function") {
2191          callback = options2;
2192          options2 = {};
2193        }
2194        if (options2.defaultNS == null && options2.ns) {
2195          if (isString$4(options2.ns)) {
2196            options2.defaultNS = options2.ns;
2197          } else if (options2.ns.indexOf("translation") < 0) {
2198            options2.defaultNS = options2.ns[0];
2199          }
2200        }
2201        const defOpts = get$1();
2202        this.options = __spreadValues(__spreadValues(__spreadValues({}, defOpts), this.options), transformOptions(options2));
2203        this.options.interpolation = __spreadValues(__spreadValues({}, defOpts.interpolation), this.options.interpolation);
2204        if (options2.keySeparator !== void 0) {
2205          this.options.userDefinedKeySeparator = options2.keySeparator;
2206        }
2207        if (options2.nsSeparator !== void 0) {
2208          this.options.userDefinedNsSeparator = options2.nsSeparator;
2209        }
2210        if (typeof this.options.overloadTranslationOptionHandler !== "function") {
2211          this.options.overloadTranslationOptionHandler = defOpts.overloadTranslationOptionHandler;
2212        }
2213        const createClassOnDemand = (ClassOrObject) => {
2214          if (!ClassOrObject) return null;
2215          if (typeof ClassOrObject === "function") return new ClassOrObject();
2216          return ClassOrObject;
2217        };
2218        if (!this.options.isClone) {
2219          if (this.modules.logger) {
2220            baseLogger.init(createClassOnDemand(this.modules.logger), this.options);
2221          } else {
2222            baseLogger.init(null, this.options);
2223          }
2224          let formatter;
2225          if (this.modules.formatter) {
2226            formatter = this.modules.formatter;
2227          } else {
2228            formatter = Formatter;
2229          }
2230          const lu = new LanguageUtil(this.options);
2231          this.store = new ResourceStore(this.options.resources, this.options);
2232          const s2 = this.services;
2233          s2.logger = baseLogger;
2234          s2.resourceStore = this.store;
2235          s2.languageUtils = lu;
2236          s2.pluralResolver = new PluralResolver(lu, {
2237            prepend: this.options.pluralSeparator,
2238            simplifyPluralSuffix: this.options.simplifyPluralSuffix
2239          });
2240          const usingLegacyFormatFunction = this.options.interpolation.format && this.options.interpolation.format !== defOpts.interpolation.format;
2241          if (usingLegacyFormatFunction) {
2242            this.logger.deprecate(`init: you are still using the legacy format function, please use the new approach: https://www.i18next.com/translation-function/formatting`);
2243          }
2244          if (formatter && (!this.options.interpolation.format || this.options.interpolation.format === defOpts.interpolation.format)) {
2245            s2.formatter = createClassOnDemand(formatter);
2246            if (s2.formatter.init) s2.formatter.init(s2, this.options);
2247            this.options.interpolation.format = s2.formatter.format.bind(s2.formatter);
2248          }
2249          s2.interpolator = new Interpolator(this.options);
2250          s2.utils = {
2251            hasLoadedNamespace: this.hasLoadedNamespace.bind(this)
2252          };
2253          s2.backendConnector = new Connector(createClassOnDemand(this.modules.backend), s2.resourceStore, s2, this.options);
2254          s2.backendConnector.on("*", (event, ...args) => {

2255            this.emit(event, ...args);
2256          });
2257          if (this.modules.languageDetector) {
2258            s2.languageDetector = createClassOnDemand(this.modules.languageDetector);
2259            if (s2.languageDetector.init) s2.languageDetector.init(s2, this.options.detection, this.options);
2260          }
2261          if (this.modules.i18nFormat) {
2262            s2.i18nFormat = createClassOnDemand(this.modules.i18nFormat);
2263            if (s2.i18nFormat.init) s2.i18nFormat.init(this);
2264          }
2265          this.translator = new Translator(this.services, this.options);
2266          this.translator.on("*", (event, ...args) => {
2267            this.emit(event, ...args);
2268          });
2269          this.modules.external.forEach((m2) => {
2270            if (m2.init) m2.init(this);
2271          });
2272        }
2273        this.format = this.options.interpolation.format;
2274        if (!callback) callback = noop$8;
2275        if (this.options.fallbackLng && !this.services.languageDetector && !this.options.lng) {
2276          const codes = this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);
2277          if (codes.length > 0 && codes[0] !== "dev") this.options.lng = codes[0];
2278        }
2279        if (!this.services.languageDetector && !this.options.lng) {
2280          this.logger.warn("init: no languageDetector is used and no lng is defined");
2281        }
2282        const storeApi = ["getResource", "hasResourceBundle", "getResourceBundle", "getDataByLanguage"];
2283        storeApi.forEach((fcName) => {
2284          this[fcName] = (...args) => this.store[fcName](...args);
2285        });
2286        const storeApiChained = ["addResource", "addResources", "addResourceBundle", "removeResourceBundle"];
2287        storeApiChained.forEach((fcName) => {
2288          this[fcName] = (...args) => {
2289            this.store[fcName](...args);
2290            return this;
2291          };
2292        });
2293        const deferred = defer();
2294        const load = () => {
2295          const finish = (err, t2) => {
2296            this.isInitializing = false;
2297            if (this.isInitialized && !this.initializedStoreOnce) this.logger.warn("init: i18next is already initialized. You should call init just once!");
2298            this.isInitialized = true;
2299            if (!this.options.isClone) this.logger.log("initialized", this.options);
2300            this.emit("initialized", this.options);
2301            deferred.resolve(t2);
2302            callback(err, t2);
2303          };
2304          if (this.languages && !this.isInitialized) return finish(null, this.t.bind(this));
2305          this.changeLanguage(this.options.lng, finish);
2306        };
2307        if (this.options.resources || !this.options.initAsync) {
2308          load();
2309        } else {
2310          setTimeout(load, 0);
2311        }
2312        return deferred;
2313      }
2314      loadResources(language, callback = noop$8) {
2315        var _a, _b;
2316        let usedCallback = callback;
2317        const usedLng = isString$4(language) ? language : this.language;
2318        if (typeof language === "function") usedCallback = language;
2319        if (!this.options.resources || this.options.partialBundledLanguages) {
2320          if ((usedLng == null ? void 0 : usedLng.toLowerCase()) === "cimode" && (!this.options.preload || this.options.preload.length === 0)) return usedCallback();
2321          const toLoad = [];
2322          const append2 = (lng) => {
2323            if (!lng) return;
2324            if (lng === "cimode") return;
2325            const lngs = this.services.languageUtils.toResolveHierarchy(lng);
2326            lngs.forEach((l2) => {
2327              if (l2 === "cimode") return;
2328              if (toLoad.indexOf(l2) < 0) toLoad.push(l2);
2329            });
2330          };
2331          if (!usedLng) {
2332            const fallbacks = this.services.languageUtils.getFallbackCodes(this.options.fallbackLng);
2333            fallbacks.forEach((l2) => append2(l2));
2334          } else {
2335            append2(usedLng);
2336          }
2337          (_b = (_a = this.options.preload) == null ? void 0 : _a.forEach) == null ? void 0 : _b.call(_a, (l2) => append2(l2));
2338          this.services.backendConnector.load(toLoad, this.options.ns, (e2) => {
2339            if (!e2 && !this.resolvedLanguage && this.language) this.setResolvedLanguage(this.language);
2340            usedCallback(e2);
2341          });
2342        } else {
2343          usedCallback(null);
2344        }
2345      }
2346      reloadResources(lngs, ns, callback) {
2347        const deferred = defer();
2348        if (typeof lngs === "function") {
2349          callback = lngs;
2350          lngs = void 0;
2351        }
2352        if (typeof ns === "function") {
2353          callback = ns;
2354          ns = void 0;
2355        }
2356        if (!lngs) lngs = this.languages;
2357        if (!ns) ns = this.options.ns;
2358        if (!callback) callback = noop$8;
2359        this.services.backendConnector.reload(lngs, ns, (err) => {
2360          deferred.resolve();
2361          callback(err);
2362        });
2363        return deferred;
2364      }
2365      use(module2) {
2366        if (!module2) throw new Error("You are passing an undefined module! Please check the object you are passing to i18next.use()");
2367        if (!module2.type) throw new Error("You are passing a wrong module! Please check the object you are passing to i18next.use()");
2368        if (module2.type === "backend") {
2369          this.modules.backend = module2;
2370        }
2371        if (module2.type === "logger" || module2.log && module2.warn && module2.error) {
2372          this.modules.logger = module2;
2373        }
2374        if (module2.type === "languageDetector") {
2375          this.modules.languageDetector = module2;
2376        }
2377        if (module2.type === "i18nFormat") {
2378          this.modules.i18nFormat = module2;
2379        }
2380        if (module2.type === "postProcessor") {
2381          postProcessor.addPostProcessor(module2);
2382        }
2383        if (module2.type === "formatter") {
2384          this.modules.formatter = module2;
2385        }
2386        if (module2.type === "3rdParty") {
2387          this.modules.external.push(module2);
2388        }
2389        return this;
2390      }
2391      setResolvedLanguage(l2) {
2392        if (!l2 || !this.languages) return;
2393        if (["cimode", "dev"].indexOf(l2) > -1) return;
2394        for (let li2 = 0; li2 < this.languages.length; li2++) {
2395          const lngInLngs = this.languages[li2];
2396          if (["cimode", "dev"].indexOf(lngInLngs) > -1) continue;
2397          if (this.store.hasLanguageSomeTranslations(lngInLngs)) {
2398            this.resolvedLanguage = lngInLngs;
2399            break;
2400          }
2401        }
2402        if (!this.resolvedLanguage && this.languages.indexOf(l2) < 0 && this.store.hasLanguageSomeTranslations(l2)) {
2403          this.resolvedLanguage = l2;
2404          this.languages.unshift(l2);
2405        }
2406      }
2407      changeLanguage(lng, callback) {
2408        this.isLanguageChangingTo = lng;
2409        const deferred = defer();

2410        this.emit("languageChanging", lng);
2411        const setLngProps = (l2) => {
2412          this.language = l2;
2413          this.languages = this.services.languageUtils.toResolveHierarchy(l2);
2414          this.resolvedLanguage = void 0;
2415          this.setResolvedLanguage(l2);
2416        };
2417        const done = (err, l2) => {
2418          if (l2) {
2419            if (this.isLanguageChangingTo === lng) {
2420              setLngProps(l2);
2421              this.translator.changeLanguage(l2);
2422              this.isLanguageChangingTo = void 0;
2423              this.emit("languageChanged", l2);
2424              this.logger.log("languageChanged", l2);
2425            }
2426          } else {
2427            this.isLanguageChangingTo = void 0;
2428          }
2429          deferred.resolve((...args) => this.t(...args));
2430          if (callback) callback(err, (...args) => this.t(...args));
2431        };
2432        const setLng = (lngs) => {
2433          var _a, _b;
2434          if (!lng && !lngs && this.services.languageDetector) lngs = [];
2435          const fl = isString$4(lngs) ? lngs : lngs && lngs[0];
2436          const l2 = this.store.hasLanguageSomeTranslations(fl) ? fl : this.services.languageUtils.getBestMatchFromCodes(isString$4(lngs) ? [lngs] : lngs);
2437          if (l2) {
2438            if (!this.language) {
2439              setLngProps(l2);
2440            }
2441            if (!this.translator.language) this.translator.changeLanguage(l2);
2442            (_b = (_a = this.services.languageDetector) == null ? void 0 : _a.cacheUserLanguage) == null ? void 0 : _b.call(_a, l2);
2443          }
2444          this.loadResources(l2, (err) => {
2445            done(err, l2);
2446          });
2447        };
2448        if (!lng && this.services.languageDetector && !this.services.languageDetector.async) {
2449          setLng(this.services.languageDetector.detect());
2450        } else if (!lng && this.services.languageDetector && this.services.languageDetector.async) {
2451          if (this.services.languageDetector.detect.length === 0) {
2452            this.services.languageDetector.detect().then(setLng);
2453          } else {
2454            this.services.languageDetector.detect(setLng);
2455          }
2456        } else {
2457          setLng(lng);
2458        }
2459        return deferred;
2460      }
2461      getFixedT(lng, ns, keyPrefix) {
2462        const fixedT = (key, opts, ...rest) => {
2463          let o2;
2464          if (typeof opts !== "object") {
2465            o2 = this.options.overloadTranslationOptionHandler([key, opts].concat(rest));
2466          } else {
2467            o2 = __spreadValues({}, opts);
2468          }
2469          o2.lng = o2.lng || fixedT.lng;
2470          o2.lngs = o2.lngs || fixedT.lngs;
2471          o2.ns = o2.ns || fixedT.ns;
2472          if (o2.keyPrefix !== "") o2.keyPrefix = o2.keyPrefix || keyPrefix || fixedT.keyPrefix;
2473          const keySeparator = this.options.keySeparator || ".";
2474          let resultKey;
2475          if (o2.keyPrefix && Array.isArray(key)) {
2476            resultKey = key.map((k2) => {
2477              if (typeof k2 === "function") k2 = keysFromSelector(k2, __spreadValues(__spreadValues({}, this.options), opts));
2478              return `${o2.keyPrefix}${keySeparator}${k2}`;
2479            });
2480          } else {
2481            if (typeof key === "function") key = keysFromSelector(key, __spreadValues(__spreadValues({}, this.options), opts));
2482            resultKey = o2.keyPrefix ? `${o2.keyPrefix}${keySeparator}${key}` : key;
2483          }
2484          return this.t(resultKey, o2);
2485        };
2486        if (isString$4(lng)) {
2487          fixedT.lng = lng;
2488        } else {
2489          fixedT.lngs = lng;
2490        }
2491        fixedT.ns = ns;
2492        fixedT.keyPrefix = keyPrefix;
2493        return fixedT;
2494      }
2495      t(...args) {
2496        var _a;
2497        return (_a = this.translator) == null ? void 0 : _a.translate(...args);
2498      }
2499      exists(...args) {
2500        var _a;
2501        return (_a = this.translator) == null ? void 0 : _a.exists(...args);
2502      }
2503      setDefaultNamespace(ns) {
2504        this.options.defaultNS = ns;
2505      }
2506      hasLoadedNamespace(ns, options2 = {}) {
2507        if (!this.isInitialized) {
2508          this.logger.warn("hasLoadedNamespace: i18next was not initialized", this.languages);
2509          return false;

2510        }
2511        if (!this.languages || !this.languages.length) {
2512          this.logger.warn("hasLoadedNamespace: i18n.languages were undefined or empty", this.languages);
2513          return false;
2514        }
2515        const lng = options2.lng || this.resolvedLanguage || this.languages[0];
2516        const fallbackLng = this.options ? this.options.fallbackLng : false;
2517        const lastLng = this.languages[this.languages.length - 1];
2518        if (lng.toLowerCase() === "cimode") return true;
2519        const loadNotPending = (l2, n2) => {
2520          const loadState = this.services.backendConnector.state[`${l2}|${n2}`];
2521          return loadState === -1 || loadState === 0 || loadState === 2;
2522        };
2523        if (options2.precheck) {
2524          const preResult = options2.precheck(this, loadNotPending);
2525          if (preResult !== void 0) return preResult;
2526        }
2527        if (this.hasResourceBundle(lng, ns)) return true;
2528        if (!this.services.backendConnector.backend || this.options.resources && !this.options.partialBundledLanguages) return true;
2529        if (loadNotPending(lng, ns) && (!fallbackLng || loadNotPending(lastLng, ns))) return true;
2530        return false;
2531      }
2532      loadNamespaces(ns, callback) {
2533        const deferred = defer();
2534        if (!this.options.ns) {
2535          if (callback) callback();
2536          return Promise.resolve();
2537        }
2538        if (isString$4(ns)) ns = [ns];
2539        ns.forEach((n2) => {
2540          if (this.options.ns.indexOf(n2) < 0) this.options.ns.push(n2);
2541        });
2542        this.loadResources((err) => {
2543          deferred.resolve();
2544          if (callback) callback(err);
2545        });
2546        return deferred;
2547      }
2548      loadLanguages(lngs, callback) {
2549        const deferred = defer();
2550        if (isString$4(lngs)) lngs = [lngs];
2551        const preloaded = this.options.preload || [];
2552        const newLngs = lngs.filter((lng) => preloaded.indexOf(lng) < 0 && this.services.languageUtils.isSupportedCode(lng));
2553        if (!newLngs.length) {
2554          if (callback) callback();
2555          return Promise.resolve();
2556        }
2557        this.options.preload = preloaded.concat(newLngs);
2558        this.loadResources((err) => {
2559          deferred.resolve();
2560          if (callback) callback(err);
2561        });
2562        return deferred;
2563      }
2564      dir(lng) {
2565        var _a, _b;
2566        if (!lng) lng = this.resolvedLanguage || (((_a = this.languages) == null ? void 0 : _a.length) > 0 ? this.languages[0] : this.language);
2567        if (!lng) return "rtl";
2568        try {
2569          const l2 = new Intl.Locale(lng);
2570          if (l2 && l2.getTextInfo) {
2571            const ti2 = l2.getTextInfo();
2572            if (ti2 && ti2.direction) return ti2.direction;
2573          }
2574        } catch (e2) {
2575        }
2576        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", "yds", "yih", "ji", "yi", "hbo", "men", "xmn", "fa", "jpr", "peo", "pes", "prs", "dv", "sam", "ckb"];
2577        const languageUtils = ((_b = this.services) == null ? void 0 : _b.languageUtils) || new LanguageUtil(get$1());
2578        if (lng.toLowerCase().indexOf("-latn") > 1) return "ltr";
2579        return rtlLngs.indexOf(languageUtils.getLanguagePartFromCode(lng)) > -1 || lng.toLowerCase().indexOf("-arab") > 1 ? "rtl" : "ltr";
2580      }
2581      static createInstance(options2 = {}, callback) {
2582        const instance2 = new I18n(options2, callback);
2583        instance2.createInstance = I18n.createInstance;
2584        return instance2;
2585      }
2586      cloneInstance(options2 = {}, callback = noop$8) {
2587        const forkResourceStore = options2.forkResourceStore;
2588        if (forkResourceStore) delete options2.forkResourceStore;
2589        const mergedOptions = __spreadValues(__spreadValues(__spreadValues({}, this.options), options2), {
2590          isClone: true
2591        });
2592        const clone2 = new I18n(mergedOptions);
2593        if (options2.debug !== void 0 || options2.prefix !== void 0) {
2594          clone2.logger = clone2.logger.clone(options2);
2595        }
2596        const membersToCopy = ["store", "services", "language"];
2597        membersToCopy.forEach((m2) => {
2598          clone2[m2] = this[m2];
2599        });
2600        clone2.services = __spreadValues({}, this.services);
2601        clone2.services.utils = {
2602          hasLoadedNamespace: clone2.hasLoadedNamespace.bind(clone2)
2603        };
2604        if (forkResourceStore) {
2605          const clonedData = Object.keys(this.store.data).reduce((prev2, l2) => {
2606            prev2[l2] = __spreadValues({}, this.store.data[l2]);
2607            prev2[l2] = Object.keys(prev2[l2]).reduce((acc, n2) => {
2608              acc[n2] = __spreadValues({}, prev2[l2][n2]);
2609              return acc;
2610            }, prev2[l2]);
2611            return prev2;
2612          }, {});
2613          clone2.store = new ResourceStore(clonedData, mergedOptions);
2614          clone2.services.resourceStore = clone2.store;
2615        }
2616        if (options2.interpolation) clone2.services.interpolator = new Interpolator(mergedOptions);
2617        clone2.translator = new Translator(clone2.services, mergedOptions);
2618        clone2.translator.on("*", (event, ...args) => {
2619          clone2.emit(event, ...args);
2620        });
2621        clone2.init(mergedOptions, callback);
2622        clone2.translator.options = mergedOptions;
2623        clone2.translator.backendConnector.services.utils = {
2624          hasLoadedNamespace: clone2.hasLoadedNamespace.bind(clone2)
2625        };
2626        return clone2;
2627      }
2628      toJSON() {
2629        return {
2630          options: this.options,
2631          store: this.store,
2632          language: this.language,
2633          languages: this.languages,
2634          resolvedLanguage: this.resolvedLanguage
2635        };
2636      }
2637    }
2638    const instance = I18n.createInstance();
2639    instance.createInstance;
2640    instance.dir;
2641    instance.init;
2642    instance.loadResources;
2643    instance.reloadResources;
2644    instance.use;
2645    instance.changeLanguage;
2646    instance.getFixedT;
2647    instance.t;
2648    instance.exists;
2649    instance.setDefaultNamespace;
2650    instance.hasLoadedNamespace;
2651    instance.loadNamespaces;
2652    instance.loadLanguages;
2653    var reactExports = requireReact();
2654    const e$3 = /* @__PURE__ */ getDefaultExportFromCjs(reactExports);
2655    const React = /* @__PURE__ */ _mergeNamespaces({
2656      __proto__: null,
2657      default: e$3
2658    }, [reactExports]);
2659    var voidElements;
2660    var hasRequiredVoidElements;
2661    function requireVoidElements() {
2662      if (hasRequiredVoidElements) return voidElements;
2663      hasRequiredVoidElements = 1;
2664      voidElements = {
2665        "area": true,
2666        "base": true,
2667        "br": true,
2668        "col": true,
2669        "embed": true,
2670        "hr": true,
2671        "img": true,
2672        "input": true,
2673        "link": true,
2674        "meta": true,
2675        "param": true,
2676        "source": true,
2677        "track": true,
2678        "wbr": true
2679      };
2680      return voidElements;
2681    }
2682    var voidElementsExports = requireVoidElements();
2683    const e$2 = /* @__PURE__ */ getDefaultExportFromCjs(voidElementsExports);
2684    var t$2 = /\s([^'"/\s><]+?)[\s/>]|([^\s=]+)=\s?(".*?"|'.*?')/g;
2685    function n$2(n2) {
2686      var r2 = { type: "tag", name: "", voidElement: false, attrs: {}, children: [] }, i2 = n2.match(/<\/?([^\s]+?)[/\s>]/);
2687      if (i2 && (r2.name = i2[1], (e$2[i2[1]] || "/" === n2.charAt(n2.length - 2)) && (r2.voidElement = true), r2.name.startsWith("!--"))) {
2688        var s2 = n2.indexOf("-->");
2689        return { type: "comment", comment: -1 !== s2 ? n2.slice(4, s2) : "" };
2690      }
2691      for (var a2 = new RegExp(t$2), c2 = null; null !== (c2 = a2.exec(n2)); ) if (c2[0].trim()) if (c2[1]) {
2692        var o2 = c2[1].trim(), l2 = [o2, ""];
2693        o2.indexOf("=") > -1 && (l2 = o2.split("=")), r2.attrs[l2[0]] = l2[1], a2.lastIndex--;
2694      } else c2[2] && (r2.attrs[c2[2]] = c2[3].trim().substring(1, c2[3].length - 1));
2695      return r2;
2696    }
2697    var r$2 = /<[a-zA-Z0-9\-\!\/](?:"[^"]*"|'[^']*'|[^'">])*>/g, i$1 = /^\s*$/, s$6 = /* @__PURE__ */ Object.create(null);
2698    function a$1(e2, t2) {
2699      switch (t2.type) {
2700        case "text":
2701          return e2 + t2.content;
2702        case "tag":
2703          return e2 += "<" + t2.name + (t2.attrs ? (function(e3) {
2704            var t3 = [];
2705            for (var n2 in e3) t3.push(n2 + '="' + e3[n2] + '"');
2706            return t3.length ? " " + t3.join(" ") : "";
2707          })(t2.attrs) : "") + (t2.voidElement ? "/>" : ">"), t2.voidElement ? e2 : e2 + t2.children.reduce(a$1, "") + "</" + t2.name + ">";
2708        case "comment":
2709          return e2 + "<!--" + t2.comment + "-->";
2710      }
2711    }
2712    var c$5 = { parse: function(e2, t2) {
2713      t2 || (t2 = {}), t2.components || (t2.components = s$6);
2714      var a2, c2 = [], o2 = [], l2 = -1, m2 = false;