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

package/dist/cjs/localisedUrls/routes.js

@@ -0,0 +1,202 @@
+"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__, {
+    applyLocalisedUrlsToRoutes: ()=>applyLocalisedUrlsToRoutes,
+    validateLocalisedUrls: ()=>validateLocalisedUrls
+});
+const external_normalise_js_namespaceObject = require("./normalise.js");
+const external_patterns_js_namespaceObject = require("./patterns.js");
+const isLocalisableRoutePath = (path)=>{
+    const pathWithoutLocale = (0, external_normalise_js_namespaceObject.stripLeadingLocaleParam)(path);
+    if (!pathWithoutLocale || '/' === pathWithoutLocale || '*' === pathWithoutLocale) return false;
+    return true;
+};
+const joinPath = (parentPath, routePath)=>{
+    if (!isLocalisableRoutePath(routePath)) return parentPath;
+    const segment = (0, external_normalise_js_namespaceObject.normaliseRoutePath)((0, external_normalise_js_namespaceObject.stripLeadingLocaleParam)(routePath) || '');
+    return (0, external_normalise_js_namespaceObject.normalisePathPattern)(`${parentPath}/${segment}`);
+};
+const isFrameworkInternalRoutePath = (canonicalPath)=>'/_mf' === canonicalPath || canonicalPath.startsWith('/_mf/');
+const legalRouteIdPart = (value)=>value.replace(/[^a-zA-Z0-9_$-]+/g, '_').replace(/^_+|_+$/g, '') || 'index';
+const formatParamSignature = (signature)=>signature.length > 0 ? signature.join(', ') : '(none)';
+const validateLocalisedUrlPatterns = (languages, localisedUrls)=>{
+    const physicalPatterns = new Map();
+    const claimedPatterns = [];
+    const claimPhysicalPattern = (sourcePattern, canonicalPath, source)=>{
+        const physicalPattern = (0, external_patterns_js_namespaceObject.getPhysicalPathPattern)(sourcePattern);
+        const existing = physicalPatterns.get(physicalPattern);
+        if (existing && existing.canonicalPath !== canonicalPath) throw new Error(`localisedUrls["${existing.canonicalPath}"] ${existing.source} and localisedUrls["${canonicalPath}"] ${source} generate the same physical route pattern "${physicalPattern}". Localised route patterns must identify exactly one canonical route.`);
+        const overlapping = claimedPatterns.find((claimed)=>claimed.canonicalPath !== canonicalPath && (0, external_patterns_js_namespaceObject.haveEqualPatternSpecificity)(claimed.pattern, sourcePattern) && (0, external_patterns_js_namespaceObject.doPathPatternsOverlap)(claimed.pattern, sourcePattern));
+        if (overlapping) throw new Error(`localisedUrls["${overlapping.canonicalPath}"] ${overlapping.source} pattern "${overlapping.pattern}" and localisedUrls["${canonicalPath}"] ${source} pattern "${sourcePattern}" are equal-specificity overlapping route patterns. Localised route patterns must identify exactly one canonical route.`);
+        physicalPatterns.set(physicalPattern, {
+            canonicalPath,
+            source
+        });
+        claimedPatterns.push({
+            canonicalPath,
+            pattern: sourcePattern,
+            source
+        });
+    };
+    for (const [canonicalPath, entry] of Object.entries(localisedUrls).sort(([left], [right])=>left < right ? -1 : left > right ? 1 : 0)){
+        const canonicalIssue = (0, external_patterns_js_namespaceObject.getPathPatternValidationIssue)(canonicalPath);
+        if (canonicalIssue) throw new Error(`localisedUrls["${canonicalPath}"] canonical pattern has ${canonicalIssue}.`);
+        const expectedSignature = (0, external_patterns_js_namespaceObject.getPathParamSignature)(canonicalPath);
+        const expectedOrderedSignature = (0, external_patterns_js_namespaceObject.getOrderedPathParamSignature)(canonicalPath);
+        claimPhysicalPattern(canonicalPath, canonicalPath, 'canonical pattern');
+        for (const language of languages){
+            const localisedPattern = entry[language];
+            if (!localisedPattern) continue;
+            const localisedIssue = (0, external_patterns_js_namespaceObject.getPathPatternValidationIssue)(localisedPattern);
+            if (localisedIssue) throw new Error(`localisedUrls["${canonicalPath}"].${language} has ${localisedIssue}.`);
+            const actualSignature = (0, external_patterns_js_namespaceObject.getPathParamSignature)(localisedPattern);
+            if (actualSignature.length !== expectedSignature.length || actualSignature.some((parameter, index)=>parameter !== expectedSignature[index])) throw new Error(`localisedUrls["${canonicalPath}"].${language} must use the same parameter signature as "${canonicalPath}": expected ${formatParamSignature(expectedSignature)}; received ${formatParamSignature(actualSignature)}.`);
+            const actualOrderedSignature = (0, external_patterns_js_namespaceObject.getOrderedPathParamSignature)(localisedPattern);
+            if (expectedOrderedSignature.some((parameter)=>'*' === parameter || parameter.endsWith('?')) && actualOrderedSignature.some((parameter, index)=>parameter !== expectedOrderedSignature[index])) throw new Error(`localisedUrls["${canonicalPath}"].${language} must keep optional and splat parameters in canonical order: expected ${formatParamSignature(expectedOrderedSignature)}; received ${formatParamSignature(actualOrderedSignature)}.`);
+            claimPhysicalPattern(localisedPattern, canonicalPath, `.${language}`);
+        }
+    }
+};
+const ensureLocalisedUrlsForPath = (canonicalPath, languages, localisedUrls)=>{
+    const entry = localisedUrls[canonicalPath];
+    if (!entry) throw new Error(`localisedUrls is enabled, but route "${canonicalPath}" does not define localised URLs for languages: ${languages.join(', ')}. Add localisedUrls["${canonicalPath}"] or set localeDetection.localisedUrls to false.`);
+    const missingLanguages = languages.filter((language)=>!entry[language]);
+    if (missingLanguages.length > 0) throw new Error(`localisedUrls["${canonicalPath}"] is missing languages: ${missingLanguages.join(', ')}. Every configured language must have a localised URL.`);
+    return entry;
+};
+const validateLocalisedUrls = (routes, languages, localisedUrls)=>{
+    validateLocalisedUrlPatterns(languages, localisedUrls);
+    const visit = (route, parentPath)=>{
+        const canonicalPath = joinPath(parentPath, route.path);
+        if (isLocalisableRoutePath(route.path) && !isFrameworkInternalRoutePath(canonicalPath)) ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls);
+        if ('children' in route && route.children) route.children.forEach((child)=>visit(child, canonicalPath));
+    };
+    routes.forEach((route)=>visit(route, ''));
+};
+const getLocalisedRouteIdSuffixes = (paths)=>{
+    const usedSuffixes = new Set();
+    return paths.map((path, index)=>{
+        if (0 === index) return;
+        const baseSuffix = legalRouteIdPart(path);
+        let suffix = baseSuffix;
+        let disambiguator = 2;
+        while(usedSuffixes.has(suffix))suffix = `${baseSuffix}_${disambiguator++}`;
+        usedSuffixes.add(suffix);
+        return suffix;
+    });
+};
+const getLocalisedRoutePaths = (canonicalPath, parentLocalisedPaths, languages, entry)=>{
+    const paths = languages.map((language)=>{
+        const fullPath = (0, external_normalise_js_namespaceObject.normalisePathPattern)(entry[language]);
+        const parentPath = (0, external_normalise_js_namespaceObject.normalisePathPattern)(parentLocalisedPaths[language] || '/');
+        if ('/' === parentPath) return (0, external_normalise_js_namespaceObject.normaliseRoutePath)(fullPath) || void 0;
+        const parentPrefix = `${parentPath}/`;
+        if (!fullPath.startsWith(parentPrefix)) throw new Error(`localisedUrls["${canonicalPath}"].${language} must be nested under "${parentPath}" because its parent route is localised there.`);
+        return (0, external_normalise_js_namespaceObject.normaliseRoutePath)(fullPath.slice(parentPath.length));
+    });
+    const uniquePaths = Array.from(new Set(paths.filter(Boolean)));
+    return uniquePaths;
+};
+const transformLocalisedRoute = (route, parentCanonicalPath, parentLocalisedPaths, languages, localisedUrls)=>{
+    const canonicalPath = joinPath(parentCanonicalPath, route.path);
+    const localisedUrlEntry = isLocalisableRoutePath(route.path) && !isFrameworkInternalRoutePath(canonicalPath) ? ensureLocalisedUrlsForPath(canonicalPath, languages, localisedUrls) : void 0;
+    const routeLocalisedPaths = localisedUrlEntry ? languages.reduce((acc, language)=>{
+        acc[language] = (0, external_normalise_js_namespaceObject.normalisePathPattern)(localisedUrlEntry[language]);
+        return acc;
+    }, {}) : parentLocalisedPaths;
+    const children = 'children' in route && route.children ? route.children.flatMap((child)=>transformLocalisedRoute(child, canonicalPath, routeLocalisedPaths, languages, localisedUrls)) : void 0;
+    const baseRoute = {
+        ...route,
+        ...children ? {
+            children
+        } : {}
+    };
+    if (!localisedUrlEntry) return [
+        baseRoute
+    ];
+    const localisedPaths = getLocalisedRoutePaths(canonicalPath, parentLocalisedPaths, languages, localisedUrlEntry);
+    const leadingLocaleParam = (0, external_normalise_js_namespaceObject.getLeadingLocaleParam)(route.path);
+    const routeIdPaths = leadingLocaleParam ? localisedPaths.map((path)=>(0, external_normalise_js_namespaceObject.normaliseRoutePath)(`${leadingLocaleParam}/${path}`)) : localisedPaths;
+    const routeIdSuffixes = getLocalisedRouteIdSuffixes(routeIdPaths);
+    return localisedPaths.map((localisedPath, index)=>cloneRouteWithLocalisedPath(baseRoute, localisedPath, routeIdSuffixes[index], canonicalPath));
+};
+const suffixRouteIds = (route, suffix)=>{
+    const children = 'children' in route && route.children ? route.children.map((child)=>suffixRouteIds(child, suffix)) : void 0;
+    return {
+        ...route,
+        ...route.id ? {
+            id: `${route.id}__localised_${suffix}`
+        } : {},
+        ...children ? {
+            children
+        } : {}
+    };
+};
+const collectRouteIdCounts = (routes, counts = new Map())=>{
+    for (const route of routes){
+        if (route.id) counts.set(route.id, (counts.get(route.id) ?? 0) + 1);
+        if ('children' in route && route.children) collectRouteIdCounts(route.children, counts);
+    }
+    return counts;
+};
+const validateNoNewRouteIdCollisions = (sourceRoutes, localisedRoutes)=>{
+    const sourceCounts = collectRouteIdCounts(sourceRoutes);
+    const localisedCounts = collectRouteIdCounts(localisedRoutes);
+    for (const [routeId, count] of localisedCounts)if (count > 1 && count > (sourceCounts.get(routeId) ?? 0)) throw new Error(`Localised route expansion generated duplicate route ID "${routeId}". Change the source route ID or localised path so every generated route remains identifiable.`);
+};
+const cloneRouteWithLocalisedPath = (route, path, routeIdSuffix, canonicalPath)=>{
+    const leadingLocaleParam = (0, external_normalise_js_namespaceObject.getLeadingLocaleParam)(route.path);
+    const localisedPath = leadingLocaleParam ? (0, external_normalise_js_namespaceObject.normaliseRoutePath)(`${leadingLocaleParam}/${path}`) : path;
+    const routeWithPath = {
+        ...route,
+        path: localisedPath
+    };
+    routeWithPath.modernCanonicalPath = canonicalPath;
+    return routeIdSuffix ? suffixRouteIds(routeWithPath, routeIdSuffix) : routeWithPath;
+};
+const applyLocalisedUrlsToRoutes = (routes, languages, localisedUrls)=>{
+    const rootLocalisedPaths = languages.reduce((acc, language)=>{
+        acc[language] = '/';
+        return acc;
+    }, {});
+    validateLocalisedUrls(routes, languages, localisedUrls);
+    const localisedRoutes = routes.flatMap((route)=>transformLocalisedRoute(route, '', rootLocalisedPaths, languages, localisedUrls));
+    validateNoNewRouteIdCollisions(routes, localisedRoutes);
+    return localisedRoutes;
+};
+exports.applyLocalisedUrlsToRoutes = __webpack_exports__.applyLocalisedUrlsToRoutes;
+exports.validateLocalisedUrls = __webpack_exports__.validateLocalisedUrls;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "applyLocalisedUrlsToRoutes",
+    "validateLocalisedUrls"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/localisedUrls/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/esm/index.mjs

