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

package/dist/cjs/runtime/i18n/instance.cjs

@@ -0,0 +1,132 @@
+"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__, {
+    getActualI18nextInstance: ()=>getActualI18nextInstance,
+    getI18nInstance: ()=>getI18nInstance,
+    getI18nWrapperI18nextInstance: ()=>getI18nWrapperI18nextInstance,
+    getI18nextInstanceForProvider: ()=>getI18nextInstanceForProvider,
+    getI18nextProvider: ()=>getI18nextProvider,
+    getInitReactI18next: ()=>getInitReactI18next,
+    isI18nInstance: ()=>isI18nInstance,
+    isI18nWrapperInstance: ()=>isI18nWrapperInstance
+});
+function isI18nWrapperInstance(obj) {
+    if (!obj || 'object' != typeof obj) return false;
+    if (!obj.i18nInstance || 'object' != typeof obj.i18nInstance) return false;
+    if (!obj.i18nInstance.instance) return false;
+    if ('function' != typeof obj.init || 'function' != typeof obj.use) return false;
+    return true;
+}
+function getI18nWrapperI18nextInstance(wrapperInstance) {
+    if (isI18nWrapperInstance(wrapperInstance)) return wrapperInstance.i18nInstance?.instance;
+    return null;
+}
+function getActualI18nextInstance(instance) {
+    if (isI18nWrapperInstance(instance)) {
+        const i18nextInstance = getI18nWrapperI18nextInstance(instance);
+        return i18nextInstance || instance;
+    }
+    return instance;
+}
+function isI18nInstance(obj) {
+    if (!obj || 'object' != typeof obj) return false;
+    if (isI18nWrapperInstance(obj)) return true;
+    return 'function' == typeof obj.init && 'function' == typeof obj.use;
+}
+async function tryImportI18next() {
+    try {
+        const i18next = await import("i18next");
+        return i18next.default;
+    } catch (error) {
+        return null;
+    }
+}
+async function createI18nextInstance() {
+    try {
+        const i18next = await tryImportI18next();
+        if (!i18next) return null;
+        return i18next.createInstance({
+            initImmediate: false
+        });
+    } catch (error) {
+        return null;
+    }
+}
+async function tryImportReactI18next() {
+    try {
+        const reactI18next = await import("react-i18next");
+        return reactI18next;
+    } catch (error) {
+        return null;
+    }
+}
+function getI18nextInstanceForProvider(instance) {
+    if (isI18nWrapperInstance(instance)) {
+        const i18nextInstance = getI18nWrapperI18nextInstance(instance);
+        if (i18nextInstance) return i18nextInstance;
+    }
+    return instance;
+}
+async function getI18nInstance(userInstance) {
+    if (userInstance) {
+        if (isI18nWrapperInstance(userInstance)) return userInstance;
+        if (isI18nInstance(userInstance)) return userInstance;
+    }
+    const i18nextInstance = await createI18nextInstance();
+    if (i18nextInstance) return i18nextInstance;
+    throw new Error('No i18n instance found');
+}
+async function getInitReactI18next() {
+    const reactI18nextModule = await tryImportReactI18next();
+    if (reactI18nextModule) return reactI18nextModule.initReactI18next;
+    return null;
+}
+async function getI18nextProvider() {
+    const reactI18nextModule = await tryImportReactI18next();
+    if (reactI18nextModule) return reactI18nextModule.I18nextProvider;
+    return null;
+}
+exports.getActualI18nextInstance = __webpack_exports__.getActualI18nextInstance;
+exports.getI18nInstance = __webpack_exports__.getI18nInstance;
+exports.getI18nWrapperI18nextInstance = __webpack_exports__.getI18nWrapperI18nextInstance;
+exports.getI18nextInstanceForProvider = __webpack_exports__.getI18nextInstanceForProvider;
+exports.getI18nextProvider = __webpack_exports__.getI18nextProvider;
+exports.getInitReactI18next = __webpack_exports__.getInitReactI18next;
+exports.isI18nInstance = __webpack_exports__.isI18nInstance;
+exports.isI18nWrapperInstance = __webpack_exports__.isI18nWrapperInstance;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getActualI18nextInstance",
+    "getI18nInstance",
+    "getI18nWrapperI18nextInstance",
+    "getI18nextInstanceForProvider",
+    "getI18nextProvider",
+    "getInitReactI18next",
+    "isI18nInstance",
+    "isI18nWrapperInstance"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/i18n/utils.cjs

