@bleedingdev/modern-js-plugin-i18n 3.5.0-ultramodern.3 → 3.5.0-ultramodern.31

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

package/dist/cjs/runtime/linkHelpers.js

@@ -0,0 +1,148 @@
+"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 warnedTargets = new Set();
+const warnOnce = (key, message)=>{
+    if ('development' !== process.env.NODE_ENV || warnedTargets.has(key)) return;
+    warnedTargets.add(key);
+    console.warn(message);
+};
+const interpolateRouteParams = (pathname, params)=>{
+    if (!/[$:*{]/.test(pathname)) return pathname;
+    const resolveParam = (name)=>{
+        const value = params?.[name];
+        return void 0 === value ? void 0 : String(value);
+    };
+    const segments = pathname.split('/').map((segment)=>{
+        if (!segment) return segment;
+        if (segment.startsWith('{-$') && segment.endsWith('}')) {
+            const value = resolveParam(segment.slice(3, -1));
+            return void 0 === value ? null : encodeURIComponent(value);
+        }
+        if ('$' === segment || '*' === segment) {
+            const value = resolveParam('_splat') ?? resolveParam('*');
+            return void 0 === value ? null : value.split('/').map(encodeURIComponent).join('/');
+        }
+        if (segment.startsWith('$')) {
+            const value = resolveParam(segment.slice(1));
+            if (void 0 === value) {
+                warnOnce(`missing-param:${pathname}:${segment}`, `[plugin-i18n] <Link to="${pathname}"> is missing required param "${segment.slice(1)}".`);
+                return segment;
+            }
+            return encodeURIComponent(value);
+        }
+        if (segment.startsWith(':')) {
+            const optional = segment.endsWith('?');
+            const name = segment.slice(1, optional ? -1 : void 0);
+            const value = resolveParam(name);
+            if (void 0 === value) {
+                if (optional) return null;
+                warnOnce(`missing-param:${pathname}:${segment}`, `[plugin-i18n] <Link to="${pathname}"> is missing required param "${name}".`);
+                return segment;
+            }
+            return encodeURIComponent(value);
+        }
+        return segment;
+    }).filter((segment)=>null !== segment);
+    return segments.join('/') || '/';
+};
+const normalizeSearch = (search, searchFromTo)=>{
+    if (search && 'object' == typeof search) {
+        const searchObject = {};
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(search)){
+            if (null == value) continue;
+            if (Array.isArray(value)) {
+                const values = value.filter((item)=>null != item).map(String);
+                if (0 === values.length) continue;
+                searchObject[key] = values;
+                for (const item of values)params.append(key, item);
+                continue;
+            }
+            const stringValue = String(value);
+            searchObject[key] = stringValue;
+            params.append(key, stringValue);
+        }
+        const serialized = params.toString();
+        return {
+            searchString: serialized ? `?${serialized}` : '',
+            searchObject: Object.keys(searchObject).length > 0 ? searchObject : void 0
+        };
+    }
+    const raw = 'string' == typeof search ? search : searchFromTo;
+    if (!raw) return {
+        searchString: '',
+        searchObject: void 0
+    };
+    const searchString = raw.startsWith('?') ? raw : `?${raw}`;
+    const searchObject = {};
+    new URLSearchParams(searchString).forEach((value, key)=>{
+        const existing = searchObject[key];
+        if (void 0 === existing) searchObject[key] = value;
+        else if (Array.isArray(existing)) existing.push(value);
+        else searchObject[key] = [
+            existing,
+            value
+        ];
+    });
+    return {
+        searchString,
+        searchObject
+    };
+};
+const splitActiveProps = (active, activeProps)=>{
+    if (!active || !activeProps) return {};
+    return activeProps;
+};
+const mergeClassNames = (...values)=>{
+    const classNames = values.filter((value)=>'string' == typeof value && value.length > 0);
+    return classNames.length > 0 ? classNames.join(' ') : void 0;
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    interpolateRouteParams: interpolateRouteParams,
+    mergeClassNames: mergeClassNames,
+    normalizeSearch: normalizeSearch,
+    splitActiveProps: splitActiveProps,
+    warnOnce: warnOnce
+});
+exports.interpolateRouteParams = __webpack_exports__.interpolateRouteParams;
+exports.mergeClassNames = __webpack_exports__.mergeClassNames;
+exports.normalizeSearch = __webpack_exports__.normalizeSearch;
+exports.splitActiveProps = __webpack_exports__.splitActiveProps;
+exports.warnOnce = __webpack_exports__.warnOnce;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "interpolateRouteParams",
+    "mergeClassNames",
+    "normalizeSearch",
+    "splitActiveProps",
+    "warnOnce"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/pluginSetup.js