@@ -0,0 +1,3 @@
+export * from "./language-sync/controller.mjs";
+export * from "./language-sync/react.mjs";
+export * from "./localisedUrls/index.mjs";

package/dist/esm/language-sync/controller.mjs

@@ -0,0 +1,203 @@
+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));
+export { createLatestLanguageSyncBinding };

package/dist/esm/language-sync/react.mjs

@@ -0,0 +1,118 @@
+import { getGlobalBasename } from "@modern-js/runtime/context";
+import i18next_browser_languagedetector from "i18next-browser-languagedetector";
+import { useCallback, useEffect, useRef } from "react";
+import { createLatestLanguageSyncBinding } from "./controller.mjs";
+const useLatestLanguageSync = ({ changeLanguage, commitLanguage, desiredLanguage, enabled = true, policy, readLanguage, reportFailure, target })=>{
+    const bindingRef = useRef(null);
+    if (null === bindingRef.current) bindingRef.current = createLatestLanguageSyncBinding(policy);
+    const binding = bindingRef.current;
+    useEffect(()=>{
+        binding.updateCallbacks({
+            changeLanguage,
+            commitLanguage,
+            readLanguage,
+            reportFailure
+        });
+    });
+    useEffect(()=>{
+        if (!enabled || !target) return;
+        binding.activate(target);
+        return ()=>binding.deactivate();
+    }, [
+        binding,
+        enabled,
+        target
+    ]);
+    useEffect(()=>{
+        if (!enabled || !target || !desiredLanguage) return void binding.clearRequest();
+        binding.request(desiredLanguage);
+    }, [
+        binding,
+        desiredLanguage,
+        enabled,
+        target
+    ]);
+    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 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 i18next_browser_languagedetector();
+                manualDetector.init(services, instance.options?.detection ?? options.detection);
+                manualDetector.cacheUserLanguage?.(language);
+            }
+        }
+    } catch  {}
+};
+const detectPathLanguage = (pathname, languages)=>{
+    if (!pathname) return;
+    const basename = 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);
+        }
+    });
+    useEffect(()=>{
+        if (!localePathRedirect && i18nInstance?.language) {
+            const instanceLanguage = i18nInstance.language;
+            if (instanceLanguage !== prevLangRef.current) {
+                prevLangRef.current = instanceLanguage;
+                setLang(instanceLanguage);
+            }
+        }
+    }, [
+        i18nInstance,
+        localePathRedirect,
+        prevLangRef,
+        setLang
+    ]);
+    return synchronizeLanguage;
+}
+export { useLanguageSync, useLatestLanguageSync };