@@ -0,0 +1,185 @@
+"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__, {
+    setupClonedInstance: ()=>setupClonedInstance,
+    buildInitOptions: ()=>buildInitOptions,
+    assertI18nInstance: ()=>assertI18nInstance,
+    initializeI18nInstance: ()=>initializeI18nInstance,
+    changeI18nLanguage: ()=>changeI18nLanguage,
+    ensureLanguageMatch: ()=>ensureLanguageMatch
+});
+const runtime_namespaceObject = require("@modern-js/runtime");
+const index_cjs_namespaceObject = require("./backend/index.cjs");
+const middleware_cjs_namespaceObject = require("./backend/middleware.cjs");
+const sdk_backend_cjs_namespaceObject = require("./backend/sdk-backend.cjs");
+const external_detection_index_cjs_namespaceObject = require("./detection/index.cjs");
+const external_instance_cjs_namespaceObject = require("./instance.cjs");
+function assertI18nInstance(obj) {
+    if (!(0, external_instance_cjs_namespaceObject.isI18nInstance)(obj)) throw new Error('Object does not implement I18nInstance interface');
+}
+const buildInitOptions = async (finalLanguage, fallbackLanguage, languages, mergedDetection, mergedBackend, userInitOptions, useSuspense, i18nInstance)=>{
+    const defaultUseSuspense = void 0 !== useSuspense ? useSuspense : (0, runtime_namespaceObject.isBrowser)() ? userInitOptions?.react?.useSuspense ?? true : false;
+    const isChainedBackend = !!mergedBackend?._useChainedBackend;
+    const sanitizedUserInitOptions = userInitOptions ? {
+        ...userInitOptions,
+        backend: void 0
+    } : void 0;
+    const { backend: _removedBackend, ...userOptionsWithoutBackend } = sanitizedUserInitOptions || {};
+    const initOptions = {
+        lng: finalLanguage,
+        fallbackLng: fallbackLanguage,
+        supportedLngs: languages,
+        detection: mergedDetection,
+        initImmediate: sanitizedUserInitOptions?.initImmediate ?? true,
+        interpolation: {
+            ...sanitizedUserInitOptions?.interpolation || {},
+            escapeValue: sanitizedUserInitOptions?.interpolation?.escapeValue ?? false
+        },
+        react: {
+            ...sanitizedUserInitOptions?.react || {},
+            useSuspense: defaultUseSuspense
+        },
+        ...userOptionsWithoutBackend
+    };
+    if (mergedBackend) if (isChainedBackend && mergedBackend._chainedBackendConfig) {
+        let HttpBackend;
+        let SdkBackendClass;
+        if (i18nInstance?.options?.backend?.backends && Array.isArray(i18nInstance.options.backend.backends) && i18nInstance.options.backend.backends.length >= 2) {
+            HttpBackend = i18nInstance.options.backend.backends[0];
+            SdkBackendClass = i18nInstance.options.backend.backends[1];
+        } else {
+            HttpBackend = middleware_cjs_namespaceObject.HttpBackendWithSave;
+            SdkBackendClass = sdk_backend_cjs_namespaceObject.SdkBackend;
+        }
+        initOptions.backend = {
+            backends: [
+                HttpBackend,
+                SdkBackendClass
+            ],
+            backendOptions: mergedBackend._chainedBackendConfig.backendOptions,
+            cacheHitMode: mergedBackend.cacheHitMode || 'refreshAndUpdateStore'
+        };
+    } else {
+        const { _useChainedBackend, _chainedBackendConfig, ...cleanBackend } = mergedBackend || {};
+        initOptions.backend = cleanBackend;
+    }
+    return initOptions;
+};
+const ensureLanguageMatch = async (i18nInstance, finalLanguage)=>{
+    if (i18nInstance.language !== finalLanguage) {
+        await i18nInstance.setLang?.(finalLanguage);
+        await i18nInstance.changeLanguage?.(finalLanguage);
+    }
+};
+const changeI18nLanguage = async (i18nInstance, newLang, options)=>{
+    if (!newLang || 'string' != typeof newLang) throw new Error('Language must be a non-empty string');
+    if (!i18nInstance) throw new Error('i18nInstance is required');
+    await i18nInstance.setLang?.(newLang);
+    await i18nInstance.changeLanguage?.(newLang);
+    if ((0, runtime_namespaceObject.isBrowser)()) {
+        const detectionOptions = options?.detectionOptions || i18nInstance.options?.detection;
+        (0, external_detection_index_cjs_namespaceObject.cacheUserLanguage)(i18nInstance, newLang, detectionOptions);
+    }
+};
+const initializeI18nInstance = async (i18nInstance, finalLanguage, fallbackLanguage, languages, mergedDetection, mergedBackend, userInitOptions, useSuspense)=>{
+    if (!i18nInstance.isInitialized) {
+        const initOptions = await buildInitOptions(finalLanguage, fallbackLanguage, languages, mergedDetection, mergedBackend, userInitOptions, useSuspense, i18nInstance);
+        const actualInstance = (0, external_instance_cjs_namespaceObject.getActualI18nextInstance)(i18nInstance);
+        const savedBackendConfig = actualInstance?.options?.backend || i18nInstance.options?.backend;
+        const isChainedBackendFromSaved = savedBackendConfig?.backends && Array.isArray(savedBackendConfig.backends);
+        await i18nInstance.init(initOptions);
+        if (mergedBackend) {
+            if ((0, external_instance_cjs_namespaceObject.isI18nWrapperInstance)(i18nInstance) && actualInstance?.options) {
+                if (isChainedBackendFromSaved && initOptions.backend) actualInstance.options.backend = {
+                    ...initOptions.backend,
+                    backends: savedBackendConfig.backends
+                };
+                else if (initOptions.backend) actualInstance.options.backend = {
+                    ...actualInstance.options.backend,
+                    ...initOptions.backend
+                };
+            }
+            if (hasOptions(i18nInstance)) {
+                if (isChainedBackendFromSaved && initOptions.backend) i18nInstance.options.backend = {
+                    ...initOptions.backend,
+                    backends: savedBackendConfig.backends
+                };
+                else if (initOptions.backend) i18nInstance.options.backend = {
+                    ...i18nInstance.options.backend,
+                    ...initOptions.backend
+                };
+            }
+        }
+        if (mergedBackend && hasOptions(i18nInstance)) {
+            const defaultNS = initOptions.defaultNS || initOptions.ns || 'translation';
+            const ns = Array.isArray(defaultNS) ? defaultNS[0] : defaultNS;
+            let retries = 20;
+            while(retries > 0){
+                const actualInstance = (0, external_instance_cjs_namespaceObject.getActualI18nextInstance)(i18nInstance);
+                const store = actualInstance.store;
+                if (store?.data?.[finalLanguage]?.[ns]) break;
+                await new Promise((resolve)=>setTimeout(resolve, 100));
+                retries--;
+            }
+        }
+    }
+};
+function hasOptions(instance) {
+    return void 0 !== instance.options && null !== instance.options;
+}
+const setupClonedInstance = async (i18nInstance, finalLanguage, fallbackLanguage, languages, backendEnabled, backend, i18nextDetector, detection, localePathRedirect, userInitOptions)=>{
+    const mergedBackend = (0, index_cjs_namespaceObject.mergeBackendOptions)(backend, userInitOptions);
+    const hasSdkConfig = 'function' == typeof userInitOptions?.backend?.sdk || mergedBackend?.sdk && 'function' == typeof mergedBackend.sdk;
+    if (backendEnabled || hasSdkConfig) {
+        (0, middleware_cjs_namespaceObject.useI18nextBackend)(i18nInstance, mergedBackend);
+        if (mergedBackend && hasOptions(i18nInstance)) i18nInstance.options.backend = {
+            ...i18nInstance.options.backend,
+            ...mergedBackend
+        };
+        if (i18nInstance.isInitialized) await ensureLanguageMatch(i18nInstance, finalLanguage);
+        else {
+            const mergedDetection = (0, external_detection_index_cjs_namespaceObject.mergeDetectionOptions)(i18nextDetector, detection, localePathRedirect, userInitOptions);
+            await initializeI18nInstance(i18nInstance, finalLanguage, fallbackLanguage, languages, mergedDetection, mergedBackend, userInitOptions, false);
+        }
+    } else await ensureLanguageMatch(i18nInstance, finalLanguage);
+};
+exports.assertI18nInstance = __webpack_exports__.assertI18nInstance;
+exports.buildInitOptions = __webpack_exports__.buildInitOptions;
+exports.changeI18nLanguage = __webpack_exports__.changeI18nLanguage;
+exports.ensureLanguageMatch = __webpack_exports__.ensureLanguageMatch;
+exports.initializeI18nInstance = __webpack_exports__.initializeI18nInstance;
+exports.setupClonedInstance = __webpack_exports__.setupClonedInstance;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "assertI18nInstance",
+    "buildInitOptions",
+    "changeI18nLanguage",
+    "ensureLanguageMatch",
+    "initializeI18nInstance",
+    "setupClonedInstance"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/index.cjs

