@bleedingdev/modern-js-i18n-runtime-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.10

package/dist/cjs/index.js

@@ -9,8 +9,8 @@ var __webpack_modules__ = {
     "./localeRedirectPolicy" (module) {
         module.exports = require("./localeRedirectPolicy.js");
     },
-    "./localisedUrls/index" (module) {
-        module.exports = require("./localisedUrls/index.js");
+    "@modern-js/runtime-extensions/localised-urls" (module) {
+        module.exports = require("@modern-js/runtime-extensions/localised-urls");
     }
 };
 var __webpack_module_cache__ = {};
@@ -60,21 +60,21 @@ function __webpack_require__(moduleId) {
 var __webpack_exports__ = {};
 (()=>{
     __webpack_require__.r(__webpack_exports__);
-    var _language_sync_controller__rspack_import_0 = __webpack_require__("./language-sync/controller");
+    var _modern_js_runtime_extensions_localised_urls__rspack_import_0 = __webpack_require__("@modern-js/runtime-extensions/localised-urls");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _language_sync_controller__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_language_sync_controller__rspack_import_0[__rspack_import_key];
+    for(const __rspack_import_key in _modern_js_runtime_extensions_localised_urls__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_modern_js_runtime_extensions_localised_urls__rspack_import_0[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _language_sync_react__rspack_import_1 = __webpack_require__("./language-sync/react");
+    var _language_sync_controller__rspack_import_1 = __webpack_require__("./language-sync/controller");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _language_sync_react__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_language_sync_react__rspack_import_1[__rspack_import_key];
+    for(const __rspack_import_key in _language_sync_controller__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_language_sync_controller__rspack_import_1[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _localeRedirectPolicy__rspack_import_2 = __webpack_require__("./localeRedirectPolicy");
+    var _language_sync_react__rspack_import_2 = __webpack_require__("./language-sync/react");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _localeRedirectPolicy__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_localeRedirectPolicy__rspack_import_2[__rspack_import_key];
+    for(const __rspack_import_key in _language_sync_react__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_language_sync_react__rspack_import_2[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _localisedUrls_index__rspack_import_3 = __webpack_require__("./localisedUrls/index");
+    var _localeRedirectPolicy__rspack_import_3 = __webpack_require__("./localeRedirectPolicy");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _localisedUrls_index__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_localisedUrls_index__rspack_import_3[__rspack_import_key];
+    for(const __rspack_import_key in _localeRedirectPolicy__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_localeRedirectPolicy__rspack_import_3[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
 })();
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/cjs/localeRedirectPolicy.js

@@ -34,7 +34,7 @@ __webpack_require__.d(__webpack_exports__, {
     isStaticResourceRequest: ()=>isStaticResourceRequest,
     shouldIgnoreRedirect: ()=>shouldIgnoreRedirect
 });
-const index_js_namespaceObject = require("./localisedUrls/index.js");
+const localised_urls_namespaceObject = require("@modern-js/runtime-extensions/localised-urls");
 const stripUrlPathPrefix = (pathname, urlPath)=>{
     const basePath = urlPath.replace('/*', '');
     if (!basePath || '/' === basePath) return pathname;
@@ -43,13 +43,13 @@ const stripUrlPathPrefix = (pathname, urlPath)=>{
 };
 const shouldIgnoreRedirect = (pathname, urlPath, ignoreRedirectRoutes)=>{
     const remainingPath = stripUrlPathPrefix(pathname, urlPath);
-    return (0, index_js_namespaceObject.shouldSkipLocaleRedirect)(remainingPath, [], ignoreRedirectRoutes);
+    return (0, localised_urls_namespaceObject.shouldSkipLocaleRedirect)(remainingPath, [], ignoreRedirectRoutes);
 };
 const isStaticResourceRequest = (pathname, staticRoutePrefixes, languages = [])=>{
-    if ((0, index_js_namespaceObject.isDefaultLocaleRedirectSkipPath)(pathname, languages)) return true;
-    const matchesStaticRoutePrefix = (targetPathname)=>staticRoutePrefixes.some((prefix)=>(0, index_js_namespaceObject.matchesPathPrefix)(targetPathname, prefix));
+    if ((0, localised_urls_namespaceObject.isDefaultLocaleRedirectSkipPath)(pathname, languages)) return true;
+    const matchesStaticRoutePrefix = (targetPathname)=>staticRoutePrefixes.some((prefix)=>(0, localised_urls_namespaceObject.matchesPathPrefix)(targetPathname, prefix));
     if (matchesStaticRoutePrefix(pathname)) return true;
-    const pathWithoutLanguage = (0, index_js_namespaceObject.stripLanguagePrefix)(pathname, languages);
+    const pathWithoutLanguage = (0, localised_urls_namespaceObject.stripLanguagePrefix)(pathname, languages);
     return pathWithoutLanguage !== pathname && matchesStaticRoutePrefix(pathWithoutLanguage);
 };
 const getLanguageFromPath = (req, urlPath, languages)=>{
@@ -66,7 +66,7 @@ const buildLocalizedUrl = (req, urlPath, language, languages, localisedUrls)=>{
     const pathname = url.pathname;
     const basePath = urlPath.replace('/*', '');
     const remainingPath = stripUrlPathPrefix(pathname, urlPath);
-    const newPathname = (0, index_js_namespaceObject.localiseTargetPathname)(remainingPath, language, languages, localisedUrls);
+    const newPathname = (0, localised_urls_namespaceObject.localiseTargetPathname)(remainingPath, language, languages, localisedUrls);
     const suffix = `${url.search}${url.hash}`;
     const localizedUrl = '/' === basePath ? newPathname + suffix : basePath + newPathname + suffix;
     return localizedUrl;

package/dist/cjs/native.js

@@ -0,0 +1,438 @@
+"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, 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__, {
+    createNativeI18n: ()=>createNativeI18n,
+    createNativeI18nInstance: ()=>createNativeI18nInstance,
+    getNativeI18nRewriteSnapshot: ()=>getNativeI18nRewriteSnapshot,
+    getNativeI18nSnapshotSeed: ()=>getNativeI18nSnapshotSeed,
+    invalidateNativeI18nSnapshot: ()=>invalidateNativeI18nSnapshot
+});
+const external_i18next_namespaceObject = require("i18next");
+var external_i18next_default = /*#__PURE__*/ __webpack_require__.n(external_i18next_namespaceObject);
+const controller_js_namespaceObject = require("./language-sync/controller.js");
+const external_requestLanguage_js_namespaceObject = require("./requestLanguage.js");
+const external_ssrLanguageHandoff_js_namespaceObject = require("./ssrLanguageHandoff.js");
+const external_urlRewrite_js_namespaceObject = require("./urlRewrite.js");
+const nativeSnapshotOrigins = new WeakMap();
+function invalidateNativeI18nSnapshot(instance) {
+    if ('object' == typeof instance && null !== instance) nativeSnapshotOrigins.delete(instance);
+}
+const nativeRewriteOrigins = new WeakMap();
+function getNativeI18nRewriteSnapshot(rewrite) {
+    return 'object' == typeof rewrite && null !== rewrite ? nativeRewriteOrigins.get(rewrite)?.() : void 0;
+}
+function detachLocalisedUrls(value) {
+    if (void 0 === value || 'boolean' == typeof value) return value;
+    return Object.fromEntries(Object.entries(value).map(([path, languages])=>[
+            path,
+            Object.fromEntries(Object.entries(languages))
+        ]));
+}
+function plainRecord(value) {
+    return 'object' == typeof value && null !== value && (Object.getPrototypeOf(value) === Object.prototype || null === Object.getPrototypeOf(value));
+}
+function detachOption(value, ancestors = new Set()) {
+    if (null === value || 'object' != typeof value) return value;
+    if (ancestors.has(value) || (Array.isArray(value) ? Object.getPrototypeOf(value) !== Array.prototype : !plainRecord(value))) throw new Error('Native i18n snapshot options must be plain acyclic data');
+    ancestors.add(value);
+    const copy = Array.isArray(value) ? [] : {};
+    for (const key of Reflect.ownKeys(value)){
+        if (Array.isArray(value) && 'length' === key) continue;
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if ('string' != typeof key || !descriptor || !('value' in descriptor)) throw new Error('Native i18n snapshot options cannot contain accessors');
+        Object.defineProperty(copy, key, {
+            value: detachOption(descriptor.value, ancestors),
+            enumerable: descriptor.enumerable,
+            writable: true,
+            configurable: true
+        });
+    }
+    ancestors.delete(value);
+    return copy;
+}
+function detachInitOptions(options) {
+    const copy = detachOption(options);
+    if (!plainRecord(copy)) throw new Error('Invalid native i18n options');
+    return copy;
+}
+function descriptorProof(object, ignore = new Set(), ancestors = new Set()) {
+    if (ancestors.has(object)) return ()=>true;
+    ancestors.add(object);
+    const keys = Reflect.ownKeys(object).filter((key)=>'string' != typeof key || !ignore.has(key));
+    const proofs = keys.map((key)=>{
+        const descriptor = Object.getOwnPropertyDescriptor(object, key);
+        if (!descriptor || !('value' in descriptor)) throw new Error('Native i18n snapshot provenance cannot contain accessors');
+        const value = descriptor.value;
+        const nested = Array.isArray(value) || plainRecord(value) ? descriptorProof(value, new Set(), ancestors) : ()=>true;
+        return ()=>{
+            const current = Object.getOwnPropertyDescriptor(object, key);
+            return void 0 !== current && 'value' in current && current.value === value && current.enumerable === descriptor.enumerable && current.configurable === descriptor.configurable && current.writable === descriptor.writable && nested();
+        };
+    });
+    ancestors.delete(object);
+    return ()=>{
+        const currentKeys = Reflect.ownKeys(object).filter((key)=>'string' != typeof key || !ignore.has(key));
+        return currentKeys.length === keys.length && currentKeys.every((key, index)=>key === keys[index]) && proofs.every((proof)=>proof());
+    };
+}
+function methodProof(object) {
+    const prototype = Object.getPrototypeOf(object);
+    const methods = new Map();
+    for(let current = object; current && current !== Object.prototype; current = Object.getPrototypeOf(current))for (const key of Reflect.ownKeys(current)){
+        const descriptor = Object.getOwnPropertyDescriptor(current, key);
+        if (descriptor && 'value' in descriptor) {
+            if ('function' == typeof descriptor.value && !methods.has(key)) methods.set(key, descriptor.value);
+        }
+    }
+    return ()=>{
+        if (Object.getPrototypeOf(object) !== prototype) return false;
+        for (const [key, method] of methods){
+            let current = object;
+            while(current){
+                const descriptor = Object.getOwnPropertyDescriptor(current, key);
+                if (descriptor) {
+                    if (!('value' in descriptor) || descriptor.value !== method) return false;
+                    break;
+                }
+                current = Object.getPrototypeOf(current);
+            }
+            if (!current) return false;
+        }
+        return true;
+    };
+}
+function ownValue(object, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(object, key);
+    if (descriptor && !('value' in descriptor)) throw new Error('Native i18n snapshot provenance cannot contain accessors');
+    return descriptor?.value;
+}
+function semanticProof(object, fields) {
+    const proofs = fields.map((key)=>{
+        const value = ownValue(object, key);
+        const nested = Array.isArray(value) || plainRecord(value) ? descriptorProof(value, new Set([
+            'resources'
+        ])) : ()=>true;
+        if (value instanceof RegExp) {
+            const source = value.source;
+            const flags = value.flags;
+            return ()=>{
+                const current = ownValue(object, key);
+                return current instanceof RegExp && current.source === source && current.flags === flags;
+            };
+        }
+        return ()=>ownValue(object, key) === value && nested();
+    });
+    return ()=>proofs.every((proof)=>proof());
+}
+function recordNativeSnapshotOrigin(instance, original, seed) {
+    try {
+        const useDescriptor = Object.getOwnPropertyDescriptor(instance, 'use');
+        if (!useDescriptor || !('value' in useDescriptor)) throw new Error('Native plugin registration requires an own method');
+        const use = instance.use;
+        Object.defineProperty(instance, 'use', {
+            ...useDescriptor,
+            value: function(plugin) {
+                invalidateNativeI18nSnapshot(instance);
+                return use(plugin);
+            }
+        });
+        const services = instance.services;
+        const store = instance.store;
+        const options = instance.options;
+        const modules = instance.modules;
+        const translator = Object.getOwnPropertyDescriptor(instance, 'translator')?.value;
+        const formatter = instance.services.formatter;
+        const formats = formatter && 'object' == typeof formatter ? Object.getOwnPropertyDescriptor(formatter, 'formats')?.value : void 0;
+        const proofs = [
+            descriptorProof(instance.options, new Set([
+                'resources'
+            ])),
+            descriptorProof(instance.modules),
+            descriptorProof(services),
+            methodProof(instance),
+            methodProof(instance.store),
+            ...Object.values(instance.services).filter((value)=>'object' == typeof value && null !== value).map((value)=>methodProof(value)),
+            ...translator && 'object' == typeof translator ? [
+                methodProof(translator)
+            ] : [],
+            ...formats && 'object' == typeof formats ? [
+                descriptorProof(formats)
+            ] : []
+        ];
+        const serviceFields = {
+            languageUtils: [
+                'options',
+                'supportedLngs'
+            ],
+            pluralResolver: [
+                'languageUtils',
+                'options'
+            ],
+            interpolator: [
+                'options',
+                'escape',
+                'escapeValue',
+                'useRawValueToEscape',
+                'prefix',
+                'suffix',
+                'format',
+                'formatSeparator',
+                'unescapePrefix',
+                'unescapeSuffix',
+                'nestingPrefix',
+                'nestingSuffix',
+                'nestingOptionsSeparator',
+                'maxReplaces',
+                'alwaysFormat',
+                'regexp',
+                'regexpUnescape',
+                'nestingRegexp'
+            ],
+            formatter: [
+                'formatSeparator'
+            ],
+            resourceStore: [
+                'options'
+            ],
+            backendConnector: [
+                'backend',
+                'store',
+                'services',
+                'options'
+            ]
+        };
+        const links = Object.entries(instance.services).map(([key, value])=>{
+            if ('object' == typeof value && null !== value) proofs.push(semanticProof(value, serviceFields[key] ?? []));
+            return ()=>ownValue(services, key) === value;
+        });
+        if (translator && 'object' == typeof translator) proofs.push(semanticProof(translator, [
+            'options',
+            'resourceStore',
+            'languageUtils',
+            'pluralResolver',
+            'interpolator',
+            'backendConnector',
+            'i18nFormat',
+            'utils'
+        ]));
+        nativeSnapshotOrigins.set(instance, {
+            instance,
+            original: detachInitOptions(original),
+            seed: detachInitOptions(seed),
+            unchanged: ()=>ownValue(instance, 'services') === services && ownValue(instance, 'store') === store && ownValue(instance, 'options') === options && ownValue(instance, 'modules') === modules && ownValue(services, 'formatter') === formatter && (formatter && 'object' == typeof formatter ? ownValue(formatter, 'formats') === formats : true) && Object.getOwnPropertyDescriptor(instance, 'translator')?.value === translator && (translator && 'object' == typeof translator ? ownValue(translator, 'language') === ownValue(instance, 'language') : true) && links.every((proof)=>proof()) && proofs.every((proof)=>proof())
+        });
+    } catch  {}
+}
+function createNativeI18nInstance(initOptions) {
+    const original = detachInitOptions(initOptions);
+    const seed = {
+        ...detachInitOptions(original),
+        initAsync: false,
+        partialBundledLanguages: false,
+        interpolation: {
+            escapeValue: false,
+            ...original.interpolation
+        }
+    };
+    const instance = external_i18next_default().createInstance();
+    instance.init(detachInitOptions(seed));
+    if (!instance.isInitialized || instance.isInitializing) throw new Error('Native i18n instances require complete bundled resources');
+    recordNativeSnapshotOrigin(instance, original, seed);
+    return instance;
+}
+function getNativeI18nSnapshotSeed(instance) {
+    const origin = 'object' == typeof instance && null !== instance ? nativeSnapshotOrigins.get(instance) : void 0;
+    const services = origin ? ownValue(origin.instance, 'services') : void 0;
+    const connector = services && 'object' == typeof services ? ownValue(services, 'backendConnector') : void 0;
+    const state = connector && 'object' == typeof connector ? ownValue(connector, 'state') : void 0;
+    const pending = plainRecord(state) && Object.values(Object.getOwnPropertyDescriptors(state)).some((descriptor)=>!('value' in descriptor) || 1 === descriptor.value);
+    if (!origin || true !== ownValue(origin.instance, 'isInitialized') || true === ownValue(origin.instance, 'isInitializing') || ownValue(origin.instance, 'isLanguageChangingTo') || pending || !origin.unchanged()) throw new Error('This i18n instance requires an explicit Worker profile');
+    return detachInitOptions(origin.seed);
+}
+function unwrapResource(module) {
+    const resource = 'object' == typeof module && null !== module && 'default' in module ? module.default : module;
+    return resource;
+}
+function createNativeI18n(options, loaders) {
+    const { initOptions = {}, ...routing } = options;
+    const namespaces = [
+        ...new Set(Object.values(loaders).flatMap(Object.keys))
+    ].sort();
+    const defaultNamespace = 'string' == typeof initOptions.defaultNS ? initOptions.defaultNS : namespaces.includes('translation') ? 'translation' : namespaces[0] ?? 'translation';
+    const cookie = routing.detection?.lookupCookie ?? 'i18next';
+    const backend = {
+        type: 'backend',
+        init () {},
+        read (language, namespace, callback) {
+            const bundles = Object.hasOwn(loaders, language) ? loaders[language] : void 0;
+            const load = bundles && Object.hasOwn(bundles, namespace) ? bundles[namespace] : void 0;
+            if (!load) return void callback(null, {});
+            load().then((module)=>callback(null, unwrapResource(module)), (error)=>callback(error, false));
+        }
+    };
+    const currentLanguage = ()=>(0, external_requestLanguage_js_namespaceObject.languageFromPathname)(window.location.pathname, routing.languages, routing.basePath);
+    return {
+        languages: routing.languages,
+        ...void 0 === routing.localisedUrls ? {} : {
+            localisedUrls: routing.localisedUrls
+        },
+        resolveRequest: (request)=>(0, external_requestLanguage_js_namespaceObject.resolveRequestLanguage)(request, routing),
+        redirect: external_requestLanguage_js_namespaceObject.createRequestLanguageRedirect,
+        async create (language, resources) {
+            const instance = external_i18next_default().createInstance();
+            instance.use(backend);
+            const seed = {
+                ...initOptions,
+                lng: language,
+                fallbackLng: routing.fallbackLanguage,
+                supportedLngs: [
+                    ...routing.languages
+                ],
+                ns: namespaces,
+                defaultNS: defaultNamespace,
+                partialBundledLanguages: true,
+                resources: resources ? {
+                    [language]: resources
+                } : {},
+                interpolation: {
+                    escapeValue: false,
+                    ...initOptions.interpolation
+                }
+            };
+            let original;
+            let detachedSeed;
+            try {
+                original = detachInitOptions(initOptions);
+                detachedSeed = detachInitOptions(seed);
+            } catch  {}
+            await instance.init(seed);
+            if (original && detachedSeed) recordNativeSnapshotOrigin(instance, original, detachedSeed);
+            return instance;
+        },
+        rewrite: (getLanguage)=>{
+            const languages = [
+                ...routing.languages
+            ];
+            const localisedUrls = detachLocalisedUrls(routing.localisedUrls);
+            const rewrite = (0, external_urlRewrite_js_namespaceObject.createI18nUrlRewrite)({
+                languages,
+                getLanguage,
+                localisedUrls
+            });
+            const unchanged = descriptorProof(rewrite);
+            nativeRewriteOrigins.set(rewrite, ()=>{
+                if (!unchanged()) throw new Error('Native i18n rewrite was modified');
+                const language = getLanguage();
+                if (!languages.includes(language)) throw new Error('Native i18n rewrite language is unsupported');
+                return {
+                    language,
+                    languages: [
+                        ...languages
+                    ],
+                    ...void 0 === localisedUrls ? {} : {
+                        localisedUrls: detachLocalisedUrls(localisedUrls)
+                    }
+                };
+            });
+            return rewrite;
+        },
+        handoff (language, instance) {
+            return (0, external_ssrLanguageHandoff_js_namespaceObject.createI18nSsrHandoffInlineData)({
+                language,
+                ...instance ? {
+                    resources: Object.fromEntries(namespaces.map((namespace)=>[
+                            namespace,
+                            instance.getResourceBundle(language, namespace) ?? {}
+                        ]))
+                } : {}
+            });
+        },
+        clientHandoff () {
+            const handoff = (0, external_ssrLanguageHandoff_js_namespaceObject.readI18nSsrHandoff)();
+            if (handoff && routing.languages.includes(handoff.language)) return handoff;
+            return {
+                language: currentLanguage() ?? routing.fallbackLanguage
+            };
+        },
+        syncWithRouter (router, instance) {
+            const sync = (0, controller_js_namespaceObject.createLatestLanguageSyncBinding)();
+            sync.updateCallbacks({
+                changeLanguage: (target, language)=>target.changeLanguage(language),
+                commitLanguage () {},
+                readLanguage: (target)=>target.language,
+                reportFailure: ()=>window.location.reload()
+            });
+            sync.activate(instance);
+            const unsubscribe = router.subscribe('onBeforeLoad', ({ toLocation })=>{
+                const publicHref = toLocation.maskedLocation?.publicHref ?? toLocation.publicHref;
+                const pathname = new URL(publicHref, window.location.origin).pathname;
+                const language = (0, external_requestLanguage_js_namespaceObject.languageFromPathname)(pathname, routing.languages, routing.basePath);
+                if (language) sync.request(language);
+            });
+            return ()=>{
+                unsubscribe();
+                sync.deactivate();
+            };
+        },
+        persist (instance) {
+            const persist = (language)=>{
+                document.documentElement.lang = language;
+                document.cookie = `${cookie}=${encodeURIComponent(language)}; path=/; max-age=31536000; samesite=lax`;
+            };
+            if (instance.language) persist(instance.language);
+            instance.on('languageChanged', persist);
+            return ()=>instance.off('languageChanged', persist);
+        }
+    };
+}
+exports.createNativeI18n = __webpack_exports__.createNativeI18n;
+exports.createNativeI18nInstance = __webpack_exports__.createNativeI18nInstance;
+exports.getNativeI18nRewriteSnapshot = __webpack_exports__.getNativeI18nRewriteSnapshot;
+exports.getNativeI18nSnapshotSeed = __webpack_exports__.getNativeI18nSnapshotSeed;
+exports.invalidateNativeI18nSnapshot = __webpack_exports__.invalidateNativeI18nSnapshot;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createNativeI18n",
+    "createNativeI18nInstance",
+    "getNativeI18nRewriteSnapshot",
+    "getNativeI18nSnapshotSeed",
+    "invalidateNativeI18nSnapshot"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/paths.js

@@ -30,25 +30,33 @@ __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     buildLocalizedUrl: ()=>buildLocalizedUrl,
     canonicalPath: ()=>canonicalPath,
+    configuredLanguage: ()=>configuredLanguage,
     localizePath: ()=>localizePath
 });
+const localised_urls_namespaceObject = require("@modern-js/runtime-extensions/localised-urls");
 const url_namespaceObject = require("@modern-js/runtime-utils/url");
-const index_js_namespaceObject = require("./localisedUrls/index.js");
+const configuredLanguage = (requested, languages)=>{
+    const language = languages.find((candidate)=>candidate.toLowerCase() === String(requested).toLowerCase());
+    if (void 0 === language) throw new RangeError(`Unsupported language "${requested}"; expected one of: ${languages.join(', ')}`);
+    return language;
+};
 const buildLocalizedUrl = (target, language, languages, localisedUrls)=>{
     const { pathname, search, hash } = (0, url_namespaceObject.splitUrlTarget)(target);
-    return `${(0, index_js_namespaceObject.localiseTargetPathname)(pathname, language, languages, localisedUrls)}${search}${hash}`;
+    return `${(0, localised_urls_namespaceObject.localiseTargetPathname)(pathname, language, languages, localisedUrls)}${search}${hash}`;
 };
 const localizePath = (target, language, config)=>buildLocalizedUrl(target, language, config.languages, config.localisedUrls);
 const canonicalPath = (target, config)=>{
     const { pathname, search, hash } = (0, url_namespaceObject.splitUrlTarget)(target);
-    return `${(0, index_js_namespaceObject.canonicalTargetPathname)(pathname, config.languages, config.localisedUrls)}${search}${hash}`;
+    return `${(0, localised_urls_namespaceObject.canonicalTargetPathname)(pathname, config.languages, config.localisedUrls)}${search}${hash}`;
 };
 exports.buildLocalizedUrl = __webpack_exports__.buildLocalizedUrl;
 exports.canonicalPath = __webpack_exports__.canonicalPath;
+exports.configuredLanguage = __webpack_exports__.configuredLanguage;
 exports.localizePath = __webpack_exports__.localizePath;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "buildLocalizedUrl",
     "canonicalPath",
+    "configuredLanguage",
     "localizePath"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {