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

package/dist/cjs/ssrLanguageHandoff.js

@@ -0,0 +1,94 @@
+"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__, {
+    I18N_SSR_HANDOFF_ELEMENT_ID: ()=>I18N_SSR_HANDOFF_ELEMENT_ID,
+    createI18nSsrHandoffInlineData: ()=>createI18nSsrHandoffInlineData,
+    readI18nSsrHandoff: ()=>readI18nSsrHandoff,
+    readI18nSsrHandoffFromText: ()=>readI18nSsrHandoffFromText,
+    serializeI18nSsrHandoff: ()=>serializeI18nSsrHandoff
+});
+const data_namespaceObject = require("@modern-js/renderer-core/data");
+const document_namespaceObject = require("@modern-js/renderer-core/document");
+const I18N_SSR_HANDOFF_ELEMENT_ID = '__modernjs_i18n_ssr__';
+function assertPayload(payload) {
+    if ('string' != typeof payload.language || 0 === payload.language.length) throw new TypeError('An i18n SSR handoff payload requires a nonempty language.');
+    if (void 0 !== payload.resources && ('object' != typeof payload.resources || null === payload.resources)) throw new TypeError('An i18n SSR handoff payload resources field must be a plain object.');
+}
+function createI18nSsrHandoffInlineData(payload, options = {}) {
+    assertPayload(payload);
+    return {
+        id: options.id ?? I18N_SSR_HANDOFF_ELEMENT_ID,
+        payload: (0, data_namespaceObject.serializePublicData)({
+            language: payload.language,
+            ...payload.resources ? {
+                resources: payload.resources
+            } : {}
+        })
+    };
+}
+function serializeI18nSsrHandoff(payload, options = {}) {
+    return (0, document_namespaceObject.serializeInlineData)({
+        ...createI18nSsrHandoffInlineData(payload, options),
+        nonce: options.nonce
+    });
+}
+function isHandoffPayload(value) {
+    return Boolean(value) && 'object' == typeof value && 'string' == typeof value.language;
+}
+function readI18nSsrHandoffFromText(text) {
+    if (!text) return;
+    try {
+        const result = (0, data_namespaceObject.parsePublicData)(text);
+        return isHandoffPayload(result) ? result : void 0;
+    } catch  {
+        return;
+    }
+}
+function readI18nSsrHandoff(options = {}) {
+    const doc = options.doc ?? ("u" < typeof document ? void 0 : document);
+    if (!doc) return;
+    const element = doc.getElementById(options.id ?? I18N_SSR_HANDOFF_ELEMENT_ID);
+    return readI18nSsrHandoffFromText(element?.textContent ?? null);
+}
+exports.I18N_SSR_HANDOFF_ELEMENT_ID = __webpack_exports__.I18N_SSR_HANDOFF_ELEMENT_ID;
+exports.createI18nSsrHandoffInlineData = __webpack_exports__.createI18nSsrHandoffInlineData;
+exports.readI18nSsrHandoff = __webpack_exports__.readI18nSsrHandoff;
+exports.readI18nSsrHandoffFromText = __webpack_exports__.readI18nSsrHandoffFromText;
+exports.serializeI18nSsrHandoff = __webpack_exports__.serializeI18nSsrHandoff;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "I18N_SSR_HANDOFF_ELEMENT_ID",
+    "createI18nSsrHandoffInlineData",
+    "readI18nSsrHandoff",
+    "readI18nSsrHandoffFromText",
+    "serializeI18nSsrHandoff"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/urlRewrite.js

