@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.2 → 3.9.0-ultramodern.20

package/dist/cjs/workspaceEvents.js

@@ -0,0 +1,159 @@
+"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 ultramodernWorkspaceEventNames = {
+    navigate: 'ultramodern:navigate',
+    performanceSignal: 'ultramodern:performance-signal',
+    remoteReady: 'ultramodern:remote-ready',
+    routeSettled: 'ultramodern:route-settled'
+};
+class UltramodernWorkspaceEventValidationError {
+    constructor(eventName, payload){
+        this.name = 'UltramodernWorkspaceEventValidationError';
+        this.message = `Invalid payload for UltraModern workspace event "${eventName}"`;
+        this.eventName = eventName;
+        this.payload = payload;
+    }
+}
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const isNonEmptyString = (value)=>'string' == typeof value && value.trim().length > 0;
+const isNonNegativeNumber = (value)=>'number' == typeof value && Number.isFinite(value) && value >= 0;
+const isUltramodernWorkspaceLocale = (value)=>'en' === value || 'cs' === value;
+const isPerformanceReadinessSignalId = (value)=>'bfcache' === value || 'core-web-vitals-rum' === value || 'duplicate-prefetch-warmup' === value || 'cache-policy-sanity' === value || 'save-data-behavior' === value || 'cloudflare-ssr-cache-hints' === value;
+const isPerformanceReadinessSignalStatus = (value)=>'pass' === value || 'warn' === value || 'fail' === value;
+const hasOptionalString = (value, key)=>void 0 === value[key] || isNonEmptyString(value[key]);
+const hasOptionalBoolean = (value, key)=>void 0 === value[key] || 'boolean' == typeof value[key];
+const hasOptionalRecord = (value, key)=>void 0 === value[key] || isRecord(value[key]);
+const hasOptionalNonNegativeNumber = (value, key)=>void 0 === value[key] || isNonNegativeNumber(value[key]);
+const hasOptionalLocale = (value, key)=>void 0 === value[key] || isUltramodernWorkspaceLocale(value[key]);
+const isUltramodernNavigatePayload = (payload)=>isRecord(payload) && isNonEmptyString(payload.to) && hasOptionalBoolean(payload, 'replace') && hasOptionalRecord(payload, 'state');
+const isUltramodernRouteSettledPayload = (payload)=>isRecord(payload) && isNonEmptyString(payload.pathname) && hasOptionalLocale(payload, 'locale') && hasOptionalString(payload, 'title');
+const isUltramodernRemoteReadyPayload = (payload)=>isRecord(payload) && isNonEmptyString(payload.appId) && hasOptionalString(payload, 'build') && hasOptionalString(payload, 'surface') && hasOptionalString(payload, 'version');
+const isUltramodernPerformanceSignalPayload = (payload)=>isRecord(payload) && isPerformanceReadinessSignalId(payload.signalId) && isPerformanceReadinessSignalStatus(payload.status) && hasOptionalNonNegativeNumber(payload, 'durationMs') && hasOptionalRecord(payload, 'detail');
+const ultramodernWorkspaceEventValidators = {
+    [ultramodernWorkspaceEventNames.navigate]: isUltramodernNavigatePayload,
+    [ultramodernWorkspaceEventNames.performanceSignal]: isUltramodernPerformanceSignalPayload,
+    [ultramodernWorkspaceEventNames.remoteReady]: isUltramodernRemoteReadyPayload,
+    [ultramodernWorkspaceEventNames.routeSettled]: isUltramodernRouteSettledPayload
+};
+const isUltramodernWorkspaceEventPayload = (eventName, payload)=>ultramodernWorkspaceEventValidators[eventName](payload);
+const assertUltramodernWorkspaceEventPayload = (eventName, payload)=>{
+    if (!isUltramodernWorkspaceEventPayload(eventName, payload)) throw new UltramodernWorkspaceEventValidationError(eventName, payload);
+    return payload;
+};
+const createUltramodernWorkspaceEvent = (eventName, payload)=>new CustomEvent(eventName, {
+        bubbles: true,
+        composed: true,
+        detail: assertUltramodernWorkspaceEventPayload(eventName, payload)
+    });
+const dispatchUltramodernWorkspaceEvent = (target, eventName, payload)=>target.dispatchEvent(createUltramodernWorkspaceEvent(eventName, payload));
+const onUltramodernWorkspaceEvent = (target, eventName, handler)=>{
+    const listener = (event)=>{
+        if (!('detail' in event)) throw new UltramodernWorkspaceEventValidationError(eventName, void 0);
+        const customEvent = event;
+        handler(assertUltramodernWorkspaceEventPayload(eventName, customEvent.detail), customEvent);
+    };
+    target.addEventListener(eventName, listener);
+    return ()=>{
+        target.removeEventListener(eventName, listener);
+    };
+};
+const dispatchUltramodernNavigate = (target, payload)=>dispatchUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.navigate, payload);
+const dispatchUltramodernRouteSettled = (target, payload)=>dispatchUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.routeSettled, payload);
+const dispatchUltramodernRemoteReady = (target, payload)=>dispatchUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.remoteReady, payload);
+const dispatchUltramodernPerformanceSignal = (target, payload)=>dispatchUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.performanceSignal, payload);
+const onUltramodernNavigate = (target, handler)=>onUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.navigate, handler);
+const onUltramodernRouteSettled = (target, handler)=>onUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.routeSettled, handler);
+const onUltramodernRemoteReady = (target, handler)=>onUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.remoteReady, handler);
+const onUltramodernPerformanceSignal = (target, handler)=>onUltramodernWorkspaceEvent(target, ultramodernWorkspaceEventNames.performanceSignal, handler);
+__webpack_require__.d(__webpack_exports__, {
+    UltramodernWorkspaceEventValidationError: ()=>UltramodernWorkspaceEventValidationError
+}, {
+    assertUltramodernWorkspaceEventPayload: assertUltramodernWorkspaceEventPayload,
+    createUltramodernWorkspaceEvent: createUltramodernWorkspaceEvent,
+    dispatchUltramodernNavigate: dispatchUltramodernNavigate,
+    dispatchUltramodernPerformanceSignal: dispatchUltramodernPerformanceSignal,
+    dispatchUltramodernRemoteReady: dispatchUltramodernRemoteReady,
+    dispatchUltramodernRouteSettled: dispatchUltramodernRouteSettled,
+    dispatchUltramodernWorkspaceEvent: dispatchUltramodernWorkspaceEvent,
+    isUltramodernNavigatePayload: isUltramodernNavigatePayload,
+    isUltramodernPerformanceSignalPayload: isUltramodernPerformanceSignalPayload,
+    isUltramodernRemoteReadyPayload: isUltramodernRemoteReadyPayload,
+    isUltramodernRouteSettledPayload: isUltramodernRouteSettledPayload,
+    isUltramodernWorkspaceEventPayload: isUltramodernWorkspaceEventPayload,
+    onUltramodernNavigate: onUltramodernNavigate,
+    onUltramodernPerformanceSignal: onUltramodernPerformanceSignal,
+    onUltramodernRemoteReady: onUltramodernRemoteReady,
+    onUltramodernRouteSettled: onUltramodernRouteSettled,
+    onUltramodernWorkspaceEvent: onUltramodernWorkspaceEvent,
+    ultramodernWorkspaceEventNames: ultramodernWorkspaceEventNames
+});
+exports.UltramodernWorkspaceEventValidationError = __webpack_exports__.UltramodernWorkspaceEventValidationError;
+exports.assertUltramodernWorkspaceEventPayload = __webpack_exports__.assertUltramodernWorkspaceEventPayload;
+exports.createUltramodernWorkspaceEvent = __webpack_exports__.createUltramodernWorkspaceEvent;
+exports.dispatchUltramodernNavigate = __webpack_exports__.dispatchUltramodernNavigate;
+exports.dispatchUltramodernPerformanceSignal = __webpack_exports__.dispatchUltramodernPerformanceSignal;
+exports.dispatchUltramodernRemoteReady = __webpack_exports__.dispatchUltramodernRemoteReady;
+exports.dispatchUltramodernRouteSettled = __webpack_exports__.dispatchUltramodernRouteSettled;
+exports.dispatchUltramodernWorkspaceEvent = __webpack_exports__.dispatchUltramodernWorkspaceEvent;
+exports.isUltramodernNavigatePayload = __webpack_exports__.isUltramodernNavigatePayload;
+exports.isUltramodernPerformanceSignalPayload = __webpack_exports__.isUltramodernPerformanceSignalPayload;
+exports.isUltramodernRemoteReadyPayload = __webpack_exports__.isUltramodernRemoteReadyPayload;
+exports.isUltramodernRouteSettledPayload = __webpack_exports__.isUltramodernRouteSettledPayload;
+exports.isUltramodernWorkspaceEventPayload = __webpack_exports__.isUltramodernWorkspaceEventPayload;
+exports.onUltramodernNavigate = __webpack_exports__.onUltramodernNavigate;
+exports.onUltramodernPerformanceSignal = __webpack_exports__.onUltramodernPerformanceSignal;
+exports.onUltramodernRemoteReady = __webpack_exports__.onUltramodernRemoteReady;
+exports.onUltramodernRouteSettled = __webpack_exports__.onUltramodernRouteSettled;
+exports.onUltramodernWorkspaceEvent = __webpack_exports__.onUltramodernWorkspaceEvent;
+exports.ultramodernWorkspaceEventNames = __webpack_exports__.ultramodernWorkspaceEventNames;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "UltramodernWorkspaceEventValidationError",
+    "assertUltramodernWorkspaceEventPayload",
+    "createUltramodernWorkspaceEvent",
+    "dispatchUltramodernNavigate",
+    "dispatchUltramodernPerformanceSignal",
+    "dispatchUltramodernRemoteReady",
+    "dispatchUltramodernRouteSettled",
+    "dispatchUltramodernWorkspaceEvent",
+    "isUltramodernNavigatePayload",
+    "isUltramodernPerformanceSignalPayload",
+    "isUltramodernRemoteReadyPayload",
+    "isUltramodernRouteSettledPayload",
+    "isUltramodernWorkspaceEventPayload",
+    "onUltramodernNavigate",
+    "onUltramodernPerformanceSignal",
+    "onUltramodernRemoteReady",
+    "onUltramodernRouteSettled",
+    "onUltramodernWorkspaceEvent",
+    "ultramodernWorkspaceEventNames"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/buildIdentity.mjs

