@modern-js/plugin-i18n 2.69.7 → 3.0.0-alpha.1

package/dist/cjs/runtime/i18n/backend/defaults.node.cjs

@@ -0,0 +1,56 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    DEFAULT_I18NEXT_BACKEND_OPTIONS: ()=>DEFAULT_I18NEXT_BACKEND_OPTIONS,
+    convertBackendOptions: ()=>convertBackendOptions
+});
+const DEFAULT_I18NEXT_BACKEND_OPTIONS = {
+    loadPath: './locales/{{lng}}/{{ns}}.json',
+    addPath: './locales/{{lng}}/{{ns}}.json'
+};
+function convertPath(path) {
+    if (!path) return path;
+    if (path.startsWith('/')) return `.${path}`;
+    return path;
+}
+function convertBackendOptions(options) {
+    if (!options) return options;
+    const converted = {
+        ...options
+    };
+    if (converted.loadPath) converted.loadPath = convertPath(converted.loadPath);
+    if (converted.addPath) converted.addPath = convertPath(converted.addPath);
+    return converted;
+}
+exports.DEFAULT_I18NEXT_BACKEND_OPTIONS = __webpack_exports__.DEFAULT_I18NEXT_BACKEND_OPTIONS;
+exports.convertBackendOptions = __webpack_exports__.convertBackendOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_I18NEXT_BACKEND_OPTIONS",
+    "convertBackendOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/i18n/backend/index.cjs