@@ -0,0 +1,102 @@
+"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__, {
+    setupI18nBeforeRender: ()=>setupI18nBeforeRender
+});
+const runtime_namespaceObject = require("@modern-js/runtime");
+const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
+const index_js_namespaceObject = require("./i18n/index.js");
+const backend_index_js_namespaceObject = require("./i18n/backend/index.js");
+const detection_index_js_namespaceObject = require("./i18n/detection/index.js");
+const middleware_js_namespaceObject = require("./i18n/detection/middleware.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+let i18nLifecycleHelpersPromise;
+function loadI18nLifecycleHelpers() {
+    i18nLifecycleHelpersPromise ??= Promise.all([
+        import("./i18n/backend/middleware.js"),
+        import("./i18n/utils.js")
+    ]).then(([backendMiddleware, utils])=>({
+            useI18nextBackend: backendMiddleware.useI18nextBackend,
+            changeI18nLanguage: utils.changeI18nLanguage,
+            ensureLanguageMatch: utils.ensureLanguageMatch,
+            initializeI18nInstance: utils.initializeI18nInstance,
+            setupClonedInstance: utils.setupClonedInstance
+        }));
+    return i18nLifecycleHelpersPromise;
+}
+async function setupI18nBeforeRender(context, options) {
+    const { api, userI18nInstance, initOptions, backend, backendEnabled, i18nextDetector, detection, localePathRedirect, languages, fallbackLanguage, resolveReactI18nextIntegration, setI18nextProvider } = options;
+    const { useI18nextBackend, changeI18nLanguage, ensureLanguageMatch, initializeI18nInstance, setupClonedInstance } = await loadI18nLifecycleHelpers();
+    let i18nInstance = await (0, index_js_namespaceObject.getI18nInstance)(userI18nInstance);
+    const { i18n: otherConfig } = api.getRuntimeConfig();
+    const { initOptions: otherInitOptions } = otherConfig || {};
+    const userInitOptions = (0, merge_namespaceObject.merge)(otherInitOptions || {}, initOptions || {});
+    const reactI18nextIntegration = await resolveReactI18nextIntegration();
+    setI18nextProvider(reactI18nextIntegration?.I18nextProvider ?? null);
+    if (reactI18nextIntegration?.initReactI18next) i18nInstance.use(reactI18nextIntegration.initReactI18next);
+    const pathname = (0, external_utils_js_namespaceObject.getPathname)(context);
+    if (i18nextDetector) (0, middleware_js_namespaceObject.useI18nextLanguageDetector)(i18nInstance);
+    const mergedDetection = (0, detection_index_js_namespaceObject.mergeDetectionOptions)(i18nextDetector, detection, localePathRedirect, userInitOptions);
+    const mergedBackend = (0, backend_index_js_namespaceObject.mergeBackendOptions)(backend, userInitOptions);
+    const hasSdkConfig = 'function' == typeof userInitOptions?.backend?.sdk || mergedBackend?.sdk && 'function' == typeof mergedBackend.sdk;
+    if (mergedBackend && (backendEnabled || hasSdkConfig)) useI18nextBackend(i18nInstance, mergedBackend);
+    const { finalLanguage } = await (0, detection_index_js_namespaceObject.detectLanguageWithPriority)(i18nInstance, {
+        languages,
+        fallbackLanguage,
+        localePathRedirect,
+        i18nextDetector,
+        detection,
+        userInitOptions,
+        mergedBackend,
+        pathname,
+        ssrContext: context.ssrContext
+    });
+    await initializeI18nInstance(i18nInstance, finalLanguage, fallbackLanguage, languages, mergedDetection, mergedBackend, userInitOptions);
+    if (!(0, runtime_namespaceObject.isBrowser)() && i18nInstance.cloneInstance) {
+        i18nInstance = i18nInstance.cloneInstance();
+        await setupClonedInstance(i18nInstance, finalLanguage, fallbackLanguage, languages, backendEnabled, backend, i18nextDetector, detection, localePathRedirect, userInitOptions);
+    }
+    if (localePathRedirect) await ensureLanguageMatch(i18nInstance, finalLanguage);
+    if (!(0, runtime_namespaceObject.isBrowser)()) (0, detection_index_js_namespaceObject.exportServerLngToWindow)(context, finalLanguage);
+    context.i18nInstance = i18nInstance;
+    context.changeLanguage = async (newLang)=>{
+        await changeI18nLanguage(i18nInstance, newLang, {
+            detectionOptions: mergedDetection
+        });
+    };
+    return i18nInstance;
+}
+exports.setupI18nBeforeRender = __webpack_exports__.setupI18nBeforeRender;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "setupI18nBeforeRender"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/providerComposition.js

@@ -0,0 +1,113 @@
+"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__, {
+    createI18nRootWrapper: ()=>createI18nRootWrapper
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const runtime_namespaceObject = require("@modern-js/runtime");
+const head_namespaceObject = require("@modern-js/runtime/head");
+const external_react_namespaceObject = require("react");
+const external_context_js_namespaceObject = require("./context.js");
+const external_hooks_js_namespaceObject = require("./hooks.js");
+const instance_js_namespaceObject = require("./i18n/instance.js");
+const createI18nRootWrapper = (options)=>(App)=>(props)=>{
+            const { entryName, htmlLangAttr, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls, getLatestI18nInstance, getI18nextProvider } = options;
+            const runtimeContext = (0, external_react_namespaceObject.useContext)(runtime_namespaceObject.RuntimeContext);
+            const i18nInstance = runtimeContext.i18nInstance || getLatestI18nInstance();
+            const initialLang = (0, external_react_namespaceObject.useMemo)(()=>i18nInstance?.language || fallbackLanguage, [
+                i18nInstance?.language,
+                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_js_namespaceObject.useSdkResourcesLoader)(i18nInstance, setForceUpdate);
+            (0, external_hooks_js_namespaceObject.useLanguageSync)(i18nInstance, localePathRedirect, languages, runtimeContextRef, prevLangRef, setLang);
+            (0, external_hooks_js_namespaceObject.useClientSideRedirect)(i18nInstance, localePathRedirect, languages, fallbackLanguage, ignoreRedirectRoutes, localisedUrls);
+            const contextValue = (0, external_react_namespaceObject.useMemo)(()=>(0, external_hooks_js_namespaceObject.createContextValue)(lang, i18nInstance, entryName, languages, localePathRedirect, ignoreRedirectRoutes, localisedUrls, setLang), [
+                lang,
+                i18nInstance,
+                entryName,
+                languages,
+                localePathRedirect,
+                ignoreRedirectRoutes,
+                localisedUrls,
+                forceUpdate
+            ]);
+            const children = props.children;
+            const appContent = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsxs)(jsx_runtime_namespaceObject.Fragment, {
+                children: [
+                    Boolean(htmlLangAttr) && /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(head_namespaceObject.Helmet, {
+                        htmlAttributes: {
+                            lang
+                        }
+                    }),
+                    /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_context_js_namespaceObject.ModernI18nProvider, {
+                        value: contextValue,
+                        children: App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
+                            ...props,
+                            children: children
+                        }) : children
+                    })
+                ]
+            });
+            if (!i18nInstance) return appContent;
+            const I18nextProvider = getI18nextProvider();
+            if (I18nextProvider) {
+                const i18nextInstanceForProvider = (0, instance_js_namespaceObject.getI18nextInstanceForProvider)(i18nInstance);
+                return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(I18nextProvider, {
+                    i18n: i18nextInstanceForProvider,
+                    children: appContent
+                });
+            }
+            return appContent;
+        };
+exports.createI18nRootWrapper = __webpack_exports__.createI18nRootWrapper;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createI18nRootWrapper"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/reactI18next.js

@@ -0,0 +1,43 @@
+"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 resolveReactI18nextIntegration = async (reactI18next, loadReactI18nextIntegration)=>{
+    if (!reactI18next) return null;
+    return loadReactI18nextIntegration?.() ?? null;
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    resolveReactI18nextIntegration: resolveReactI18nextIntegration
+});
+exports.resolveReactI18nextIntegration = __webpack_exports__.resolveReactI18nextIntegration;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveReactI18nextIntegration"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});