@@ -0,0 +1,35 @@
+function readBuildValue(read, fallback) {
+    try {
+        return read();
+    } catch (error) {
+        if (null !== error && 'object' == typeof error && 'name' in error && 'ReferenceError' === error.name) return fallback;
+        throw error;
+    }
+}
+function resolveUltramodernBuildArtifact(artifact, readers) {
+    const buildMarker = readers ? readBuildValue(readers.buildMarker, artifact.deliveryUnit.buildMarker) : artifact.deliveryUnit.buildMarker;
+    const sourceRevision = readers ? readBuildValue(readers.sourceRevision, artifact.deliveryUnit.sourceRevision) : artifact.deliveryUnit.sourceRevision;
+    const identity = {
+        build: buildMarker,
+        buildMarker,
+        sourceRevision
+    };
+    return {
+        ...artifact,
+        deliveryUnit: {
+            ...artifact.deliveryUnit,
+            ...identity
+        },
+        surfaces: {
+            api: {
+                ...artifact.surfaces.api,
+                ...identity
+            },
+            ui: {
+                ...artifact.surfaces.ui,
+                ...identity
+            }
+        }
+    };
+}
+export { resolveUltramodernBuildArtifact };

package/dist/esm/contextExtensions.mjs

@@ -0,0 +1,33 @@
+const EXTENSIONS_SLOT = Symbol.for('@modern-js/runtime:context-extensions');
+function getStore(context) {
+    return context[EXTENSIONS_SLOT];
+}
+function ensureStore(context) {
+    const target = context;
+    const store = target[EXTENSIONS_SLOT] ?? new Map();
+    Object.defineProperty(target, EXTENSIONS_SLOT, {
+        configurable: true,
+        enumerable: true,
+        value: store
+    });
+    return store;
+}
+function stripRuntimeContextExtensions(context) {
+    delete context[EXTENSIONS_SLOT];
+}
+function createRuntimeContextExtension(id) {
+    const key = Symbol.for(`@modern-js/runtime:context-extension:${id}`);
+    return {
+        key,
+        get (context) {
+            return getStore(context)?.get(key);
+        },
+        set (context, value) {
+            ensureStore(context).set(key, value);
+        },
+        remove (context) {
+            getStore(context)?.delete(key);
+        }
+    };
+}
+export { createRuntimeContextExtension, stripRuntimeContextExtensions };

