@bleedingdev/modern-js-i18n-runtime-extensions 3.8.3-ultramodern.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-present Bytedance, Inc. and its affiliates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cjs/index.js

@@ -0,0 +1,76 @@
+"use strict";
+var __webpack_modules__ = {
+    "./language-sync/controller" (module) {
+        module.exports = require("./language-sync/controller.js");
+    },
+    "./language-sync/react" (module) {
+        module.exports = require("./language-sync/react.js");
+    },
+    "./localisedUrls/index" (module) {
+        module.exports = require("./localisedUrls/index.js");
+    }
+};
+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__.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__);
+    var _language_sync_controller__rspack_import_0 = __webpack_require__("./language-sync/controller");
+    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];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _language_sync_react__rspack_import_1 = __webpack_require__("./language-sync/react");
+    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];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _localisedUrls_index__rspack_import_2 = __webpack_require__("./localisedUrls/index");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _localisedUrls_index__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_localisedUrls_index__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/language-sync/controller.js

@@ -0,0 +1,241 @@
+"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 DEFAULT_ATTEMPT_TIMEOUT_MS = 1000;
+const DEFAULT_MAX_ATTEMPTS = 4;
+const defaultRetryDelay = (failedAttempts)=>Math.min(50 * 2 ** Math.max(failedAttempts - 1, 0), 1000);
+const normalizePolicy = (policy)=>({
+        attemptTimeoutMs: Math.max(1, policy.attemptTimeoutMs ?? DEFAULT_ATTEMPT_TIMEOUT_MS),
+        maxAttempts: Math.max(1, policy.maxAttempts ?? DEFAULT_MAX_ATTEMPTS),
+        retryDelayMs: policy.retryDelayMs ?? defaultRetryDelay
+    });
+class LanguageSyncTimeoutError extends Error {
+    constructor(language, timeoutMs){
+        super(`Language synchronization for "${language}" did not settle within ${timeoutMs}ms.`);
+        this.name = 'LanguageSyncTimeoutError';
+    }
+}
+let requestOrder = 0;
+class Binding {
+    activate(target) {
+        if (this.target === target && this.coordinator) return;
+        const desiredLanguage = this.desiredLanguage;
+        const order = this.order;
+        this.deactivate();
+        this.desiredLanguage = desiredLanguage;
+        this.order = order;
+        this.target = target;
+        this.coordinator = getCoordinator(target, this.policy);
+        this.coordinator.add(this);
+        this.coordinator.refresh();
+    }
+    clearRequest() {
+        if (!this.desiredLanguage) return;
+        this.desiredLanguage = void 0;
+        this.order = ++requestOrder;
+        this.coordinator?.refresh();
+    }
+    deactivate() {
+        const coordinator = this.coordinator;
+        this.coordinator = void 0;
+        this.target = void 0;
+        this.desiredLanguage = void 0;
+        coordinator?.remove(this);
+    }
+    request(language) {
+        const normalizedLanguage = language.trim();
+        if (!normalizedLanguage) return;
+        const repeatedFailedRequest = this.desiredLanguage === normalizedLanguage && this.coordinator?.isFailed(normalizedLanguage);
+        this.desiredLanguage = normalizedLanguage;
+        this.order = ++requestOrder;
+        this.coordinator?.refresh(repeatedFailedRequest);
+    }
+    updateCallbacks(callbacks) {
+        this.callbacks = callbacks;
+    }
+    constructor(policy){
+        this.policy = policy;
+        this.order = 0;
+    }
+}
+class Coordinator {
+    add(binding) {
+        this.bindings.add(binding);
+    }
+    isFailed(language) {
+        return this.intent?.language === language && 'failed' === this.intent.status;
+    }
+    refresh(forceRetry = false) {
+        const selected = this.selectBinding();
+        if (!selected?.desiredLanguage) return void this.invalidateIntent();
+        const language = selected.desiredLanguage;
+        if (this.intent?.language === language && !forceRetry) {
+            if ('satisfied' === this.intent.status) this.commit(language);
+            return;
+        }
+        this.beginIntent(language, false);
+    }
+    remove(binding) {
+        this.bindings.delete(binding);
+        this.refresh();
+    }
+    beginIntent(language, forceChange) {
+        this.clearRetry();
+        const intent = {
+            attempts: 0,
+            generation: ++this.generation,
+            language,
+            status: 'attempting'
+        };
+        this.intent = intent;
+        const activeBinding = this.selectBinding();
+        if (!forceChange && activeBinding?.callbacks?.readLanguage?.(this.target) === language) {
+            intent.status = 'satisfied';
+            this.commit(language);
+            return;
+        }
+        this.startAttempt(intent);
+    }
+    clearRetry() {
+        if (void 0 !== this.retryTimer) {
+            clearTimeout(this.retryTimer);
+            this.retryTimer = void 0;
+        }
+    }
+    commit(language) {
+        for (const binding of this.bindings)if (binding.callbacks) binding.callbacks.commitLanguage(this.target, language);
+    }
+    failAttempt(intent, reason, error) {
+        if (this.intent !== intent || 'satisfied' === intent.status) return;
+        if (intent.attempts >= this.policy.maxAttempts) {
+            intent.status = 'failed';
+            for (const binding of this.bindings)if (binding.desiredLanguage === intent.language) binding.callbacks?.reportFailure?.({
+                attempts: intent.attempts,
+                error,
+                language: intent.language,
+                reason
+            });
+            return;
+        }
+        intent.status = 'retry-wait';
+        const retryDelay = Math.max(0, this.policy.retryDelayMs(intent.attempts));
+        this.retryTimer = setTimeout(()=>{
+            this.retryTimer = void 0;
+            if (this.intent === intent && this.selectBinding()?.desiredLanguage) {
+                intent.status = 'attempting';
+                this.startAttempt(intent);
+            }
+        }, retryDelay);
+    }
+    invalidateIntent() {
+        this.clearRetry();
+        this.generation += 1;
+        this.intent = void 0;
+    }
+    onFulfilled(attempt) {
+        if (attempt.settled) return;
+        attempt.settled = true;
+        clearTimeout(attempt.timer);
+        const intent = this.intent;
+        if (!intent) return;
+        if (attempt.language === intent.language) {
+            this.clearRetry();
+            if ('satisfied' !== intent.status) {
+                intent.status = 'satisfied';
+                this.commit(intent.language);
+            }
+            return;
+        }
+        this.beginIntent(intent.language, true);
+    }
+    onRejected(attempt, error) {
+        if (attempt.settled) return;
+        attempt.settled = true;
+        clearTimeout(attempt.timer);
+        if (attempt.timedOut) return;
+        const intent = this.intent;
+        if (intent?.generation === attempt.generation && intent.language === attempt.language) this.failAttempt(intent, 'rejected', error);
+    }
+    selectBinding() {
+        let selected;
+        for (const binding of this.bindings)if (binding.desiredLanguage && binding.callbacks && (!selected || binding.order > selected.order)) selected = binding;
+        return selected;
+    }
+    startAttempt(intent) {
+        const binding = this.selectBinding();
+        const callbacks = binding?.callbacks;
+        if (!callbacks || binding?.desiredLanguage !== intent.language) return void this.refresh();
+        intent.attempts += 1;
+        const attempt = {
+            generation: intent.generation,
+            language: intent.language,
+            settled: false,
+            timedOut: false,
+            timer: void 0
+        };
+        attempt.timer = setTimeout(()=>{
+            if (attempt.settled || attempt.timedOut) return;
+            attempt.timedOut = true;
+            if (this.intent === intent && intent.generation === attempt.generation && intent.language === attempt.language) this.failAttempt(intent, 'timeout', new LanguageSyncTimeoutError(attempt.language, this.policy.attemptTimeoutMs));
+        }, this.policy.attemptTimeoutMs);
+        let result;
+        try {
+            result = callbacks.changeLanguage(this.target, intent.language);
+        } catch (error) {
+            this.onRejected(attempt, error);
+            return;
+        }
+        Promise.resolve(result).then(()=>this.onFulfilled(attempt), (error)=>this.onRejected(attempt, error));
+    }
+    constructor(target, policy){
+        this.target = target;
+        this.policy = policy;
+        this.bindings = new Set();
+        this.generation = 0;
+    }
+}
+const coordinators = new WeakMap();
+const getCoordinator = (target, policy)=>{
+    const existing = coordinators.get(target);
+    if (existing) return existing;
+    const coordinator = new Coordinator(target, policy);
+    coordinators.set(target, coordinator);
+    return coordinator;
+};
+const createLatestLanguageSyncBinding = (policy = {})=>new Binding(normalizePolicy(policy));
+__webpack_require__.d(__webpack_exports__, {}, {
+    createLatestLanguageSyncBinding: createLatestLanguageSyncBinding
+});
+exports.createLatestLanguageSyncBinding = __webpack_exports__.createLatestLanguageSyncBinding;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createLatestLanguageSyncBinding"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/language-sync/react.js

