@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.6 → 3.5.0-ultramodern.76

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

@@ -28,272 +28,17 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    buildInitOptions: ()=>buildInitOptions,
+    buildInitOptions: ()=>external_initOptions_js_namespaceObject.buildInitOptions,
     cacheUserLanguage: ()=>external_middleware_js_namespaceObject.cacheUserLanguage,
-    detectLanguageWithPriority: ()=>detectLanguageWithPriority,
-    exportServerLngToWindow: ()=>exportServerLngToWindow,
-    getLanguageFromSSRData: ()=>getLanguageFromSSRData,
-    mergeDetectionOptions: ()=>mergeDetectionOptions
+    detectLanguageWithPriority: ()=>external_priority_js_namespaceObject.detectLanguageWithPriority,
+    exportServerLngToWindow: ()=>external_ssr_js_namespaceObject.exportServerLngToWindow,
+    getLanguageFromSSRData: ()=>external_ssr_js_namespaceObject.getLanguageFromSSRData,
+    mergeDetectionOptions: ()=>external_initOptions_js_namespaceObject.mergeDetectionOptions
 });
-const runtime_namespaceObject = require("@modern-js/runtime");
-const external_utils_js_namespaceObject = require("../../utils.js");
-const external_instance_js_namespaceObject = require("../instance.js");
-const external_config_js_namespaceObject = require("./config.js");
+const external_initOptions_js_namespaceObject = require("./initOptions.js");
 const external_middleware_js_namespaceObject = require("./middleware.js");
-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_js_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_js_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_js_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_js_namespaceObject.isI18nWrapperInstance)(i18nInstance) ? (0, external_middleware_js_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_js_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;
-};
+const external_priority_js_namespaceObject = require("./priority.js");
+const external_ssr_js_namespaceObject = require("./ssr.js");
 exports.buildInitOptions = __webpack_exports__.buildInitOptions;
 exports.cacheUserLanguage = __webpack_exports__.cacheUserLanguage;
 exports.detectLanguageWithPriority = __webpack_exports__.detectLanguageWithPriority;

package/dist/cjs/runtime/i18n/detection/initOptions.js

@@ -0,0 +1,69 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    buildInitOptions: ()=>buildInitOptions,
+    mergeDetectionOptions: ()=>mergeDetectionOptions
+});
+const runtime_namespaceObject = require("@modern-js/runtime");
+const external_config_js_namespaceObject = require("./config.js");
+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_js_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.mergeDetectionOptions = __webpack_exports__.mergeDetectionOptions;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildInitOptions",
+    "mergeDetectionOptions"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/i18n/detection/language.js

@@ -0,0 +1,62 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__);
+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;
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    getSupportedLanguage: getSupportedLanguage,
+    isLanguageSupported: isLanguageSupported
+});
+exports.getSupportedLanguage = __webpack_exports__.getSupportedLanguage;
+exports.isLanguageSupported = __webpack_exports__.isLanguageSupported;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getSupportedLanguage",
+    "isLanguageSupported"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/i18n/detection/path.js

@@ -0,0 +1,49 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    detectLanguageFromPathPriority: ()=>detectLanguageFromPathPriority
+});
+const external_utils_js_namespaceObject = require("../../utils.js");
+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_js_namespaceObject.detectLanguageFromPath)(pathname, languages, localePathRedirect);
+        if (true === pathDetection.detected && pathDetection.language) return pathDetection.language;
+    } catch (error) {}
+};
+exports.detectLanguageFromPathPriority = __webpack_exports__.detectLanguageFromPathPriority;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "detectLanguageFromPathPriority"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/i18n/detection/priority.js

@@ -0,0 +1,66 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    detectLanguageWithPriority: ()=>detectLanguageWithPriority
+});
+const external_instance_js_namespaceObject = require("../instance.js");
+const external_detector_js_namespaceObject = require("./detector.js");
+const external_initOptions_js_namespaceObject = require("./initOptions.js");
+const external_middleware_js_namespaceObject = require("./middleware.js");
+const external_path_js_namespaceObject = require("./path.js");
+const external_ssr_js_namespaceObject = require("./ssr.js");
+const detectLanguageWithPriority = async (i18nInstance, options)=>{
+    const { languages, fallbackLanguage, localePathRedirect, i18nextDetector, detection, userInitOptions, pathname, ssrContext } = options;
+    let detectedLanguage;
+    detectedLanguage = (0, external_path_js_namespaceObject.detectLanguageFromPathPriority)(pathname, languages, localePathRedirect);
+    if (!detectedLanguage) detectedLanguage = (0, external_ssr_js_namespaceObject.detectLanguageFromSSR)(languages);
+    if (!detectedLanguage && i18nextDetector) detectedLanguage = (0, external_instance_js_namespaceObject.isI18nWrapperInstance)(i18nInstance) ? (0, external_middleware_js_namespaceObject.readLanguageFromStorage)((0, external_initOptions_js_namespaceObject.mergeDetectionOptions)(i18nextDetector, detection, localePathRedirect, userInitOptions)) : await (0, external_detector_js_namespaceObject.detectLanguageFromI18nextDetector)(i18nInstance, {
+        languages,
+        fallbackLanguage,
+        localePathRedirect,
+        i18nextDetector,
+        detection,
+        userInitOptions,
+        mergedBackend: options.mergedBackend,
+        ssrContext
+    });
+    const finalLanguage = detectedLanguage || userInitOptions?.lng || fallbackLanguage;
+    return {
+        detectedLanguage,
+        finalLanguage
+    };
+};
+exports.detectLanguageWithPriority = __webpack_exports__.detectLanguageWithPriority;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "detectLanguageWithPriority"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/i18n/detection/ssr.js

@@ -0,0 +1,70 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    detectLanguageFromSSR: ()=>detectLanguageFromSSR,
+    exportServerLngToWindow: ()=>exportServerLngToWindow,
+    getLanguageFromSSRData: ()=>getLanguageFromSSRData
+});
+const runtime_namespaceObject = require("@modern-js/runtime");
+const external_language_js_namespaceObject = require("./language.js");
+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 detectLanguageFromSSR = (languages)=>{
+    if (!(0, runtime_namespaceObject.isBrowser)()) return;
+    try {
+        const ssrLanguage = getLanguageFromSSRData(window);
+        const supportedLanguage = (0, external_language_js_namespaceObject.getSupportedLanguage)(ssrLanguage, languages);
+        if (supportedLanguage) return supportedLanguage;
+    } catch (error) {}
+};
+exports.detectLanguageFromSSR = __webpack_exports__.detectLanguageFromSSR;
+exports.exportServerLngToWindow = __webpack_exports__.exportServerLngToWindow;
+exports.getLanguageFromSSRData = __webpack_exports__.getLanguageFromSSRData;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "detectLanguageFromSSR",
+    "exportServerLngToWindow",
+    "getLanguageFromSSRData"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/i18n/detection/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});