package/dist/esm/headRuntime.mjs

@@ -0,0 +1,43 @@
+import { jsx } from "react/jsx-runtime";
+import react from "react";
+import { Helmet, HelmetProvider } from "react-helmet-async";
+import * as __rspack_external__rendererHead_mjs_b8160cc7 from "./rendererHead.mjs";
+function createHeadRuntime() {
+    const HeadContext = /*#__PURE__*/ react.createContext(void 0);
+    const collectServerHelmet = ({ runtimeContext, helmetContext }, props)=>{
+        const createRecord = ()=>__rspack_external__rendererHead_mjs_b8160cc7.createHelmetRecord(react, props);
+        const deriveState = (records)=>__rspack_external__rendererHead_mjs_b8160cc7.deriveHelmetServerState(react, records);
+        const marker = __rspack_external__rendererHead_mjs_b8160cc7.collectHeadState(runtimeContext, createRecord, deriveState, helmetContext);
+        if (void 0 !== marker) return marker;
+        helmetContext.helmet = __rspack_external__rendererHead_mjs_b8160cc7.collectImmediateHelmetState(react, helmetContext, createRecord());
+    };
+    const Head = (props)=>{
+        const state = react.useContext(HeadContext);
+        if (void 0 !== state) return __rspack_external__rendererHead_mjs_b8160cc7.renderHeadMarker(react, collectServerHelmet(state, props));
+        return /*#__PURE__*/ react.createElement(Helmet, props);
+    };
+    const ClientRoot = ({ children })=>{
+        const state = react.useContext(HeadContext);
+        return void 0 === state ? /*#__PURE__*/ jsx(HelmetProvider, {
+            children: children
+        }) : children;
+    };
+    return {
+        Head,
+        wrapServerRoot (root, state) {
+            return /*#__PURE__*/ jsx(HeadContext.Provider, {
+                value: state,
+                children: /*#__PURE__*/ jsx(HelmetProvider, {
+                    context: state.helmetContext,
+                    children: root
+                })
+            });
+        },
+        wrapClientRoot (root) {
+            return /*#__PURE__*/ jsx(ClientRoot, {
+                children: root
+            });
+        }
+    };
+}
+export { createHeadRuntime };