package/dist/esm/localisedUrls/config.mjs

@@ -0,0 +1,11 @@
+const resolveLocalisedUrlsConfig = (option)=>{
+    if (option && 'object' == typeof option && Object.keys(option).length > 0) return {
+        enabled: true,
+        map: option
+    };
+    return {
+        enabled: false,
+        map: {}
+    };
+};
+export { resolveLocalisedUrlsConfig };

package/dist/esm/localisedUrls/index.mjs

@@ -0,0 +1,7 @@
+export { resolveLocalisedUrlsConfig } from "./config.mjs";
+export { normalisePathPattern, normalisePathname } from "./normalise.mjs";
+export { canonicalTargetPathname, localiseTargetPathname, stripLanguagePrefix } from "./pathname.mjs";
+export { buildPathFromPattern, matchPathPattern } from "./patterns.mjs";
+export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, matchesPathPrefix, shouldSkipLocaleRedirect } from "./redirect.mjs";
+export { resolveCanonicalLocalisedPath, resolveLocalisedPath } from "./resolve.mjs";
+export { applyLocalisedUrlsToRoutes, validateLocalisedUrls } from "./routes.mjs";

package/dist/esm/localisedUrls/normalise.mjs

@@ -0,0 +1,37 @@
+const LOCALE_PARAM_NAMES = new Set([
+    'lang',
+    'locale',
+    'language'
+]);
+const normaliseSlashes = (path)=>{
+    const withoutDuplicateSlashes = path.replace(/\/+/g, '/');
+    const withLeadingSlash = withoutDuplicateSlashes.startsWith('/') ? withoutDuplicateSlashes : `/${withoutDuplicateSlashes}`;
+    return withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/, '') : withLeadingSlash;
+};
+const normalisePathPattern = (path)=>normaliseSlashes(path).replace(/\[(.+?)\]/g, ':$1');
+const normalisePathname = (pathname)=>normaliseSlashes(pathname);
+const normaliseRoutePath = (path)=>{
+    const normalized = normalisePathPattern(path);
+    return '/' === normalized ? '' : normalized.slice(1);
+};
+const getLocaleParamSegment = (segment)=>{
+    if (!segment.startsWith(':')) return null;
+    const paramName = segment.slice(1).replace(/\?$/, '');
+    return LOCALE_PARAM_NAMES.has(paramName) ? segment : null;
+};
+const splitPathSegments = (path)=>{
+    if (!path) return [];
+    return normalisePathPattern(path).split('/').filter(Boolean);
+};
+const stripLeadingLocaleParam = (path)=>{
+    const segments = splitPathSegments(path);
+    const leadingLocaleParam = getLocaleParamSegment(segments[0] || '');
+    if (!leadingLocaleParam) return path;
+    const remainingPath = segments.slice(1).join('/');
+    return remainingPath ? `/${remainingPath}` : void 0;
+};
+const getLeadingLocaleParam = (path)=>{
+    const segments = splitPathSegments(path);
+    return getLocaleParamSegment(segments[0] || '');
+};
+export { getLeadingLocaleParam, normalisePathPattern, normalisePathname, normaliseRoutePath, stripLeadingLocaleParam };

package/dist/esm/localisedUrls/pathname.mjs

@@ -0,0 +1,24 @@
+import { resolveLocalisedUrlsConfig } from "./config.mjs";
+import { resolveCanonicalLocalisedPath, resolveLocalisedPath } from "./resolve.mjs";
+const stripLanguagePrefix = (pathname, languages)=>{
+    const segments = pathname.split('/').filter(Boolean);
+    const firstSegment = segments[0]?.toLowerCase();
+    if (firstSegment && languages.some((language)=>language.toLowerCase() === firstSegment)) return `/${segments.slice(1).join('/')}`;
+    return pathname || '/';
+};
+const localiseTargetPathname = (pathname, language, languages, localisedUrls)=>{
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+    const resolvedPath = localisedUrlsConfig.enabled ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
+    return `/${[
+        language,
+        ...resolvedSegments
+    ].join('/')}`;
+};
+const canonicalTargetPathname = (pathname, languages, localisedUrls)=>{
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    const localisedUrlsConfig = resolveLocalisedUrlsConfig(localisedUrls);
+    return localisedUrlsConfig.enabled ? resolveCanonicalLocalisedPath(pathWithoutLanguage, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
+};
+export { canonicalTargetPathname, localiseTargetPathname, stripLanguagePrefix };