@@ -0,0 +1,64 @@
+"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__, {
+    createI18nUrlRewrite: ()=>createI18nUrlRewrite
+});
+const localised_urls_namespaceObject = require("@modern-js/runtime-extensions/localised-urls");
+const external_requestLanguage_js_namespaceObject = require("./requestLanguage.js");
+const createI18nUrlRewrite = (options)=>{
+    const { languages, getLanguage, localisedUrls, onLanguageDetected } = options;
+    const languageList = [
+        ...languages
+    ];
+    return {
+        input: ({ url })=>{
+            const pathname = url.pathname;
+            if (onLanguageDetected) {
+                const segments = pathname.split('/').filter(Boolean);
+                const firstSegment = segments[0];
+                const detected = firstSegment ? languageList.find((language)=>language.toLowerCase() === firstSegment.toLowerCase()) : void 0;
+                if (detected) onLanguageDetected(detected);
+            }
+            url.pathname = (0, localised_urls_namespaceObject.canonicalTargetPathname)(pathname, languageList, localisedUrls);
+            return url;
+        },
+        output: ({ url })=>{
+            url.pathname = (0, localised_urls_namespaceObject.localiseTargetPathname)(url.pathname, (0, external_requestLanguage_js_namespaceObject.languageFromPathname)(url.pathname, languageList) ?? getLanguage(), languageList, localisedUrls);
+            return url;
+        }
+    };
+};
+exports.createI18nUrlRewrite = __webpack_exports__.createI18nUrlRewrite;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createI18nUrlRewrite"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/index.mjs

@@ -1,4 +1,4 @@
+export * from "@modern-js/runtime-extensions/localised-urls";
 export * from "./language-sync/controller.mjs";
 export * from "./language-sync/react.mjs";
 export * from "./localeRedirectPolicy.mjs";
-export * from "./localisedUrls/index.mjs";

package/dist/esm/localeRedirectPolicy.mjs

@@ -1,4 +1,4 @@
-import { isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchesPathPrefix, shouldSkipLocaleRedirect, stripLanguagePrefix } from "./localisedUrls/index.mjs";
+import { isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchesPathPrefix, shouldSkipLocaleRedirect, stripLanguagePrefix } from "@modern-js/runtime-extensions/localised-urls";
 const stripUrlPathPrefix = (pathname, urlPath)=>{
     const basePath = urlPath.replace('/*', '');
     if (!basePath || '/' === basePath) return pathname;

package/dist/esm/native.mjs

@@ -0,0 +1,112 @@
+import i18next from "i18next";
+import { createLatestLanguageSyncBinding } from "./language-sync/controller.mjs";
+import { createRequestLanguageRedirect, languageFromPathname, resolveRequestLanguage } from "./requestLanguage.mjs";
+import { createI18nSsrHandoffInlineData, readI18nSsrHandoff } from "./ssrLanguageHandoff.mjs";
+import { createI18nUrlRewrite } from "./urlRewrite.mjs";
+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 = ()=>languageFromPathname(window.location.pathname, routing.languages, routing.basePath);
+    return {
+        languages: routing.languages,
+        ...void 0 === routing.localisedUrls ? {} : {
+            localisedUrls: routing.localisedUrls
+        },
+        resolveRequest: (request)=>resolveRequestLanguage(request, routing),
+        redirect: createRequestLanguageRedirect,
+        async create (language, resources) {
+            const instance = i18next.createInstance();
+            instance.use(backend);
+            await instance.init({
+                ...initOptions,
+                lng: language,
+                fallbackLng: routing.fallbackLanguage,
+                supportedLngs: [
+                    ...routing.languages
+                ],
+                ns: namespaces,
+                defaultNS: defaultNamespace,
+                partialBundledLanguages: true,
+                resources: resources ? {
+                    [language]: resources
+                } : {},
+                interpolation: {
+                    escapeValue: false,
+                    ...initOptions.interpolation
+                }
+            });
+            return instance;
+        },
+        rewrite: (getLanguage)=>createI18nUrlRewrite({
+                languages: routing.languages,
+                getLanguage,
+                localisedUrls: routing.localisedUrls
+            }),
+        handoff (language, instance) {
+            return createI18nSsrHandoffInlineData({
+                language,
+                ...instance ? {
+                    resources: Object.fromEntries(namespaces.map((namespace)=>[
+                            namespace,
+                            instance.getResourceBundle(language, namespace) ?? {}
+                        ]))
+                } : {}
+            });
+        },
+        clientHandoff () {
+            const handoff = readI18nSsrHandoff();
+            if (handoff && routing.languages.includes(handoff.language)) return handoff;
+            return {
+                language: currentLanguage() ?? routing.fallbackLanguage
+            };
+        },
+        syncWithRouter (router, instance) {
+            const sync = 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 = 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);
+        }
+    };
+}
+export { createNativeI18n };

