@modern-js/plugin-i18n 2.69.5 → 3.0.0-alpha.0

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

@@ -0,0 +1,309 @@
+"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__, {
+    exportServerLngToWindow: ()=>exportServerLngToWindow,
+    buildInitOptions: ()=>buildInitOptions,
+    mergeDetectionOptions: ()=>mergeDetectionOptions,
+    getLanguageFromSSRData: ()=>getLanguageFromSSRData,
+    detectLanguageWithPriority: ()=>detectLanguageWithPriority,
+    cacheUserLanguage: ()=>external_middleware_cjs_namespaceObject.cacheUserLanguage
+});
+const runtime_namespaceObject = require("@modern-js/runtime");
+const external_utils_cjs_namespaceObject = require("../../utils.cjs");
+const external_instance_cjs_namespaceObject = require("../instance.cjs");
+const external_config_cjs_namespaceObject = require("./config.cjs");
+const external_middleware_cjs_namespaceObject = require("./middleware.cjs");
+const detectorInstanceCache = new WeakMap();
+const DETECTOR_SAFE_OPTION_KEYS = [
+    'lowerCaseLng',
+    'nonExplicitSupportedLngs',
+    'load',
+    'partialBundledLanguages',
+    'returnNull',
+    'returnEmptyString',
+    'returnObjects',
+    'joinArrays',
+    'keySeparator',
+    'nsSeparator',
+    'pluralSeparator',
+    'contextSeparator',
+    'fallbackNS',
+    'ns',
+    'defaultNS',
+    'debug'
+];
+const stableStringify = (value)=>{
+    if (null == value) return JSON.stringify(value);
+    if ('object' != typeof value) return JSON.stringify(value);
+    if (Array.isArray(value)) return `[${value.map((item)=>stableStringify(item)).join(',')}]`;
+    const sortedKeys = Object.keys(value).sort();
+    const sortedEntries = sortedKeys.map((key)=>{
+        const stringifiedValue = stableStringify(value[key]);
+        return `${JSON.stringify(key)}:${stringifiedValue}`;
+    });
+    return `{${sortedEntries.join(',')}}`;
+};
+const buildDetectorConfigKey = (languages, fallbackLanguage, mergedDetection)=>stableStringify({
+        languages,
+        fallbackLanguage,
+        detection: mergedDetection
+    });
+const pickSafeDetectionOptions = (userInitOptions)=>{
+    if (!userInitOptions) return {};
+    const safeOptions = {};
+    for (const key of DETECTOR_SAFE_OPTION_KEYS){
+        const value = userInitOptions[key];
+        if (void 0 !== value) safeOptions[key] = value;
+    }
+    if (userInitOptions.interpolation) safeOptions.interpolation = {
+        ...userInitOptions.interpolation
+    };
+    return safeOptions;
+};
+const cleanupDetectorCacheEntry = (entry)=>{
+    if (!entry || !entry.isTemporary) return;
+    const instance = entry.instance;
+    try {
+        instance?.removeAllListeners?.();
+    } catch (error) {}
+    try {
+        instance?.off?.('*');
+    } catch (error) {}
+    try {
+        instance?.services?.backendConnector?.backend?.stop?.();
+    } catch (error) {}
+    try {
+        instance?.services?.backendConnector?.backend?.close?.();
+    } catch (error) {}
+};
+function exportServerLngToWindow(context, lng) {
+    context.__i18nData__ = {
+        lng
+    };
+}
+const getLanguageFromSSRData = (window1)=>{
+    try {
+        const ssrData = window1._SSR_DATA;
+        if (!ssrData || !ssrData.data || !ssrData.data.i18nData) return;
+        const lng = ssrData.data.i18nData.lng;
+        return 'string' == typeof lng && '' !== lng.trim() ? lng : void 0;
+    } catch (error) {
+        return;
+    }
+};
+const normalizeLanguageCode = (language)=>{
+    if (!language) return language;
+    const baseLang = language.split('-')[0];
+    return baseLang;
+};
+const isLanguageSupported = (language, supportedLanguages)=>{
+    if (!language) return false;
+    if (0 === supportedLanguages.length) return true;
+    if (supportedLanguages.includes(language)) return true;
+    const baseLang = normalizeLanguageCode(language);
+    if (baseLang !== language && supportedLanguages.includes(baseLang)) return true;
+    return false;
+};
+const getSupportedLanguage = (language, supportedLanguages)=>{
+    if (!language) return;
+    if (0 === supportedLanguages.length) return language;
+    if (supportedLanguages.includes(language)) return language;
+    const baseLang = normalizeLanguageCode(language);
+    if (baseLang !== language && supportedLanguages.includes(baseLang)) return baseLang;
+};
+const detectLanguageFromSSR = (languages)=>{
+    if (!(0, runtime_namespaceObject.isBrowser)()) return;
+    try {
+        const ssrLanguage = getLanguageFromSSRData(window);
+        if (ssrLanguage && isLanguageSupported(ssrLanguage, languages)) return ssrLanguage;
+    } catch (error) {}
+};
+const detectLanguageFromPathPriority = (pathname, languages, localePathRedirect)=>{
+    if (!localePathRedirect) return;
+    if (!languages || 0 === languages.length) return;
+    if (!pathname || '' === pathname.trim()) return;
+    try {
+        const pathDetection = (0, external_utils_cjs_namespaceObject.detectLanguageFromPath)(pathname, languages, localePathRedirect);
+        if (true === pathDetection.detected && pathDetection.language) return pathDetection.language;
+    } catch (error) {}
+};
+const createDetectorInstance = (baseInstance, configKey)=>{
+    const cached = detectorInstanceCache.get(baseInstance);
+    if (cached && cached.configKey === configKey) return {
+        instance: cached.instance,
+        isTemporary: cached.isTemporary
+    };
+    if (cached) {
+        cleanupDetectorCacheEntry(cached);
+        detectorInstanceCache.delete(baseInstance);
+    }
+    const createNewInstance = ()=>{
+        if ('function' == typeof baseInstance.createInstance) try {
+            const created = baseInstance.createInstance();
+            if (created) return {
+                instance: created,
+                isTemporary: true
+            };
+        } catch (error) {}
+        if ('function' == typeof baseInstance.cloneInstance) try {
+            const cloned = baseInstance.cloneInstance();
+            if (cloned) return {
+                instance: cloned,
+                isTemporary: true
+            };
+        } catch (error) {}
+        return {
+            instance: baseInstance,
+            isTemporary: false
+        };
+    };
+    const created = createNewInstance();
+    if (created.isTemporary) detectorInstanceCache.set(baseInstance, {
+        instance: created.instance,
+        isTemporary: true,
+        configKey
+    });
+    return created;
+};
+const initializeI18nForDetector = async (i18nInstance, options)=>{
+    const mergedDetection = mergeDetectionOptions(options.i18nextDetector, options.detection, options.localePathRedirect, options.userInitOptions);
+    const configKey = buildDetectorConfigKey(options.languages, options.fallbackLanguage, mergedDetection);
+    const { instance, isTemporary } = createDetectorInstance(i18nInstance, configKey);
+    const safeUserOptions = pickSafeDetectionOptions(options.userInitOptions);
+    const initOptions = {
+        ...safeUserOptions,
+        fallbackLng: options.fallbackLanguage,
+        supportedLngs: options.languages,
+        detection: mergedDetection,
+        initImmediate: true,
+        interpolation: {
+            ...safeUserOptions?.interpolation || {},
+            escapeValue: safeUserOptions?.interpolation?.escapeValue ?? false
+        },
+        react: {
+            useSuspense: false
+        }
+    };
+    (0, external_middleware_cjs_namespaceObject.useI18nextLanguageDetector)(instance);
+    if (instance.isInitialized) {
+        if (isTemporary) await instance.init(initOptions);
+    } else await instance.init(initOptions);
+    return {
+        detectorInstance: instance,
+        isTemporary
+    };
+};
+const detectLanguageFromI18nextDetector = async (i18nInstance, options)=>{
+    if (!options.i18nextDetector) return;
+    const mergedDetection = mergeDetectionOptions(options.i18nextDetector, options.detection, options.localePathRedirect, options.userInitOptions);
+    const { detectorInstance, isTemporary } = await initializeI18nForDetector(i18nInstance, options);
+    try {
+        const request = options.ssrContext?.request;
+        if (!(0, runtime_namespaceObject.isBrowser)() && !request) return;
+        const detectorLang = (0, external_middleware_cjs_namespaceObject.detectLanguage)(detectorInstance, request, mergedDetection);
+        if (detectorLang) {
+            const supportedLang = getSupportedLanguage(detectorLang, options.languages);
+            if (supportedLang) return supportedLang;
+        }
+        if (detectorInstance.isInitialized && detectorInstance.language) {
+            const currentLang = detectorInstance.language;
+            if (isLanguageSupported(currentLang, options.languages)) return currentLang;
+        }
+    } catch (error) {} finally{
+        if (isTemporary && detectorInstance !== i18nInstance) detectorInstanceCache.set(i18nInstance, {
+            instance: detectorInstance,
+            isTemporary: true,
+            configKey: buildDetectorConfigKey(options.languages, options.fallbackLanguage, mergedDetection)
+        });
+        else if (detectorInstance === i18nInstance) {
+            i18nInstance.isInitialized = false;
+            delete i18nInstance.language;
+        }
+    }
+};
+const detectLanguageWithPriority = async (i18nInstance, options)=>{
+    const { languages, fallbackLanguage, localePathRedirect, i18nextDetector, detection, userInitOptions, pathname, ssrContext } = options;
+    let detectedLanguage;
+    detectedLanguage = detectLanguageFromSSR(languages);
+    if (!detectedLanguage) detectedLanguage = detectLanguageFromPathPriority(pathname, languages, localePathRedirect);
+    if (!detectedLanguage && i18nextDetector) detectedLanguage = (0, external_instance_cjs_namespaceObject.isI18nWrapperInstance)(i18nInstance) ? (0, external_middleware_cjs_namespaceObject.readLanguageFromStorage)(mergeDetectionOptions(i18nextDetector, detection, localePathRedirect, userInitOptions)) : await detectLanguageFromI18nextDetector(i18nInstance, {
+        languages,
+        fallbackLanguage,
+        localePathRedirect,
+        i18nextDetector,
+        detection,
+        userInitOptions,
+        mergedBackend: options.mergedBackend,
+        ssrContext
+    });
+    const finalLanguage = detectedLanguage || userInitOptions?.lng || fallbackLanguage;
+    return {
+        detectedLanguage,
+        finalLanguage
+    };
+};
+const buildInitOptions = (params)=>{
+    const { finalLanguage, fallbackLanguage, languages, userInitOptions, mergedDetection, mergeBackend } = params;
+    return {
+        ...userInitOptions || {},
+        lng: finalLanguage,
+        fallbackLng: fallbackLanguage,
+        supportedLngs: languages,
+        detection: mergedDetection,
+        backend: mergeBackend,
+        interpolation: {
+            ...userInitOptions?.interpolation || {},
+            escapeValue: userInitOptions?.interpolation?.escapeValue ?? false
+        },
+        react: {
+            useSuspense: (0, runtime_namespaceObject.isBrowser)()
+        }
+    };
+};
+const mergeDetectionOptions = (i18nextDetector, detection, localePathRedirect, userInitOptions)=>{
+    let mergedDetection;
+    mergedDetection = i18nextDetector ? (0, external_config_cjs_namespaceObject.mergeDetectionOptions)(detection, userInitOptions?.detection) : userInitOptions?.detection || {};
+    if (!mergedDetection || 'object' != typeof mergedDetection) mergedDetection = {};
+    if (localePathRedirect && mergedDetection.order) mergedDetection.order = mergedDetection.order.filter((item)=>'path' !== item);
+    return mergedDetection;
+};
+exports.buildInitOptions = __webpack_exports__.buildInitOptions;
+exports.cacheUserLanguage = __webpack_exports__.cacheUserLanguage;
+exports.detectLanguageWithPriority = __webpack_exports__.detectLanguageWithPriority;
+exports.exportServerLngToWindow = __webpack_exports__.exportServerLngToWindow;
+exports.getLanguageFromSSRData = __webpack_exports__.getLanguageFromSSRData;
+exports.mergeDetectionOptions = __webpack_exports__.mergeDetectionOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildInitOptions",
+    "cacheUserLanguage",
+    "detectLanguageWithPriority",
+    "exportServerLngToWindow",
+    "getLanguageFromSSRData",
+    "mergeDetectionOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,185 @@
+"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__, {
+    detectLanguage: ()=>detectLanguage,
+    useI18nextLanguageDetector: ()=>useI18nextLanguageDetector,
+    readLanguageFromStorage: ()=>readLanguageFromStorage,
+    cacheUserLanguage: ()=>cacheUserLanguage
+});
+const runtime_namespaceObject = require("@modern-js/runtime");
+const external_i18next_browser_languagedetector_namespaceObject = require("i18next-browser-languagedetector");
+var external_i18next_browser_languagedetector_default = /*#__PURE__*/ __webpack_require__.n(external_i18next_browser_languagedetector_namespaceObject);
+const external_instance_cjs_namespaceObject = require("../instance.cjs");
+const useI18nextLanguageDetector = (i18nInstance)=>{
+    if (!i18nInstance.isInitialized) {
+        if ((0, external_instance_cjs_namespaceObject.isI18nWrapperInstance)(i18nInstance)) {
+            const actualInstance = (0, external_instance_cjs_namespaceObject.getActualI18nextInstance)(i18nInstance);
+            if (actualInstance && !actualInstance.isInitialized) actualInstance.use(external_i18next_browser_languagedetector_default());
+        }
+        return i18nInstance.use(external_i18next_browser_languagedetector_default());
+    }
+    return i18nInstance;
+};
+const readLanguageFromStorage = (detectionOptions)=>{
+    try {
+        const options = detectionOptions || {};
+        const order = options.order || [
+            'querystring',
+            'cookie',
+            'localStorage',
+            'navigator',
+            'htmlTag',
+            'path',
+            'subdomain'
+        ];
+        for (const method of order)switch(method){
+            case 'querystring':
+                {
+                    const lookupKey = options.lookupQuerystring || 'lng';
+                    const urlParams = new URLSearchParams(window.location.search);
+                    const lang = urlParams.get(lookupKey);
+                    if (lang) return lang;
+                    break;
+                }
+            case 'cookie':
+                {
+                    const lookupKey = options.lookupCookie || 'i18next';
+                    const cookies = document.cookie.split(';').reduce((acc, item)=>{
+                        const [key, value] = item.trim().split('=');
+                        if (key && value) acc[key] = decodeURIComponent(value);
+                        return acc;
+                    }, {});
+                    if (cookies[lookupKey]) return cookies[lookupKey];
+                    break;
+                }
+            case 'localStorage':
+                {
+                    const lookupKey = options.lookupLocalStorage || 'i18nextLng';
+                    const keysToCheck = [
+                        lookupKey
+                    ];
+                    if ('i18nextLng' === lookupKey) keysToCheck.push('i18next');
+                    for (const key of keysToCheck){
+                        const stored = localStorage.getItem(key);
+                        if (stored) return stored;
+                    }
+                    break;
+                }
+            case 'navigator':
+                if (navigator.language) return navigator.language.split('-')[0];
+                break;
+            case 'htmlTag':
+                {
+                    const htmlLang = document.documentElement.lang;
+                    if (htmlLang) return htmlLang.split('-')[0];
+                    break;
+                }
+        }
+    } catch (error) {}
+};
+const detectLanguage = (i18nInstance, _request, detectionOptions)=>{
+    try {
+        const actualInstance = (0, external_instance_cjs_namespaceObject.isI18nWrapperInstance)(i18nInstance) ? (0, external_instance_cjs_namespaceObject.getActualI18nextInstance)(i18nInstance) : i18nInstance;
+        const isInitialized = i18nInstance.isInitialized || actualInstance?.isInitialized;
+        const detector = actualInstance?.services?.languageDetector || i18nInstance.services?.languageDetector;
+        if (detector && 'function' == typeof detector.detect) {
+            const result = detector.detect();
+            if ('string' == typeof result) return result;
+            if (Array.isArray(result) && result.length > 0) return result[0];
+        }
+        if ((0, runtime_namespaceObject.isBrowser)()) {
+            const directRead = readLanguageFromStorage(detectionOptions);
+            if (directRead) return directRead;
+        }
+        if (isInitialized) {
+            const servicesToUse = actualInstance?.services || i18nInstance.services;
+            const optionsToUse = actualInstance?.options || i18nInstance.options;
+            if (servicesToUse && optionsToUse) {
+                const manualDetector = new (external_i18next_browser_languagedetector_default())();
+                const mergedOptions = detectionOptions ? {
+                    ...optionsToUse,
+                    detection: detectionOptions
+                } : optionsToUse;
+                manualDetector.init(servicesToUse, mergedOptions);
+                const result = manualDetector.detect();
+                if ('string' == typeof result) return result;
+                if (Array.isArray(result) && result.length > 0) return result[0];
+            }
+        }
+    } catch (error) {}
+};
+const cacheUserLanguage = (i18nInstance, language, detectionOptions)=>{
+    if ("u" < typeof window) return;
+    try {
+        const actualInstance = (0, external_instance_cjs_namespaceObject.isI18nWrapperInstance)(i18nInstance) ? (0, external_instance_cjs_namespaceObject.getActualI18nextInstance)(i18nInstance) : i18nInstance;
+        const detector = actualInstance?.services?.languageDetector || i18nInstance.services?.languageDetector;
+        if (detector && 'function' == typeof detector.cacheUserLanguage) try {
+            detector.cacheUserLanguage(language);
+            return;
+        } catch (error) {
+            if ('development' === process.env.NODE_ENV) console.warn('[i18n] Failed to cache via detector, falling back to manual cache:', error);
+        }
+        const isInitialized = i18nInstance.isInitialized || actualInstance?.isInitialized;
+        const servicesToUse = actualInstance?.services || i18nInstance.services;
+        const optionsToUse = actualInstance?.options || i18nInstance.options;
+        if (isInitialized && servicesToUse && optionsToUse) try {
+            const userOptions = detectionOptions || optionsToUse?.detection;
+            const mergedOptions = userOptions ? {
+                ...optionsToUse,
+                detection: userOptions
+            } : optionsToUse;
+            const manualDetector = new (external_i18next_browser_languagedetector_default())();
+            manualDetector.init(servicesToUse, mergedOptions);
+            if ('function' == typeof manualDetector.cacheUserLanguage) return void manualDetector.cacheUserLanguage(language);
+        } catch (error) {
+            if ('development' === process.env.NODE_ENV) console.warn('[i18n] Failed to create manual detector:', error);
+        }
+    } catch (error) {
+        if ('development' === process.env.NODE_ENV) console.error('Failed to cache user language:', error);
+    }
+};
+exports.cacheUserLanguage = __webpack_exports__.cacheUserLanguage;
+exports.detectLanguage = __webpack_exports__.detectLanguage;
+exports.readLanguageFromStorage = __webpack_exports__.readLanguageFromStorage;
+exports.useI18nextLanguageDetector = __webpack_exports__.useI18nextLanguageDetector;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "cacheUserLanguage",
+    "detectLanguage",
+    "readLanguageFromStorage",
+    "useI18nextLanguageDetector"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,74 @@
+"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__, {
+    detectLanguage: ()=>detectLanguage,
+    useI18nextLanguageDetector: ()=>useI18nextLanguageDetector,
+    readLanguageFromStorage: ()=>readLanguageFromStorage,
+    cacheUserLanguage: ()=>cacheUserLanguage
+});
+const external_i18next_http_middleware_namespaceObject = require("i18next-http-middleware");
+const cacheUserLanguage = (_i18nInstance, _language, _detectionOptions)=>{};
+const readLanguageFromStorage = (_detectionOptions)=>{};
+const useI18nextLanguageDetector = (i18nInstance)=>{
+    if (!i18nInstance.isInitialized) return i18nInstance.use(external_i18next_http_middleware_namespaceObject.LanguageDetector);
+    return i18nInstance;
+};
+const detectLanguage = (i18nInstance, request, detectionOptions)=>{
+    if (!request) return;
+    try {
+        const detector = i18nInstance.services?.languageDetector;
+        if (detector && 'function' == typeof detector.detect) {
+            const result = detector.detect(request, {});
+            if ('string' == typeof result) return result;
+            if (Array.isArray(result) && result.length > 0) return result[0];
+            return;
+        }
+        if (i18nInstance.isInitialized && i18nInstance.services && i18nInstance.options) {
+            const manualDetector = new external_i18next_http_middleware_namespaceObject.LanguageDetector();
+            const optionsToUse = detectionOptions ? {
+                ...i18nInstance.options,
+                detection: detectionOptions
+            } : i18nInstance.options;
+            manualDetector.init(i18nInstance.services, optionsToUse);
+            const result = manualDetector.detect(request, {}, void 0);
+            if ('string' == typeof result) return result;
+            if (Array.isArray(result) && result.length > 0) return result[0];
+        }
+    } catch (error) {}
+};
+exports.cacheUserLanguage = __webpack_exports__.cacheUserLanguage;
+exports.detectLanguage = __webpack_exports__.detectLanguage;
+exports.readLanguageFromStorage = __webpack_exports__.readLanguageFromStorage;
+exports.useI18nextLanguageDetector = __webpack_exports__.useI18nextLanguageDetector;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "cacheUserLanguage",
+    "detectLanguage",
+    "readLanguageFromStorage",
+    "useI18nextLanguageDetector"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,43 @@
+"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__, {
+    getI18nInstance: ()=>external_instance_cjs_namespaceObject.getI18nInstance,
+    isI18nInstance: ()=>external_instance_cjs_namespaceObject.isI18nInstance,
+    assertI18nInstance: ()=>external_utils_cjs_namespaceObject.assertI18nInstance
+});
+const external_instance_cjs_namespaceObject = require("./instance.cjs");
+const external_utils_cjs_namespaceObject = require("./utils.cjs");
+exports.assertI18nInstance = __webpack_exports__.assertI18nInstance;
+exports.getI18nInstance = __webpack_exports__.getI18nInstance;
+exports.isI18nInstance = __webpack_exports__.isI18nInstance;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "assertI18nInstance",
+    "getI18nInstance",
+    "isI18nInstance"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});