package/dist/esm/helmetContext.mjs

@@ -0,0 +1,13 @@
+import { createRuntimeContextExtension } from "./contextExtensions.mjs";
+const helmetContextExtension = createRuntimeContextExtension('@modern-js/runtime:helmet-context');
+function getHelmetContext(context) {
+    return helmetContextExtension.get(context);
+}
+function ensureHelmetContext(context) {
+    const existing = helmetContextExtension.get(context);
+    if (void 0 !== existing) return existing;
+    const created = {};
+    helmetContextExtension.set(context, created);
+    return created;
+}
+export { ensureHelmetContext, getHelmetContext };

package/dist/esm/index.mjs

@@ -1,4 +1,6 @@
 export * from "./html.mjs";
 export * from "./navigationWarmup.mjs";
+export * from "./prefetchPolicy.mjs";
 export * from "./rendererHead.mjs";
+export * from "./routeHydration.mjs";
 export * from "./shellStream.mjs";

package/dist/esm/localisedLoaderIdentity.mjs

@@ -0,0 +1,13 @@
+function resolveLocalisedLoaderRouteId(routes, requestedId, matchedIds = []) {
+    if (matchedIds.includes(requestedId)) return requestedId;
+    const matched = new Set(matchedIds);
+    const visit = (nodes)=>{
+        for (const route of nodes){
+            if (route.id && matched.has(route.id) && route.modernLocalisedRoute?.id === requestedId) return route.id;
+            const child = route.children && visit(route.children);
+            if (child) return child;
+        }
+    };
+    return visit(routes) ?? requestedId;
+}
+export { resolveLocalisedLoaderRouteId };

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,8 @@
+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 { createLocalisedRouteRewrite } from "./routeIdentity.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 };

