https://thebullyvard.com/contact/assets/index-DIe8mhyr.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-DIe8mhyr.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] = "1194f582-8209-4e1f-a426-3bef5e345d94", e2._sentryDebugIdIdentifier = "sentry-dbid-1194f582-8209-4e1f-a426-3bef5e345d94");
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_OMNI_URL: void 0
175      };
176    }
177    function getDefaultExportFromCjs(x2) {
178      return x2 && x2.__esModule && Object.prototype.hasOwnProperty.call(x2, "default") ? x2["default"] : x2;
179    }
180    function getAugmentedNamespace(n2) {
181      if (Object.prototype.hasOwnProperty.call(n2, "__esModule")) return n2;
182      var f2 = n2.default;
183      if (typeof f2 == "function") {
184        var a2 = function a3() {
185          var isInstance = false;
186          try {
187            isInstance = this instanceof a3;
188          } catch (e2) {
189          }
190          if (isInstance) {
191            return Reflect.construct(f2, arguments, this.constructor);
192          }
193          return f2.apply(this, arguments);
194        };
195        a2.prototype = f2.prototype;
196      } else a2 = {};
197      Object.defineProperty(a2, "__esModule", { value: true });
198      Object.keys(n2).forEach(function(k2) {
199        var d2 = Object.getOwnPropertyDescriptor(n2, k2);
200        Object.defineProperty(a2, k2, d2.get ? d2 : {
201          enumerable: true,
202          get: function() {
203            return n2[k2];
204          }
205        });
206      });
207      return a2;
208    }
209    var jsxRuntime = { exports: {} };
210    var reactJsxRuntime_production_min = {};
211    var react = { exports: {} };
212    var react_production_min = {};
213    /**
214     * @license React
215     * react.production.min.js
216     *
217     * Copyright (c) Facebook, Inc. and its affiliates.
218     *
219     * This source code is licensed under the MIT license found in the
220     * LICENSE file in the root directory of this source tree.
221     */
222    var hasRequiredReact_production_min;
223    function requireReact_production_min() {
224      if (hasRequiredReact_production_min) return react_production_min;
225      hasRequiredReact_production_min = 1;
226      var l2 = Symbol.for("react.element"), n2 = Symbol.for("react.portal"), p2 = 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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