@@ -0,0 +1,162 @@
+"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__, {
+    I18nLink: ()=>external_I18nLink_cjs_namespaceObject.I18nLink,
+    default: ()=>runtime,
+    useModernI18n: ()=>external_context_cjs_namespaceObject.useModernI18n,
+    i18nPlugin: ()=>i18nPlugin
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const runtime_namespaceObject = require("@modern-js/runtime");
+const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
+const external_react_namespaceObject = require("react");
+const external_context_cjs_namespaceObject = require("./context.cjs");
+const external_hooks_cjs_namespaceObject = require("./hooks.cjs");
+const index_cjs_namespaceObject = require("./i18n/index.cjs");
+const backend_index_cjs_namespaceObject = require("./i18n/backend/index.cjs");
+const middleware_cjs_namespaceObject = require("./i18n/backend/middleware.cjs");
+const detection_index_cjs_namespaceObject = require("./i18n/detection/index.cjs");
+const detection_middleware_cjs_namespaceObject = require("./i18n/detection/middleware.cjs");
+const instance_cjs_namespaceObject = require("./i18n/instance.cjs");
+const utils_cjs_namespaceObject = require("./i18n/utils.cjs");
+const external_utils_cjs_namespaceObject = require("./utils.cjs");
+require("./types.cjs");
+const external_I18nLink_cjs_namespaceObject = require("./I18nLink.cjs");
+const i18nPlugin = (options)=>({
+        name: '@modern-js/plugin-i18n',
+        setup: (api)=>{
+            const { entryName, i18nInstance: userI18nInstance, initOptions, localeDetection, backend } = options;
+            const { localePathRedirect = false, i18nextDetector = true, languages = [], fallbackLanguage = 'en', detection, ignoreRedirectRoutes } = localeDetection || {};
+            const { enabled: backendEnabled = false } = backend || {};
+            let I18nextProvider;
+            api.onBeforeRender(async (context)=>{
+                let i18nInstance = await (0, index_cjs_namespaceObject.getI18nInstance)(userI18nInstance);
+                const { i18n: otherConfig } = api.getRuntimeConfig();
+                const { initOptions: otherInitOptions } = otherConfig || {};
+                const userInitOptions = (0, merge_namespaceObject.merge)(otherInitOptions || {}, initOptions || {});
+                const initReactI18next = await (0, instance_cjs_namespaceObject.getInitReactI18next)();
+                I18nextProvider = await (0, instance_cjs_namespaceObject.getI18nextProvider)();
+                if (initReactI18next) i18nInstance.use(initReactI18next);
+                const pathname = (0, external_utils_cjs_namespaceObject.getPathname)(context);
+                if (i18nextDetector) (0, detection_middleware_cjs_namespaceObject.useI18nextLanguageDetector)(i18nInstance);
+                const mergedDetection = (0, detection_index_cjs_namespaceObject.mergeDetectionOptions)(i18nextDetector, detection, localePathRedirect, userInitOptions);
+                const mergedBackend = (0, backend_index_cjs_namespaceObject.mergeBackendOptions)(backend, userInitOptions);
+                const hasSdkConfig = 'function' == typeof userInitOptions?.backend?.sdk || mergedBackend?.sdk && 'function' == typeof mergedBackend.sdk;
+                if (mergedBackend && (backendEnabled || hasSdkConfig)) (0, middleware_cjs_namespaceObject.useI18nextBackend)(i18nInstance, mergedBackend);
+                const { finalLanguage } = await (0, detection_index_cjs_namespaceObject.detectLanguageWithPriority)(i18nInstance, {
+                    languages,
+                    fallbackLanguage,
+                    localePathRedirect,
+                    i18nextDetector,
+                    detection,
+                    userInitOptions,
+                    mergedBackend,
+                    pathname,
+                    ssrContext: context.ssrContext
+                });
+                await (0, utils_cjs_namespaceObject.initializeI18nInstance)(i18nInstance, finalLanguage, fallbackLanguage, languages, mergedDetection, mergedBackend, userInitOptions);
+                if (!(0, runtime_namespaceObject.isBrowser)() && i18nInstance.cloneInstance) {
+                    i18nInstance = i18nInstance.cloneInstance();
+                    await (0, utils_cjs_namespaceObject.setupClonedInstance)(i18nInstance, finalLanguage, fallbackLanguage, languages, backendEnabled, backend, i18nextDetector, detection, localePathRedirect, userInitOptions);
+                }
+                if (localePathRedirect) await (0, utils_cjs_namespaceObject.ensureLanguageMatch)(i18nInstance, finalLanguage);
+                if (!(0, runtime_namespaceObject.isBrowser)()) (0, detection_index_cjs_namespaceObject.exportServerLngToWindow)(context, finalLanguage);
+                context.i18nInstance = i18nInstance;
+                context.changeLanguage = async (newLang)=>{
+                    await (0, utils_cjs_namespaceObject.changeI18nLanguage)(i18nInstance, newLang, {
+                        detectionOptions: mergedDetection
+                    });
+                };
+            });
+            api.wrapRoot((App)=>(props)=>{
+                    const runtimeContext = (0, runtime_namespaceObject.useRuntimeContext)();
+                    const i18nInstance = runtimeContext.i18nInstance;
+                    const initialLang = (0, external_react_namespaceObject.useMemo)(()=>i18nInstance?.language || (localeDetection?.fallbackLanguage ?? 'en'), [
+                        i18nInstance?.language,
+                        localeDetection?.fallbackLanguage
+                    ]);
+                    const [lang, setLang] = (0, external_react_namespaceObject.useState)(initialLang);
+                    const [forceUpdate, setForceUpdate] = (0, external_react_namespaceObject.useState)(0);
+                    const prevLangRef = (0, external_react_namespaceObject.useRef)(lang);
+                    const runtimeContextRef = (0, external_react_namespaceObject.useRef)(runtimeContext);
+                    runtimeContextRef.current = runtimeContext;
+                    (0, external_react_namespaceObject.useEffect)(()=>{
+                        if (i18nInstance?.language) {
+                            const translator = i18nInstance.translator;
+                            if (translator) translator.language = i18nInstance.language;
+                        }
+                    }, [
+                        i18nInstance?.language
+                    ]);
+                    (0, external_react_namespaceObject.useEffect)(()=>{
+                        prevLangRef.current = lang;
+                    }, [
+                        lang
+                    ]);
+                    (0, external_hooks_cjs_namespaceObject.useSdkResourcesLoader)(i18nInstance, setForceUpdate);
+                    (0, external_hooks_cjs_namespaceObject.useLanguageSync)(i18nInstance, localePathRedirect, languages, runtimeContextRef, prevLangRef, setLang);
+                    (0, external_hooks_cjs_namespaceObject.useClientSideRedirect)(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes);
+                    const contextValue = (0, external_react_namespaceObject.useMemo)(()=>(0, external_hooks_cjs_namespaceObject.createContextValue)(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, setLang), [
+                        lang,
+                        i18nInstance,
+                        entryName,
+                        languages,
+                        localePathRedirect,
+                        ignoreRedirectRoutes,
+                        forceUpdate
+                    ]);
+                    const appContent = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_context_cjs_namespaceObject.ModernI18nProvider, {
+                        value: contextValue,
+                        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
+                            ...props
+                        })
+                    });
+                    if (!i18nInstance) return appContent;
+                    if (I18nextProvider) {
+                        const i18nextInstanceForProvider = (0, instance_cjs_namespaceObject.getI18nextInstanceForProvider)(i18nInstance);
+                        return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(I18nextProvider, {
+                            i18n: i18nextInstanceForProvider,
+                            children: appContent
+                        });
+                    }
+                    return appContent;
+                });
+        }
+    });
+const runtime = i18nPlugin;
+exports.I18nLink = __webpack_exports__.I18nLink;
+exports["default"] = __webpack_exports__["default"];
+exports.i18nPlugin = __webpack_exports__.i18nPlugin;
+exports.useModernI18n = __webpack_exports__.useModernI18n;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "I18nLink",
+    "default",
+    "i18nPlugin",
+    "useModernI18n"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/types.cjs