@@ -0,0 +1,169 @@
+"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__, {
+    useLanguageSync: ()=>useLanguageSync,
+    useLatestLanguageSync: ()=>useLatestLanguageSync
+});
+const context_namespaceObject = require("@modern-js/runtime/context");
+const external_i18next_browser_languagedetector_namespaceObject = require("i18next-browser-languagedetector");
+var external_i18next_browser_languagedetector_default = /*#__PURE__*/ __webpack_require__.n(external_i18next_browser_languagedetector_namespaceObject);
+const external_react_namespaceObject = require("react");
+const external_controller_js_namespaceObject = require("./controller.js");
+const useLatestLanguageSync = ({ changeLanguage, commitLanguage, desiredLanguage, enabled = true, policy, readLanguage, reportFailure, target })=>{
+    const bindingRef = (0, external_react_namespaceObject.useRef)(null);
+    if (null === bindingRef.current) bindingRef.current = (0, external_controller_js_namespaceObject.createLatestLanguageSyncBinding)(policy);
+    const binding = bindingRef.current;
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        binding.updateCallbacks({
+            changeLanguage,
+            commitLanguage,
+            readLanguage,
+            reportFailure
+        });
+    });
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (!enabled || !target) return;
+        binding.activate(target);
+        return ()=>binding.deactivate();
+    }, [
+        binding,
+        enabled,
+        target
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (!enabled || !target || !desiredLanguage) return void binding.clearRequest();
+        binding.request(desiredLanguage);
+    }, [
+        binding,
+        desiredLanguage,
+        enabled,
+        target
+    ]);
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (!enabled || !target || !desiredLanguage || "u" < typeof window) return;
+        const retryCurrentIntent = ()=>binding.request(desiredLanguage);
+        const retryVisibleIntent = ()=>{
+            if ('visible' === document.visibilityState) retryCurrentIntent();
+        };
+        window.addEventListener('online', retryCurrentIntent);
+        document.addEventListener('visibilitychange', retryVisibleIntent);
+        return ()=>{
+            window.removeEventListener('online', retryCurrentIntent);
+            document.removeEventListener('visibilitychange', retryVisibleIntent);
+        };
+    }, [
+        binding,
+        desiredLanguage,
+        enabled,
+        target
+    ]);
+    return (0, external_react_namespaceObject.useCallback)((language)=>binding.request(language), [
+        binding
+    ]);
+};
+const actualInstance = (instance)=>instance.i18nInstance?.instance ?? instance;
+const cacheLanguage = (instance, language)=>{
+    if ("u" < typeof window) return;
+    const actual = actualInstance(instance);
+    const detector = actual.services?.languageDetector ?? instance.services?.languageDetector;
+    try {
+        if (detector?.cacheUserLanguage) return void detector.cacheUserLanguage(language);
+        if (instance.isInitialized || actual.isInitialized) {
+            const services = actual.services ?? instance.services;
+            const options = actual.options ?? instance.options;
+            if (services && options) {
+                const manualDetector = new (external_i18next_browser_languagedetector_default())();
+                manualDetector.init(services, instance.options?.detection ?? options.detection);
+                manualDetector.cacheUserLanguage?.(language);
+            }
+        }
+    } catch  {}
+};
+const detectPathLanguage = (pathname, languages)=>{
+    if (!pathname) return;
+    const basename = (0, context_namespaceObject.getGlobalBasename)();
+    const entryPath = basename && '/' !== basename ? basename : '';
+    const relativePath = pathname.startsWith(entryPath) ? pathname.slice(entryPath.length) : pathname;
+    const segments = relativePath.split('/').filter(Boolean);
+    const segmentsToCheck = !entryPath && segments.length > 1 && segments[0] && !languages.includes(segments[0]) ? segments.slice(1) : segments;
+    const language = segmentsToCheck[0];
+    return language && languages.includes(language) ? language : void 0;
+};
+function useLanguageSync(i18nInstance, localePathRedirect, languages, pathname, prevLangRef, setLang) {
+    const desiredLanguage = localePathRedirect ? detectPathLanguage(pathname, languages) : void 0;
+    const synchronizeLanguage = useLatestLanguageSync({
+        target: i18nInstance,
+        desiredLanguage,
+        enabled: Boolean(i18nInstance && localePathRedirect),
+        readLanguage: (instance)=>instance.language,
+        changeLanguage: (instance, language)=>instance.setLang ? instance.setLang(language) : instance.changeLanguage?.(language),
+        commitLanguage: (instance, language)=>{
+            prevLangRef.current = language;
+            setLang(language);
+            cacheLanguage(instance, language);
+        },
+        reportFailure: ({ error, language })=>{
+            console.error(`Failed to synchronize i18n language "${language}".`, error);
+        }
+    });
+    (0, external_react_namespaceObject.useEffect)(()=>{
+        if (!localePathRedirect && i18nInstance?.language) {
+            const instanceLanguage = i18nInstance.language;
+            if (instanceLanguage !== prevLangRef.current) {
+                prevLangRef.current = instanceLanguage;
+                setLang(instanceLanguage);
+            }
+        }
+    }, [
+        i18nInstance,
+        localePathRedirect,
+        prevLangRef,
+        setLang
+    ]);
+    return synchronizeLanguage;
+}
+exports.useLanguageSync = __webpack_exports__.useLanguageSync;
+exports.useLatestLanguageSync = __webpack_exports__.useLatestLanguageSync;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "useLanguageSync",
+    "useLatestLanguageSync"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/localisedUrls/config.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__);
+const resolveLocalisedUrlsConfig = (option)=>{
+    if (option && 'object' == typeof option && Object.keys(option).length > 0) return {
+        enabled: true,
+        map: option
+    };
+    return {
+        enabled: false,
+        map: {}
+    };
+};
+__webpack_require__.d(__webpack_exports__, {}, {
+    resolveLocalisedUrlsConfig: resolveLocalisedUrlsConfig
+});
+exports.resolveLocalisedUrlsConfig = __webpack_exports__.resolveLocalisedUrlsConfig;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveLocalisedUrlsConfig"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/localisedUrls/index.js