@@ -0,0 +1,108 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    mergeBackendOptions: ()=>mergeBackendOptions
+});
+const external_config_cjs_namespaceObject = require("./config.cjs");
+const external_defaults_cjs_namespaceObject = require("./defaults.cjs");
+function hasSdkFunction(backend, userInitOptions) {
+    return 'function' == typeof userInitOptions?.backend?.sdk || !!backend?.enabled && !!backend?.sdk && 'function' == typeof backend.sdk;
+}
+function hasLoadPath(backend, userInitOptions) {
+    const userLoadPath = userInitOptions?.backend?.loadPath ?? backend?.loadPath;
+    const isExplicit = !!userLoadPath && '' !== userLoadPath;
+    const hasPath = isExplicit || !!backend?.enabled && void 0 === userLoadPath;
+    return {
+        hasPath,
+        isExplicit
+    };
+}
+function ensureDefaultLoadPath(merged, backend, isExplicitLoadPath = false) {
+    if (backend?.enabled && !isExplicitLoadPath && !merged.loadPath) {
+        merged.loadPath = external_defaults_cjs_namespaceObject.DEFAULT_I18NEXT_BACKEND_OPTIONS.loadPath;
+        merged.addPath = external_defaults_cjs_namespaceObject.DEFAULT_I18NEXT_BACKEND_OPTIONS.addPath;
+    }
+}
+function getFinalLoadPath(mergedOptions, backend, userInitOptions) {
+    return mergedOptions?.loadPath || userInitOptions?.backend?.loadPath || (backend?.enabled ? external_defaults_cjs_namespaceObject.DEFAULT_I18NEXT_BACKEND_OPTIONS.loadPath : void 0);
+}
+function getFinalSdk(mergedOptions, backend, userInitOptions) {
+    return mergedOptions?.sdk || userInitOptions?.backend?.sdk || (backend?.sdk && 'function' == typeof backend.sdk ? backend.sdk : void 0);
+}
+function buildChainedBackendConfig(backend, userInitOptions) {
+    const merged = (0, external_config_cjs_namespaceObject.mergeBackendOptions)(external_defaults_cjs_namespaceObject.DEFAULT_I18NEXT_BACKEND_OPTIONS, backend, userInitOptions?.backend);
+    const { isExplicit } = hasLoadPath(backend, userInitOptions);
+    ensureDefaultLoadPath(merged, backend, isExplicit);
+    const mergedOptions = (0, external_defaults_cjs_namespaceObject.convertBackendOptions)(merged);
+    const finalLoadPath = getFinalLoadPath(mergedOptions, backend, userInitOptions);
+    const finalSdk = getFinalSdk(mergedOptions, backend, userInitOptions);
+    const chainedBackendOptions = [
+        {
+            loadPath: finalLoadPath,
+            addPath: mergedOptions?.addPath || external_defaults_cjs_namespaceObject.DEFAULT_I18NEXT_BACKEND_OPTIONS.addPath
+        },
+        {
+            sdk: finalSdk
+        }
+    ];
+    return {
+        ...mergedOptions,
+        loadPath: finalLoadPath,
+        sdk: finalSdk,
+        cacheHitMode: mergedOptions?.cacheHitMode || backend?.cacheHitMode || userInitOptions?.backend?.cacheHitMode || 'refreshAndUpdateStore',
+        _useChainedBackend: true,
+        _chainedBackendConfig: {
+            backendOptions: chainedBackendOptions
+        }
+    };
+}
+function buildSdkOnlyBackendConfig(backend, userInitOptions) {
+    const merged = (0, external_config_cjs_namespaceObject.mergeBackendOptions)({}, backend, userInitOptions?.backend);
+    return (0, external_defaults_cjs_namespaceObject.convertBackendOptions)(merged) || {};
+}
+function buildHttpFsBackendConfig(backend, userInitOptions) {
+    if (!backend?.enabled && !userInitOptions?.backend) return;
+    const mergedBackend = backend?.enabled ? (0, external_config_cjs_namespaceObject.mergeBackendOptions)(external_defaults_cjs_namespaceObject.DEFAULT_I18NEXT_BACKEND_OPTIONS, backend, userInitOptions?.backend) : userInitOptions?.backend;
+    if (mergedBackend) {
+        const { isExplicit } = hasLoadPath(backend, userInitOptions);
+        ensureDefaultLoadPath(mergedBackend, backend, isExplicit);
+    }
+    return (0, external_defaults_cjs_namespaceObject.convertBackendOptions)(mergedBackend) || {};
+}
+const mergeBackendOptions = (backend, userInitOptions)=>{
+    const sdkFunction = hasSdkFunction(backend, userInitOptions);
+    const { hasPath } = hasLoadPath(backend, userInitOptions);
+    if (hasPath && sdkFunction) return buildChainedBackendConfig(backend, userInitOptions);
+    if (sdkFunction) return buildSdkOnlyBackendConfig(backend, userInitOptions);
+    return buildHttpFsBackendConfig(backend, userInitOptions);
+};
+exports.mergeBackendOptions = __webpack_exports__.mergeBackendOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "mergeBackendOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/i18n/backend/middleware.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    HttpBackendWithSave: ()=>HttpBackendWithSave,
+    useI18nextBackend: ()=>useI18nextBackend
+});
+const external_i18next_http_backend_namespaceObject = require("i18next-http-backend");
+var external_i18next_http_backend_default = /*#__PURE__*/ __webpack_require__.n(external_i18next_http_backend_namespaceObject);
+const external_middleware_common_cjs_namespaceObject = require("./middleware.common.cjs");
+class HttpBackendWithSave extends external_i18next_http_backend_default() {
+    save(_language, _namespace, _data) {}
+}
+const useI18nextBackend = (i18nInstance, backend)=>(0, external_middleware_common_cjs_namespaceObject.useI18nextBackendCommon)(i18nInstance, HttpBackendWithSave, external_i18next_http_backend_default(), backend);
+exports.HttpBackendWithSave = __webpack_exports__.HttpBackendWithSave;
+exports.useI18nextBackend = __webpack_exports__.useI18nextBackend;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "HttpBackendWithSave",
+    "useI18nextBackend"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/i18n/backend/middleware.common.cjs