@@ -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
+});

package/dist/cjs/runtime/utils.cjs

@@ -0,0 +1,134 @@
+"use strict";
+var __webpack_modules__ = {
+    "@modern-js/runtime/router" (module) {
+        module.exports = require("@modern-js/runtime/router");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __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__, {
+        detectLanguageFromPath: ()=>detectLanguageFromPath,
+        getLanguageFromPath: ()=>getLanguageFromPath,
+        buildLocalizedUrl: ()=>buildLocalizedUrl,
+        getPathname: ()=>getPathname,
+        shouldIgnoreRedirect: ()=>shouldIgnoreRedirect,
+        useRouterHooks: ()=>useRouterHooks,
+        getEntryPath: ()=>getEntryPath
+    });
+    const runtime_namespaceObject = require("@modern-js/runtime");
+    const context_namespaceObject = require("@modern-js/runtime/context");
+    const getPathname = (context)=>{
+        if ((0, runtime_namespaceObject.isBrowser)()) return window.location.pathname;
+        return context.ssrContext?.request?.pathname || '/';
+    };
+    const getEntryPath = ()=>{
+        const basename = (0, context_namespaceObject.getGlobalBasename)();
+        if (basename) return '/' === basename ? '' : basename;
+        return '';
+    };
+    const getLanguageFromPath = (pathname, languages, fallbackLanguage)=>{
+        const segments = pathname.split('/').filter(Boolean);
+        const firstSegment = segments[0];
+        if (languages.includes(firstSegment)) return firstSegment;
+        return fallbackLanguage;
+    };
+    const buildLocalizedUrl = (pathname, language, languages)=>{
+        const segments = pathname.split('/').filter(Boolean);
+        if (segments.length > 0 && languages.includes(segments[0])) segments[0] = language;
+        else segments.unshift(language);
+        return `/${segments.join('/')}`;
+    };
+    const detectLanguageFromPath = (pathname, languages, localePathRedirect)=>{
+        if (!localePathRedirect) return {
+            detected: false
+        };
+        const relativePath = pathname.replace(getEntryPath(), '');
+        const segments = relativePath.split('/').filter(Boolean);
+        const firstSegment = segments[0];
+        if (firstSegment && languages.includes(firstSegment)) return {
+            detected: true,
+            language: firstSegment
+        };
+        return {
+            detected: false
+        };
+    };
+    const shouldIgnoreRedirect = (pathname, languages, ignoreRedirectRoutes)=>{
+        if (!ignoreRedirectRoutes) return false;
+        const segments = pathname.split('/').filter(Boolean);
+        let pathWithoutLang = pathname;
+        if (segments.length > 0 && languages.includes(segments[0])) pathWithoutLang = `/${segments.slice(1).join('/')}`;
+        const normalizedPath = pathWithoutLang.startsWith('/') ? pathWithoutLang : `/${pathWithoutLang}`;
+        if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(normalizedPath);
+        return ignoreRedirectRoutes.some((pattern)=>normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`));
+    };
+    const useRouterHooks = ()=>{
+        try {
+            const { useLocation, useNavigate, useParams } = __webpack_require__("@modern-js/runtime/router");
+            return {
+                navigate: useNavigate(),
+                location: useLocation(),
+                params: useParams(),
+                hasRouter: true
+            };
+        } catch (error) {
+            return {
+                navigate: null,
+                location: null,
+                params: {},
+                hasRouter: false
+            };
+        }
+    };
+})();
+exports.buildLocalizedUrl = __webpack_exports__.buildLocalizedUrl;
+exports.detectLanguageFromPath = __webpack_exports__.detectLanguageFromPath;
+exports.getEntryPath = __webpack_exports__.getEntryPath;
+exports.getLanguageFromPath = __webpack_exports__.getLanguageFromPath;
+exports.getPathname = __webpack_exports__.getPathname;
+exports.shouldIgnoreRedirect = __webpack_exports__.shouldIgnoreRedirect;
+exports.useRouterHooks = __webpack_exports__.useRouterHooks;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildLocalizedUrl",
+    "detectLanguageFromPath",
+    "getEntryPath",
+    "getLanguageFromPath",
+    "getPathname",
+    "shouldIgnoreRedirect",
+    "useRouterHooks"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});