package/dist/esm/paths.mjs

@@ -1,5 +1,10 @@
+import { canonicalTargetPathname, localiseTargetPathname } from "@modern-js/runtime-extensions/localised-urls";
 import { splitUrlTarget } from "@modern-js/runtime-utils/url";
-import { canonicalTargetPathname, localiseTargetPathname } from "./localisedUrls/index.mjs";
+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 } = splitUrlTarget(target);
     return `${localiseTargetPathname(pathname, language, languages, localisedUrls)}${search}${hash}`;
@@ -9,4 +14,4 @@ const canonicalPath = (target, config)=>{
     const { pathname, search, hash } = splitUrlTarget(target);
     return `${canonicalTargetPathname(pathname, config.languages, config.localisedUrls)}${search}${hash}`;
 };
-export { buildLocalizedUrl, canonicalPath, localizePath };
+export { buildLocalizedUrl, canonicalPath, configuredLanguage, localizePath };

package/dist/esm/requestLanguage.mjs

@@ -0,0 +1,148 @@
+import { localiseTargetPathname, shouldSkipLocaleRedirect } from "@modern-js/runtime-extensions/localised-urls";
+const DEFAULT_ORDER = [
+    'querystring',
+    'cookie',
+    'header'
+];
+const normaliseBasePath = (basePath)=>{
+    if (!basePath || '/' === basePath) return '';
+    return `/${basePath.split('/').filter(Boolean).join('/')}`;
+};
+const entryPathname = (pathname, basePath)=>{
+    const base = normaliseBasePath(basePath);
+    if (!base) return pathname || '/';
+    if (pathname === base) return '/';
+    return pathname.startsWith(`${base}/`) ? pathname.slice(base.length) : void 0;
+};
+const baseLanguage = (tag)=>tag.toLowerCase().split(/[-_]/u)[0];
+const compatibleLanguages = (candidate, languages)=>{
+    const value = candidate?.trim().toLowerCase();
+    if (!value) return [];
+    const base = baseLanguage(value);
+    return [
+        ...languages.filter((language)=>language.toLowerCase() === value),
+        ...languages.filter((language)=>language.toLowerCase() === base),
+        ...base === value ? languages.filter((language)=>baseLanguage(language) === value) : []
+    ].filter((language, index, all)=>all.indexOf(language) === index);
+};
+const matchLanguage = (candidate, languages)=>compatibleLanguages(candidate, languages)[0];
+function languageFromPathname(pathname, languages, basePath) {
+    const remaining = entryPathname(pathname, basePath);
+    if (void 0 === remaining) return;
+    const first = remaining.split('/').filter(Boolean)[0];
+    if (!first) return;
+    return languages.find((language)=>language.toLowerCase() === first.toLowerCase());
+}
+const readCookie = (header, name)=>{
+    if (!header) return null;
+    for (const part of header.split(';')){
+        const separator = part.indexOf('=');
+        if (separator < 0) continue;
+        if (part.slice(0, separator).trim() !== name) continue;
+        const raw = part.slice(separator + 1).trim();
+        try {
+            return decodeURIComponent(raw);
+        } catch  {
+            return raw;
+        }
+    }
+    return null;
+};
+const QVALUE = /^(?:0(?:\.\d{0,3})?|1(?:\.0{0,3})?)$/;
+const rangeSpecificity = (range, language)=>{
+    const value = range.toLowerCase().replaceAll('_', '-');
+    const supported = language.toLowerCase().replaceAll('_', '-');
+    if ('*' === value) return 0;
+    if (value === supported) return Number.MAX_SAFE_INTEGER;
+    if (supported.startsWith(`${value}-`)) return 1 + value.split('-').length;
+    if (baseLanguage(value) === supported) return 1;
+};
+const acceptedLanguages = (header, languages)=>{
+    const items = (header ?? '').split(',').map((item, index)=>{
+        const [tag, ...parameters] = item.trim().split(';');
+        const quality = parameters.map((parameter)=>parameter.trim()).find((parameter)=>parameter.toLowerCase().startsWith('q='));
+        const value = quality?.slice(2).trim();
+        const q = void 0 === value ? 1 : QVALUE.test(value) ? Number(value) : 0 / 0;
+        return {
+            tag: tag.trim(),
+            q,
+            index
+        };
+    }).filter((item)=>item.tag && !Number.isNaN(item.q));
+    const ranked = languages.flatMap((language, position)=>{
+        let best;
+        for (const item of items){
+            const specificity = rangeSpecificity(item.tag, language);
+            if (void 0 !== specificity && (!best || specificity > best.specificity)) best = {
+                q: item.q,
+                index: item.index,
+                specificity
+            };
+        }
+        return best && best.q > 0 ? [
+            {
+                language,
+                position,
+                ...best
+            }
+        ] : [];
+    });
+    return ranked.sort((left, right)=>right.q - left.q || left.index - right.index || right.specificity - left.specificity || left.position - right.position).map((entry)=>entry.language);
+};
+function detectRequestLanguage(request, languages, detection = {}) {
+    const url = new URL(request.url);
+    for (const detector of detection.order ?? DEFAULT_ORDER){
+        let language;
+        if ('querystring' === detector) language = matchLanguage(url.searchParams.get(detection.lookupQuerystring ?? 'lng'), languages);
+        else if ('cookie' === detector) language = matchLanguage(readCookie(request.headers.get('cookie'), detection.lookupCookie ?? 'i18next'), languages);
+        else if ('header' === detector) language = acceptedLanguages(request.headers.get(detection.lookupHeader ?? 'accept-language'), languages).find(Boolean);
+        if (language) return language;
+    }
+}
+function resolveRequestLanguage(request, options) {
+    const { languages, fallbackLanguage } = options;
+    const url = new URL(request.url);
+    const fromPath = languageFromPathname(url.pathname, languages, options.basePath);
+    if (fromPath) return {
+        kind: 'language',
+        language: fromPath
+    };
+    const detected = (false === options.detect ? void 0 : detectRequestLanguage(request, languages, options.detection)) ?? fallbackLanguage;
+    const remaining = entryPathname(url.pathname, options.basePath);
+    if (void 0 === remaining || shouldSkipLocaleRedirect(remaining, [
+        ...languages
+    ], options.ignoreRedirectRoutes)) {
+        const vary = (false === options.detect ? [] : options.detection?.order ?? DEFAULT_ORDER).flatMap((detector)=>'header' === detector ? [
+                options.detection?.lookupHeader ?? 'Accept-Language'
+            ] : 'cookie' === detector ? [
+                'Cookie'
+            ] : []);
+        return vary.length ? {
+            kind: 'language',
+            language: detected,
+            vary
+        } : {
+            kind: 'language',
+            language: detected
+        };
+    }
+    const localized = localiseTargetPathname(remaining, detected, [
+        ...languages
+    ], options.localisedUrls);
+    return {
+        kind: 'redirect',
+        language: detected,
+        location: `${normaliseBasePath(options.basePath)}${localized}${url.search}`
+    };
+}
+function createRequestLanguageRedirect(location) {
+    return new Response(null, {
+        status: 302,
+        headers: {
+            'cache-control': 'private, no-store',
+            location,
+            vary: 'Accept-Language, Cookie'
+        }
+    });
+}
+export { createRequestLanguageRedirect, detectRequestLanguage, languageFromPathname, resolveRequestLanguage };