@@ -0,0 +1,105 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useI18nextBackendCommon: ()=>useI18nextBackendCommon
+});
+const external_i18next_chained_backend_namespaceObject = require("i18next-chained-backend");
+var external_i18next_chained_backend_default = /*#__PURE__*/ __webpack_require__.n(external_i18next_chained_backend_namespaceObject);
+const external_instance_cjs_namespaceObject = require("../instance.cjs");
+const external_sdk_backend_cjs_namespaceObject = require("./sdk-backend.cjs");
+function checkBackendConfig(backend) {
+    const hasSdk = backend?.sdk && 'function' == typeof backend.sdk;
+    const hasLoadPath = !!backend?.loadPath;
+    const useChained = backend?._useChainedBackend;
+    return {
+        hasSdk,
+        hasLoadPath,
+        useChained
+    };
+}
+function buildChainedBackendConfig(backend, BackendWithSave) {
+    const cacheHitMode = backend.cacheHitMode || 'refreshAndUpdateStore';
+    if (backend._chainedBackendConfig) return {
+        backends: [
+            BackendWithSave,
+            external_sdk_backend_cjs_namespaceObject.SdkBackend
+        ],
+        backendOptions: backend._chainedBackendConfig.backendOptions,
+        cacheHitMode
+    };
+    return {
+        backends: [
+            BackendWithSave,
+            external_sdk_backend_cjs_namespaceObject.SdkBackend
+        ],
+        backendOptions: [
+            {
+                loadPath: backend.loadPath,
+                addPath: backend.addPath
+            },
+            {
+                sdk: backend.sdk
+            }
+        ],
+        cacheHitMode
+    };
+}
+function setupChainedBackend(i18nInstance, backend, BackendWithSave) {
+    i18nInstance.use(external_i18next_chained_backend_default());
+    const actualInstance = (0, external_instance_cjs_namespaceObject.getActualI18nextInstance)(i18nInstance);
+    if (actualInstance?.options) actualInstance.options.backend = buildChainedBackendConfig(backend, BackendWithSave);
+    if (i18nInstance.options) i18nInstance.options.backend = buildChainedBackendConfig(backend, BackendWithSave);
+}
+function cleanBackendConfig(backend) {
+    const { _useChainedBackend, _chainedBackendConfig, ...cleanBackend } = backend;
+    return cleanBackend;
+}
+function useI18nextBackendCommon(i18nInstance, BackendWithSave, BackendBase, backend) {
+    if (!backend) return i18nInstance.use(BackendBase);
+    const { hasSdk, hasLoadPath, useChained } = checkBackendConfig(backend);
+    if (useChained || hasLoadPath && hasSdk) return void setupChainedBackend(i18nInstance, backend, BackendWithSave);
+    if (hasSdk) return i18nInstance.use(external_sdk_backend_cjs_namespaceObject.SdkBackend);
+    const actualInstance = (0, external_instance_cjs_namespaceObject.getActualI18nextInstance)(i18nInstance);
+    if (actualInstance?.options) actualInstance.options.backend = cleanBackendConfig(backend);
+    if (i18nInstance.options) i18nInstance.options.backend = cleanBackendConfig(backend);
+    return i18nInstance.use(BackendBase);
+}
+exports.useI18nextBackendCommon = __webpack_exports__.useI18nextBackendCommon;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "useI18nextBackendCommon"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/i18n/backend/middleware.node.cjs