@@ -0,0 +1,91 @@
+"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__, {
+    DEFAULT_LOCALE_REDIRECT_SKIP_RULES: ()=>external_redirect_js_namespaceObject.DEFAULT_LOCALE_REDIRECT_SKIP_RULES,
+    applyLocalisedUrlsToRoutes: ()=>external_routes_js_namespaceObject.applyLocalisedUrlsToRoutes,
+    buildPathFromPattern: ()=>external_patterns_js_namespaceObject.buildPathFromPattern,
+    canonicalTargetPathname: ()=>external_pathname_js_namespaceObject.canonicalTargetPathname,
+    isDefaultLocaleRedirectSkipPath: ()=>external_redirect_js_namespaceObject.isDefaultLocaleRedirectSkipPath,
+    localiseTargetPathname: ()=>external_pathname_js_namespaceObject.localiseTargetPathname,
+    matchPathPattern: ()=>external_patterns_js_namespaceObject.matchPathPattern,
+    matchesPathPrefix: ()=>external_redirect_js_namespaceObject.matchesPathPrefix,
+    normalisePathPattern: ()=>external_normalise_js_namespaceObject.normalisePathPattern,
+    normalisePathname: ()=>external_normalise_js_namespaceObject.normalisePathname,
+    resolveCanonicalLocalisedPath: ()=>external_resolve_js_namespaceObject.resolveCanonicalLocalisedPath,
+    resolveLocalisedPath: ()=>external_resolve_js_namespaceObject.resolveLocalisedPath,
+    resolveLocalisedUrlsConfig: ()=>external_config_js_namespaceObject.resolveLocalisedUrlsConfig,
+    shouldSkipLocaleRedirect: ()=>external_redirect_js_namespaceObject.shouldSkipLocaleRedirect,
+    stripLanguagePrefix: ()=>external_pathname_js_namespaceObject.stripLanguagePrefix,
+    validateLocalisedUrls: ()=>external_routes_js_namespaceObject.validateLocalisedUrls
+});
+const external_config_js_namespaceObject = require("./config.js");
+const external_normalise_js_namespaceObject = require("./normalise.js");
+const external_pathname_js_namespaceObject = require("./pathname.js");
+const external_patterns_js_namespaceObject = require("./patterns.js");
+const external_redirect_js_namespaceObject = require("./redirect.js");
+const external_resolve_js_namespaceObject = require("./resolve.js");
+const external_routes_js_namespaceObject = require("./routes.js");
+exports.DEFAULT_LOCALE_REDIRECT_SKIP_RULES = __webpack_exports__.DEFAULT_LOCALE_REDIRECT_SKIP_RULES;
+exports.applyLocalisedUrlsToRoutes = __webpack_exports__.applyLocalisedUrlsToRoutes;
+exports.buildPathFromPattern = __webpack_exports__.buildPathFromPattern;
+exports.canonicalTargetPathname = __webpack_exports__.canonicalTargetPathname;
+exports.isDefaultLocaleRedirectSkipPath = __webpack_exports__.isDefaultLocaleRedirectSkipPath;
+exports.localiseTargetPathname = __webpack_exports__.localiseTargetPathname;
+exports.matchPathPattern = __webpack_exports__.matchPathPattern;
+exports.matchesPathPrefix = __webpack_exports__.matchesPathPrefix;
+exports.normalisePathPattern = __webpack_exports__.normalisePathPattern;
+exports.normalisePathname = __webpack_exports__.normalisePathname;
+exports.resolveCanonicalLocalisedPath = __webpack_exports__.resolveCanonicalLocalisedPath;
+exports.resolveLocalisedPath = __webpack_exports__.resolveLocalisedPath;
+exports.resolveLocalisedUrlsConfig = __webpack_exports__.resolveLocalisedUrlsConfig;
+exports.shouldSkipLocaleRedirect = __webpack_exports__.shouldSkipLocaleRedirect;
+exports.stripLanguagePrefix = __webpack_exports__.stripLanguagePrefix;
+exports.validateLocalisedUrls = __webpack_exports__.validateLocalisedUrls;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_LOCALE_REDIRECT_SKIP_RULES",
+    "applyLocalisedUrlsToRoutes",
+    "buildPathFromPattern",
+    "canonicalTargetPathname",
+    "isDefaultLocaleRedirectSkipPath",
+    "localiseTargetPathname",
+    "matchPathPattern",
+    "matchesPathPrefix",
+    "normalisePathPattern",
+    "normalisePathname",
+    "resolveCanonicalLocalisedPath",
+    "resolveLocalisedPath",
+    "resolveLocalisedUrlsConfig",
+    "shouldSkipLocaleRedirect",
+    "stripLanguagePrefix",
+    "validateLocalisedUrls"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});