package/dist/esm/router-navigation/adapter.mjs

@@ -0,0 +1,55 @@
+import { jsx } from "react/jsx-runtime";
+import { RuntimeContext } from "@modern-js/runtime";
+import { InternalRuntimeContext } from "@modern-js/runtime/context";
+import { getRouterRuntimeState, subscribeRouterRuntimeState } from "@modern-js/runtime-extensions/router-state";
+import { useCallback, useContext, useSyncExternalStore } from "react";
+const subscribeNone = ()=>()=>{};
+const getEmptySnapshot = ()=>null;
+const createI18nRouterNavigation = ({ I18nNavigationProvider, useNativeI18nRouterAdapter })=>{
+    const NavigationProvider = I18nNavigationProvider;
+    const useIntegratedRouterAdapter = ()=>{
+        const runtimeContext = useContext(RuntimeContext);
+        const internalContext = useContext(InternalRuntimeContext);
+        const native = useNativeI18nRouterAdapter();
+        const getCapability = useCallback(()=>getRouterRuntimeState(internalContext)?.navigation ?? getRouterRuntimeState(runtimeContext)?.navigation, [
+            internalContext,
+            runtimeContext
+        ]);
+        const subscribeCapability = useCallback((update)=>{
+            const stopInternal = subscribeRouterRuntimeState(internalContext, update);
+            const stopPublic = internalContext === runtimeContext ? void 0 : subscribeRouterRuntimeState(runtimeContext, update);
+            return ()=>{
+                stopInternal();
+                stopPublic?.();
+            };
+        }, [
+            internalContext,
+            runtimeContext
+        ]);
+        const capability = useSyncExternalStore(subscribeCapability, getCapability, getCapability);
+        const snapshot = useSyncExternalStore(capability?.subscribe ?? subscribeNone, capability?.getSnapshot ?? getEmptySnapshot, capability?.getSnapshot ?? getEmptySnapshot);
+        if (native.hasRouter || !capability || !snapshot) return native;
+        const internalState = getRouterRuntimeState(internalContext);
+        return {
+            framework: internalState?.navigation === capability ? internalState.framework : getRouterRuntimeState(runtimeContext)?.framework,
+            hasRouter: true,
+            ...snapshot,
+            navigate: capability.navigate,
+            Link: capability.Link,
+            createLinkProps: capability.createLinkProps
+        };
+    };
+    const I18nRouterNavigationProvider = ({ children })=>{
+        const value = useIntegratedRouterAdapter();
+        const native = useNativeI18nRouterAdapter();
+        return /*#__PURE__*/ jsx(NavigationProvider, {
+            value: value.hasRouter && !native.hasRouter ? value : null,
+            children: children
+        });
+    };
+    return {
+        useIntegratedRouterAdapter,
+        I18nRouterNavigationProvider
+    };
+};
+export { createI18nRouterNavigation };