@@ -0,0 +1,58 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    HttpBackendWithSave: ()=>HttpBackendWithSave,
+    useI18nextBackend: ()=>useI18nextBackend,
+    FsBackendWithSave: ()=>FsBackendWithSave
+});
+const external_i18next_fs_backend_namespaceObject = require("i18next-fs-backend");
+var external_i18next_fs_backend_default = /*#__PURE__*/ __webpack_require__.n(external_i18next_fs_backend_namespaceObject);
+const external_middleware_common_cjs_namespaceObject = require("./middleware.common.cjs");
+class FsBackendWithSave extends external_i18next_fs_backend_default() {
+    save(_language, _namespace, _data) {}
+}
+const HttpBackendWithSave = FsBackendWithSave;
+const useI18nextBackend = (i18nInstance, backend)=>(0, external_middleware_common_cjs_namespaceObject.useI18nextBackendCommon)(i18nInstance, FsBackendWithSave, external_i18next_fs_backend_default(), backend);
+exports.FsBackendWithSave = __webpack_exports__.FsBackendWithSave;
+exports.HttpBackendWithSave = __webpack_exports__.HttpBackendWithSave;
+exports.useI18nextBackend = __webpack_exports__.useI18nextBackend;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "FsBackendWithSave",
+    "HttpBackendWithSave",
+    "useI18nextBackend"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/i18n/backend/sdk-backend.cjs

@@ -0,0 +1,171 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    SdkBackend: ()=>SdkBackend
+});
+class SdkBackend {
+    init(services, backendOptions, _i18nextOptions) {
+        this.services = services;
+        this.sdk = backendOptions?.sdk;
+        if (!this.sdk) throw new Error('SdkBackend requires an SDK function to be provided in backend options');
+    }
+    read(language, namespace, callback) {
+        if (!this.sdk) {
+            console.error('[i18n] SdkBackend.read - SDK function not initialized');
+            callback(new Error('SDK function not initialized'), null);
+            return;
+        }
+        const cached = this.allResourcesCache ? this.extractFromCache(language, namespace) : null;
+        if (null !== cached) {
+            const mergedData = this.mergeWithExistingResources(language, namespace, cached);
+            callback(null, mergedData);
+            return;
+        }
+        const cacheKey = this.getCacheKey(language, namespace);
+        const existingPromise = this.loadingPromises.get(cacheKey);
+        if (existingPromise) return void this.handlePromise(existingPromise, language, namespace, callback, false);
+        this.loadResource(language, namespace, callback);
+    }
+    create(_languages, _namespace, _key, _fallbackValue) {}
+    isLoading(language, namespace) {
+        return this.loadingPromises.has(this.getCacheKey(language, namespace));
+    }
+    getLoadingResources() {
+        const loading = [];
+        for (const key of this.loadingPromises.keys()){
+            const [language, namespace] = key.split(':');
+            if (language && namespace) loading.push({
+                language,
+                namespace
+            });
+        }
+        return loading;
+    }
+    hasLoadingResources() {
+        return this.loadingPromises.size > 0;
+    }
+    getCacheKey(language, namespace) {
+        return `${language}:${namespace}`;
+    }
+    loadResource(language, namespace, callback) {
+        try {
+            const result = this.callSdk(language, namespace);
+            const loadPromise = result instanceof Promise ? result : Promise.resolve(result);
+            const cacheKey = this.getCacheKey(language, namespace);
+            this.loadingPromises.set(cacheKey, loadPromise);
+            this.handlePromise(loadPromise, language, namespace, callback, true);
+        } catch (error) {
+            callback(this.normalizeError(error), null);
+        }
+    }
+    handlePromise(promise, language, namespace, callback, shouldUpdateCache) {
+        const cacheKey = this.getCacheKey(language, namespace);
+        promise.then((data)=>{
+            const formattedData = this.formatResources(data, language, namespace);
+            const mergedData = this.mergeWithExistingResources(language, namespace, formattedData);
+            if (shouldUpdateCache) {
+                this.updateCache(language, namespace, mergedData);
+                this.loadingPromises.delete(cacheKey);
+            }
+            callback(null, mergedData);
+            this.triggerI18nextUpdate(language, namespace);
+        }).catch((error)=>{
+            if (shouldUpdateCache) this.loadingPromises.delete(cacheKey);
+            callback(this.normalizeError(error), null);
+        });
+    }
+    normalizeError(error) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    callSdk(language, namespace) {
+        if (!this.sdk) throw new Error('SDK function not initialized');
+        const options = {
+            lng: language,
+            ns: namespace
+        };
+        return this.sdk(options);
+    }
+    extractFromCache(language, namespace) {
+        if (!this.allResourcesCache) return null;
+        const langData = this.allResourcesCache[language];
+        if (!this.isObject(langData)) return null;
+        const nsData = langData[namespace];
+        if (!this.isObject(nsData)) return null;
+        return nsData;
+    }
+    updateCache(language, namespace, data) {
+        if (!this.allResourcesCache) this.allResourcesCache = {};
+        if (!this.allResourcesCache[language]) this.allResourcesCache[language] = {};
+        if (this.isObject(data)) this.allResourcesCache[language][namespace] = data;
+    }
+    formatResources(data, language, namespace) {
+        if (!this.isObject(data)) return {};
+        const dataObj = data;
+        const langData = dataObj[language];
+        if (this.isObject(langData)) {
+            const nsData = langData[namespace];
+            if (this.isObject(nsData)) return nsData;
+        }
+        const hasLanguageKeys = Object.keys(dataObj).some((key)=>this.isObject(dataObj[key]));
+        if (!hasLanguageKeys) return dataObj;
+        return {};
+    }
+    isObject(value) {
+        return null !== value && 'object' == typeof value;
+    }
+    mergeWithExistingResources(language, namespace, sdkData) {
+        const store = this.services?.resourceStore || this.services?.store;
+        const existingData = store?.data?.[language]?.[namespace] || {};
+        return {
+            ...existingData,
+            ...sdkData
+        };
+    }
+    triggerI18nextUpdate(language, namespace) {
+        if ("u" > typeof window) {
+            const event = new CustomEvent('i18n-sdk-resources-loaded', {
+                detail: {
+                    language,
+                    namespace
+                }
+            });
+            window.dispatchEvent(event);
+        }
+    }
+    constructor(_services, _options){
+        this.type = 'backend';
+        this.allResourcesCache = null;
+        this.loadingPromises = new Map();
+    }
+}
+SdkBackend.type = 'backend';
+exports.SdkBackend = __webpack_exports__.SdkBackend;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "SdkBackend"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/i18n/detection/config.cjs