package/dist/esm/localisedUrls/patterns.mjs

@@ -0,0 +1,152 @@
+import { normalisePathPattern, normalisePathname } from "./normalise.mjs";
+const escapeRegExp = (value)=>value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const getParamName = (segment)=>segment.slice(1).replace(/\?$/, '');
+const getOrderedPathParamSignature = (pattern)=>normalisePathPattern(pattern).split('/').filter(Boolean).flatMap((segment)=>{
+        if ('*' === segment) return [
+            '*'
+        ];
+        if (!segment.startsWith(':')) return [];
+        return [
+            `:${getParamName(segment)}${segment.endsWith('?') ? '?' : ''}`
+        ];
+    });
+const getPathParamSignature = (pattern)=>getOrderedPathParamSignature(pattern).sort((left, right)=>left < right ? -1 : left > right ? 1 : 0);
+const getPathPatternValidationIssue = (pattern)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const seenParams = new Set();
+    for (const [index, segment] of segments.entries()){
+        if ('*' === segment) {
+            if (index !== segments.length - 1) return 'splat parameter "*" must be the final segment';
+            if (seenParams.has('*')) return 'duplicate splat parameter "*"';
+            seenParams.add('*');
+            continue;
+        }
+        if (!segment.startsWith(':')) continue;
+        const paramName = getParamName(segment);
+        if (seenParams.has(paramName)) return `duplicate path parameter ":${paramName}"`;
+        seenParams.add(paramName);
+    }
+};
+const getPhysicalPathPattern = (pattern)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const physicalSegments = segments.map((segment)=>{
+        if ('*' === segment) return '*';
+        if (segment.startsWith(':')) return segment.endsWith('?') ? ':param?' : ':param';
+        return segment;
+    });
+    return `/${physicalSegments.join('/')}`;
+};
+const compiledPathPatternCache = new Map();
+const compilePathPattern = (pattern)=>{
+    const normalizedPattern = normalisePathPattern(pattern);
+    const cached = compiledPathPatternCache.get(normalizedPattern);
+    if (cached) return cached;
+    const names = [];
+    const segments = normalizedPattern.split('/').filter(Boolean);
+    const source = segments.map((segment)=>{
+        if (segment.startsWith(':')) {
+            names.push(getParamName(segment));
+            const paramPattern = '([^/]+)';
+            return segment.endsWith('?') ? `(?:/${paramPattern})?` : `/${paramPattern}`;
+        }
+        if ('*' === segment) {
+            names.push('*');
+            return '(?:/(.*))?';
+        }
+        return `/${escapeRegExp(segment)}`;
+    }).join('');
+    const compiled = {
+        names,
+        regexp: new RegExp(`^${source || '/'}$`)
+    };
+    compiledPathPatternCache.set(normalizedPattern, compiled);
+    return compiled;
+};
+const getPatternSpecificity = (pattern)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    let staticSegments = 0;
+    let dynamicSegments = 0;
+    let optionalSegments = 0;
+    let splatSegments = 0;
+    for (const segment of segments)if ('*' === segment) splatSegments++;
+    else if (segment.startsWith(':')) {
+        dynamicSegments++;
+        if (segment.endsWith('?')) optionalSegments++;
+    } else staticSegments++;
+    return {
+        staticSegments,
+        dynamicSegments,
+        optionalSegments,
+        splatSegments,
+        totalSegments: segments.length
+    };
+};
+const comparePatternSpecificity = (left, right)=>{
+    const a = getPatternSpecificity(left);
+    const b = getPatternSpecificity(right);
+    return b.staticSegments - a.staticSegments || a.splatSegments - b.splatSegments || a.optionalSegments - b.optionalSegments || b.totalSegments - a.totalSegments || a.dynamicSegments - b.dynamicSegments;
+};
+const haveEqualPatternSpecificity = (left, right)=>0 === comparePatternSpecificity(left, right);
+const doPathPatternsOverlap = (left, right)=>{
+    const leftSegments = normalisePathPattern(left).split('/').filter(Boolean);
+    const rightSegments = normalisePathPattern(right).split('/').filter(Boolean);
+    if (leftSegments.length !== rightSegments.length) return false;
+    return leftSegments.every((leftSegment, index)=>{
+        const rightSegment = rightSegments[index];
+        const leftIsDynamic = '*' === leftSegment || leftSegment.startsWith(':');
+        const rightIsDynamic = '*' === rightSegment || rightSegment.startsWith(':');
+        return leftIsDynamic || rightIsDynamic || leftSegment === rightSegment;
+    });
+};
+const comparePatternNames = (left, right)=>{
+    const normalizedLeft = normalisePathPattern(left);
+    const normalizedRight = normalisePathPattern(right);
+    return normalizedLeft < normalizedRight ? -1 : normalizedLeft > normalizedRight ? 1 : 0;
+};
+const sortPatternsBySpecificity = (patterns)=>patterns.map((pattern, index)=>({
+            pattern,
+            index
+        })).sort((left, right)=>comparePatternSpecificity(left.pattern.pattern, right.pattern.pattern) || comparePatternNames(left.pattern.pattern, right.pattern.pattern) || left.index - right.index).map(({ pattern })=>pattern);
+const decodePathParam = (value)=>{
+    try {
+        return decodeURIComponent(value);
+    } catch  {
+        return null;
+    }
+};
+const encodeSplatParam = (value)=>value.split('/').map(encodeURIComponent).join('/');
+const matchPathPattern = (pathname, pattern)=>{
+    const { names, regexp } = compilePathPattern(pattern);
+    const match = regexp.exec(normalisePathname(pathname));
+    if (!match) return null;
+    const params = {};
+    for(let index = 0; index < names.length; index++){
+        const decoded = decodePathParam(match[index + 1] || '');
+        if (null === decoded) return null;
+        Object.defineProperty(params, names[index], {
+            configurable: true,
+            enumerable: true,
+            value: decoded,
+            writable: true
+        });
+    }
+    return params;
+};
+const buildPathFromPattern = (pattern, params)=>{
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const path = segments.map((segment)=>{
+        if (segment.startsWith(':')) {
+            const paramName = getParamName(segment);
+            const param = Object.hasOwn(params, paramName) ? params[paramName] : void 0;
+            if (void 0 === param || '' === param) {
+                if (segment.endsWith('?')) return '';
+                throw new Error(`Missing required path parameter "${paramName}" for pattern "${normalisePathPattern(pattern)}".`);
+            }
+            return encodeURIComponent(param);
+        }
+        if ('*' === segment) return encodeSplatParam(params['*'] || '');
+        return segment;
+    }).filter(Boolean).join('/');
+    return `/${path}`;
+};
+export { buildPathFromPattern, doPathPatternsOverlap, getOrderedPathParamSignature, getPathParamSignature, getPathPatternValidationIssue, getPhysicalPathPattern, haveEqualPatternSpecificity, matchPathPattern, sortPatternsBySpecificity };