package/dist/esm/router-navigation/index.mjs

@@ -0,0 +1 @@
+export { createI18nRouterNavigation } from "./adapter.mjs";

package/dist/esm/ssrLanguageHandoff.mjs

@@ -0,0 +1,44 @@
+import { parsePublicData, serializePublicData } from "@modern-js/renderer-core/data";
+import { serializeInlineData } from "@modern-js/renderer-core/document";
+const I18N_SSR_HANDOFF_ELEMENT_ID = '__modernjs_i18n_ssr__';
+function assertPayload(payload) {
+    if ('string' != typeof payload.language || 0 === payload.language.length) throw new TypeError('An i18n SSR handoff payload requires a nonempty language.');
+    if (void 0 !== payload.resources && ('object' != typeof payload.resources || null === payload.resources)) throw new TypeError('An i18n SSR handoff payload resources field must be a plain object.');
+}
+function createI18nSsrHandoffInlineData(payload, options = {}) {
+    assertPayload(payload);
+    return {
+        id: options.id ?? I18N_SSR_HANDOFF_ELEMENT_ID,
+        payload: serializePublicData({
+            language: payload.language,
+            ...payload.resources ? {
+                resources: payload.resources
+            } : {}
+        })
+    };
+}
+function serializeI18nSsrHandoff(payload, options = {}) {
+    return serializeInlineData({
+        ...createI18nSsrHandoffInlineData(payload, options),
+        nonce: options.nonce
+    });
+}
+function isHandoffPayload(value) {
+    return Boolean(value) && 'object' == typeof value && 'string' == typeof value.language;
+}
+function readI18nSsrHandoffFromText(text) {
+    if (!text) return;
+    try {
+        const result = parsePublicData(text);
+        return isHandoffPayload(result) ? result : void 0;
+    } catch  {
+        return;
+    }
+}
+function readI18nSsrHandoff(options = {}) {
+    const doc = options.doc ?? ("u" < typeof document ? void 0 : document);
+    if (!doc) return;
+    const element = doc.getElementById(options.id ?? I18N_SSR_HANDOFF_ELEMENT_ID);
+    return readI18nSsrHandoffFromText(element?.textContent ?? null);
+}
+export { I18N_SSR_HANDOFF_ELEMENT_ID, createI18nSsrHandoffInlineData, readI18nSsrHandoff, readI18nSsrHandoffFromText, serializeI18nSsrHandoff };