@@ -0,0 +1,63 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    mergeDetectionOptions: ()=>mergeDetectionOptions,
+    DEFAULT_I18NEXT_DETECTION_OPTIONS: ()=>DEFAULT_I18NEXT_DETECTION_OPTIONS
+});
+const deepMerge_cjs_namespaceObject = require("../../../shared/deepMerge.cjs");
+const DEFAULT_I18NEXT_DETECTION_OPTIONS = {
+    caches: [
+        'cookie',
+        'localStorage'
+    ],
+    order: [
+        'querystring',
+        'cookie',
+        'localStorage',
+        'header',
+        'navigator',
+        'htmlTag',
+        'path',
+        'subdomain'
+    ],
+    cookieMinutes: 525600,
+    lookupQuerystring: 'lng',
+    lookupCookie: 'i18next',
+    lookupLocalStorage: 'i18nextLng',
+    lookupHeader: 'accept-language'
+};
+function mergeDetectionOptions(cliOptions, userOptions, defaultOptions = DEFAULT_I18NEXT_DETECTION_OPTIONS) {
+    return (0, deepMerge_cjs_namespaceObject.deepMerge)((0, deepMerge_cjs_namespaceObject.deepMerge)(defaultOptions, cliOptions ?? {}), userOptions ?? {});
+}
+exports.DEFAULT_I18NEXT_DETECTION_OPTIONS = __webpack_exports__.DEFAULT_I18NEXT_DETECTION_OPTIONS;
+exports.mergeDetectionOptions = __webpack_exports__.mergeDetectionOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_I18NEXT_DETECTION_OPTIONS",
+    "mergeDetectionOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});