package/dist/esm/localisedUrls/redirect.mjs

@@ -0,0 +1,53 @@
+import { normalisePathname } from "./normalise.mjs";
+import { stripLanguagePrefix } from "./pathname.mjs";
+const DEFAULT_LOCALE_REDIRECT_SKIP_RULES = [
+    {
+        type: 'exact',
+        path: '/backend-mf-manifest.json'
+    },
+    {
+        type: 'exact',
+        path: '/mf-manifest.json'
+    },
+    {
+        type: 'exact',
+        path: '/mf-stats.json'
+    },
+    {
+        type: 'pattern',
+        path: /^\/(?:backendRemoteEntry(?:\.[a-zA-Z0-9_-]+)?\.cjs|remoteEntry(?:\.[a-zA-Z0-9_-]+)?\.js)$/
+    },
+    {
+        type: 'prefix',
+        path: '/static/'
+    },
+    {
+        type: 'prefix',
+        path: '/upload/'
+    }
+];
+const stripTrailingSlash = (pathname)=>pathname.length > 1 ? pathname.replace(/\/+$/, '') : pathname;
+const matchesPathPrefix = (pathname, prefix)=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const normalizedPrefix = stripTrailingSlash(normalisePathname(prefix));
+    return normalizedPathname === normalizedPrefix || normalizedPathname.startsWith(`${normalizedPrefix}/`);
+};
+const matchesSkipRule = (pathname, rule)=>{
+    if ('exact' === rule.type) return normalisePathname(pathname) === normalisePathname(rule.path);
+    if ('pattern' === rule.type) return rule.path.test(normalisePathname(pathname));
+    return matchesPathPrefix(pathname, rule.path);
+};
+const isDefaultLocaleRedirectSkipPath = (pathname, languages = [])=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const pathWithoutLanguage = stripLanguagePrefix(normalizedPathname, languages);
+    return DEFAULT_LOCALE_REDIRECT_SKIP_RULES.some((rule)=>matchesSkipRule(pathWithoutLanguage, rule));
+};
+const shouldSkipLocaleRedirect = (pathname, languages = [], ignoreRedirectRoutes)=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const pathWithoutLanguage = stripLanguagePrefix(normalizedPathname, languages);
+    if (isDefaultLocaleRedirectSkipPath(pathWithoutLanguage)) return true;
+    if (!ignoreRedirectRoutes) return false;
+    if ('function' == typeof ignoreRedirectRoutes) return ignoreRedirectRoutes(pathWithoutLanguage);
+    return ignoreRedirectRoutes.some((pattern)=>matchesPathPrefix(pathWithoutLanguage, pattern));
+};
+export { DEFAULT_LOCALE_REDIRECT_SKIP_RULES, isDefaultLocaleRedirectSkipPath, matchesPathPrefix, shouldSkipLocaleRedirect };