package/dist/esm/urlRewrite.mjs

@@ -0,0 +1,26 @@
+import { canonicalTargetPathname, localiseTargetPathname } from "@modern-js/runtime-extensions/localised-urls";
+import { languageFromPathname } from "./requestLanguage.mjs";
+const createI18nUrlRewrite = (options)=>{
+    const { languages, getLanguage, localisedUrls, onLanguageDetected } = options;
+    const languageList = [
+        ...languages
+    ];
+    return {
+        input: ({ url })=>{
+            const pathname = url.pathname;
+            if (onLanguageDetected) {
+                const segments = pathname.split('/').filter(Boolean);
+                const firstSegment = segments[0];
+                const detected = firstSegment ? languageList.find((language)=>language.toLowerCase() === firstSegment.toLowerCase()) : void 0;
+                if (detected) onLanguageDetected(detected);
+            }
+            url.pathname = canonicalTargetPathname(pathname, languageList, localisedUrls);
+            return url;
+        },
+        output: ({ url })=>{
+            url.pathname = localiseTargetPathname(url.pathname, languageFromPathname(url.pathname, languageList) ?? getLanguage(), languageList, localisedUrls);
+            return url;
+        }
+    };
+};
+export { createI18nUrlRewrite };

package/dist/esm-node/index.mjs

@@ -1,5 +1,5 @@
 import "node:module";
+export * from "@modern-js/runtime-extensions/localised-urls";
 export * from "./language-sync/controller.mjs";
 export * from "./language-sync/react.mjs";
 export * from "./localeRedirectPolicy.mjs";
-export * from "./localisedUrls/index.mjs";

package/dist/esm-node/localeRedirectPolicy.mjs

@@ -1,5 +1,5 @@
 import "node:module";
-import { isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchesPathPrefix, shouldSkipLocaleRedirect, stripLanguagePrefix } from "./localisedUrls/index.mjs";
+import { isDefaultLocaleRedirectSkipPath, localiseTargetPathname, matchesPathPrefix, shouldSkipLocaleRedirect, stripLanguagePrefix } from "@modern-js/runtime-extensions/localised-urls";
 const stripUrlPathPrefix = (pathname, urlPath)=>{
     const basePath = urlPath.replace('/*', '');
     if (!basePath || '/' === basePath) return pathname;