package/dist/esm/localisedUrls/resolve.mjs

@@ -0,0 +1,37 @@
+import { normalisePathname } from "./normalise.mjs";
+import { buildPathFromPattern, matchPathPattern, sortPatternsBySpecificity } from "./patterns.mjs";
+const getCanonicalCandidates = (localisedUrls)=>sortPatternsBySpecificity(Object.entries(localisedUrls).map(([canonicalPattern, localisedUrlEntry])=>({
+            pattern: canonicalPattern,
+            canonicalPattern,
+            localisedUrlEntry
+        })));
+const resolveLocalisedUrlPath = (pathname, languages, localisedUrls, options)=>{
+    const normalizedPathname = normalisePathname(pathname);
+    const canonicalCandidates = getCanonicalCandidates(localisedUrls);
+    const candidates = sortPatternsBySpecificity(canonicalCandidates.flatMap(({ canonicalPattern, localisedUrlEntry })=>{
+        const targetPattern = 'localised' === options.mode ? localisedUrlEntry[options.targetLanguage] : canonicalPattern;
+        if (!targetPattern) return [];
+        const sourcePatterns = new Set([
+            canonicalPattern,
+            ...languages.map((language)=>localisedUrlEntry[language]).filter((sourcePattern)=>Boolean(sourcePattern))
+        ]);
+        return Array.from(sourcePatterns, (sourcePattern)=>({
+                pattern: sourcePattern,
+                sourcePattern,
+                targetPattern
+            }));
+    }));
+    for (const { sourcePattern, targetPattern } of candidates){
+        const params = matchPathPattern(normalizedPathname, sourcePattern);
+        if (params) return buildPathFromPattern(targetPattern, params);
+    }
+    return normalizedPathname;
+};
+const resolveLocalisedPath = (pathname, targetLanguage, languages, localisedUrls)=>resolveLocalisedUrlPath(pathname, languages, localisedUrls, {
+        mode: 'localised',
+        targetLanguage
+    });
+const resolveCanonicalLocalisedPath = (pathname, languages, localisedUrls)=>resolveLocalisedUrlPath(pathname, languages, localisedUrls, {
+        mode: 'canonical'
+    });
+export { resolveCanonicalLocalisedPath, resolveLocalisedPath };