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

package/tests/reactLanguageSync.test.tsx

@@ -1,4 +1,4 @@
-import React, { act, Suspense, startTransition } from 'react';
+import { act, Suspense, startTransition } from 'react';
 import { createRoot } from 'react-dom/client';
 import { useLatestLanguageSync } from '../src/language-sync/react';
 
@@ -7,6 +7,14 @@ interface Target {
   language: string;
 }
 
+beforeEach(() => {
+  rstest.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true);
+});
+
+afterEach(() => {
+  rstest.unstubAllGlobals();
+});
+
 test('an abandoned suspended render cannot publish an uncommitted target', async () => {
   let resolveFirst!: () => void;
   const firstChange = new Promise<void>(resolve => {
@@ -14,6 +22,7 @@ test('an abandoned suspended render cannot publish an uncommitted target', async
   });
   const changes: string[] = [];
   const commits: string[] = [];
+  let suspended = false;
   const neverSettles = new Promise<never>(() => undefined);
   const first = { id: 'first', language: 'en' };
   const speculative = { id: 'speculative', language: 'en' };
@@ -41,6 +50,7 @@ test('an abandoned suspended render cannot publish an uncommitted target', async
       },
     });
     if (suspend) {
+      suspended = true;
       throw neverSettles;
     }
     return <main>{target.id}</main>;
@@ -49,7 +59,11 @@ test('an abandoned suspended render cannot publish an uncommitted target', async
   const container = document.createElement('div');
   const root = createRoot(container);
   await act(async () => {
-    root.render(<Harness target={first} />);
+    root.render(
+      <Suspense fallback={<p>loading</p>}>
+        <Harness target={first} />
+      </Suspense>,
+    );
   });
   expect(changes).toEqual(['first']);
 
@@ -64,6 +78,11 @@ test('an abandoned suspended render cannot publish an uncommitted target', async
     await Promise.resolve();
   });
 
+  expect(suspended).toBe(true);
+  expect(container.textContent).toBe('first');
+  expect(changes).toEqual(['first']);
+  expect(commits).toEqual([]);
+
   await act(async () => {
     resolveFirst();
     await firstChange;

package/tests/routerNavigation.test.tsx

@@ -0,0 +1,80 @@
+import {
+  InternalRuntimeContext,
+  RuntimeContext,
+} from '@modern-js/runtime/context';
+import {
+  applyRouterRuntimeState,
+  type RouterNavigationCapability,
+} from '@modern-js/runtime-extensions/router-state';
+import React, { act, createContext, useContext, useEffect } from 'react';
+import { createRoot } from 'react-dom/client';
+import {
+  createI18nRouterNavigation,
+  type I18nRouterAdapterShape,
+} from '../src/router-navigation/adapter';
+
+test('late navigation installation preserves the mounted router and native fallback', async () => {
+  rstest.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true);
+  const context = {} as React.ContextType<typeof InternalRuntimeContext>;
+  const navigationContext = createContext<I18nRouterAdapterShape | null>(null);
+  const native: I18nRouterAdapterShape = {
+    hasRouter: false,
+    location: null,
+    navigate: null,
+    Link: null,
+    params: {},
+  };
+  const { I18nRouterNavigationProvider } = createI18nRouterNavigation({
+    I18nNavigationProvider: navigationContext.Provider,
+    useNativeI18nRouterAdapter: () => native,
+  });
+  const snapshot = {
+    location: { pathname: '/cs/produkty/bota', search: '', hash: '' },
+    params: { lang: 'cs', slug: 'bota' },
+  };
+  const navigation: RouterNavigationCapability = {
+    getSnapshot: () => snapshot,
+    subscribe: () => () => {},
+    navigate: () => {},
+    Link: () => null,
+  };
+  const mounted = rstest.fn();
+  const unmounted = rstest.fn();
+  const Router = () => {
+    const adapter = useContext(navigationContext);
+    useEffect(() => {
+      mounted();
+      return unmounted;
+    }, []);
+    return <p>{adapter?.location?.pathname ?? 'native fallback'}</p>;
+  };
+  const container = document.createElement('div');
+  const root = createRoot(container);
+  try {
+    await act(async () => {
+      root.render(
+        <InternalRuntimeContext.Provider value={context}>
+          <RuntimeContext.Provider value={context}>
+            <I18nRouterNavigationProvider>
+              <Router />
+            </I18nRouterNavigationProvider>
+          </RuntimeContext.Provider>
+        </InternalRuntimeContext.Provider>,
+      );
+    });
+    expect(container.textContent).toBe('native fallback');
+    await act(async () => {
+      applyRouterRuntimeState(context, { framework: 'tanstack', navigation });
+    });
+    expect(container.textContent).toBe('/cs/produkty/bota');
+    await act(async () => {
+      applyRouterRuntimeState(context, { navigation: undefined });
+    });
+    expect(container.textContent).toBe('native fallback');
+    expect(mounted).toHaveBeenCalledTimes(1);
+    expect(unmounted).not.toHaveBeenCalled();
+  } finally {
+    await act(async () => root.unmount());
+    rstest.unstubAllGlobals();
+  }
+});

package/dist/cjs/localisedUrls/index.js

@@ -1,91 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    DEFAULT_LOCALE_REDIRECT_SKIP_RULES: ()=>external_redirect_js_namespaceObject.DEFAULT_LOCALE_REDIRECT_SKIP_RULES,
-    applyLocalisedUrlsToRoutes: ()=>external_routes_js_namespaceObject.applyLocalisedUrlsToRoutes,
-    buildPathFromPattern: ()=>external_patterns_js_namespaceObject.buildPathFromPattern,
-    canonicalTargetPathname: ()=>external_pathname_js_namespaceObject.canonicalTargetPathname,
-    isDefaultLocaleRedirectSkipPath: ()=>external_redirect_js_namespaceObject.isDefaultLocaleRedirectSkipPath,
-    localiseTargetPathname: ()=>external_pathname_js_namespaceObject.localiseTargetPathname,
-    matchPathPattern: ()=>external_patterns_js_namespaceObject.matchPathPattern,
-    matchesPathPrefix: ()=>external_redirect_js_namespaceObject.matchesPathPrefix,
-    normalisePathPattern: ()=>external_normalise_js_namespaceObject.normalisePathPattern,
-    normalisePathname: ()=>external_normalise_js_namespaceObject.normalisePathname,
-    resolveCanonicalLocalisedPath: ()=>external_resolve_js_namespaceObject.resolveCanonicalLocalisedPath,
-    resolveLocalisedPath: ()=>external_resolve_js_namespaceObject.resolveLocalisedPath,
-    resolveLocalisedUrlsConfig: ()=>external_config_js_namespaceObject.resolveLocalisedUrlsConfig,
-    shouldSkipLocaleRedirect: ()=>external_redirect_js_namespaceObject.shouldSkipLocaleRedirect,
-    stripLanguagePrefix: ()=>external_pathname_js_namespaceObject.stripLanguagePrefix,
-    validateLocalisedUrls: ()=>external_routes_js_namespaceObject.validateLocalisedUrls
-});
-const external_config_js_namespaceObject = require("./config.js");
-const external_normalise_js_namespaceObject = require("./normalise.js");
-const external_pathname_js_namespaceObject = require("./pathname.js");
-const external_patterns_js_namespaceObject = require("./patterns.js");
-const external_redirect_js_namespaceObject = require("./redirect.js");
-const external_resolve_js_namespaceObject = require("./resolve.js");
-const external_routes_js_namespaceObject = require("./routes.js");
-exports.DEFAULT_LOCALE_REDIRECT_SKIP_RULES = __webpack_exports__.DEFAULT_LOCALE_REDIRECT_SKIP_RULES;
-exports.applyLocalisedUrlsToRoutes = __webpack_exports__.applyLocalisedUrlsToRoutes;
-exports.buildPathFromPattern = __webpack_exports__.buildPathFromPattern;
-exports.canonicalTargetPathname = __webpack_exports__.canonicalTargetPathname;
-exports.isDefaultLocaleRedirectSkipPath = __webpack_exports__.isDefaultLocaleRedirectSkipPath;
-exports.localiseTargetPathname = __webpack_exports__.localiseTargetPathname;
-exports.matchPathPattern = __webpack_exports__.matchPathPattern;
-exports.matchesPathPrefix = __webpack_exports__.matchesPathPrefix;
-exports.normalisePathPattern = __webpack_exports__.normalisePathPattern;
-exports.normalisePathname = __webpack_exports__.normalisePathname;
-exports.resolveCanonicalLocalisedPath = __webpack_exports__.resolveCanonicalLocalisedPath;
-exports.resolveLocalisedPath = __webpack_exports__.resolveLocalisedPath;
-exports.resolveLocalisedUrlsConfig = __webpack_exports__.resolveLocalisedUrlsConfig;
-exports.shouldSkipLocaleRedirect = __webpack_exports__.shouldSkipLocaleRedirect;
-exports.stripLanguagePrefix = __webpack_exports__.stripLanguagePrefix;
-exports.validateLocalisedUrls = __webpack_exports__.validateLocalisedUrls;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "DEFAULT_LOCALE_REDIRECT_SKIP_RULES",
-    "applyLocalisedUrlsToRoutes",
-    "buildPathFromPattern",
-    "canonicalTargetPathname",
-    "isDefaultLocaleRedirectSkipPath",
-    "localiseTargetPathname",
-    "matchPathPattern",
-    "matchesPathPrefix",
-    "normalisePathPattern",
-    "normalisePathname",
-    "resolveCanonicalLocalisedPath",
-    "resolveLocalisedPath",
-    "resolveLocalisedUrlsConfig",
-    "shouldSkipLocaleRedirect",
-    "stripLanguagePrefix",
-    "validateLocalisedUrls"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/cjs/localisedUrls/normalise.js

@@ -1,87 +0,0 @@
-"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 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] || '');
-};
-__webpack_require__.d(__webpack_exports__, {}, {
-    getLeadingLocaleParam: getLeadingLocaleParam,
-    normalisePathPattern: normalisePathPattern,
-    normalisePathname: normalisePathname,
-    normaliseRoutePath: normaliseRoutePath,
-    stripLeadingLocaleParam: stripLeadingLocaleParam
-});
-exports.getLeadingLocaleParam = __webpack_exports__.getLeadingLocaleParam;
-exports.normalisePathPattern = __webpack_exports__.normalisePathPattern;
-exports.normalisePathname = __webpack_exports__.normalisePathname;
-exports.normaliseRoutePath = __webpack_exports__.normaliseRoutePath;
-exports.stripLeadingLocaleParam = __webpack_exports__.stripLeadingLocaleParam;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "getLeadingLocaleParam",
-    "normalisePathPattern",
-    "normalisePathname",
-    "normaliseRoutePath",
-    "stripLeadingLocaleParam"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/cjs/localisedUrls/pathname.js

@@ -1,68 +0,0 @@
-"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__, {
-    canonicalTargetPathname: ()=>canonicalTargetPathname,
-    localiseTargetPathname: ()=>localiseTargetPathname,
-    stripLanguagePrefix: ()=>stripLanguagePrefix
-});
-const external_config_js_namespaceObject = require("./config.js");
-const external_resolve_js_namespaceObject = require("./resolve.js");
-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 = (0, external_config_js_namespaceObject.resolveLocalisedUrlsConfig)(localisedUrls);
-    const resolvedPath = localisedUrlsConfig.enabled ? (0, external_resolve_js_namespaceObject.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 = (0, external_config_js_namespaceObject.resolveLocalisedUrlsConfig)(localisedUrls);
-    return localisedUrlsConfig.enabled ? (0, external_resolve_js_namespaceObject.resolveCanonicalLocalisedPath)(pathWithoutLanguage, languages, localisedUrlsConfig.map) : pathWithoutLanguage;
-};
-exports.canonicalTargetPathname = __webpack_exports__.canonicalTargetPathname;
-exports.localiseTargetPathname = __webpack_exports__.localiseTargetPathname;
-exports.stripLanguagePrefix = __webpack_exports__.stripLanguagePrefix;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "canonicalTargetPathname",
-    "localiseTargetPathname",
-    "stripLanguagePrefix"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/cjs/localisedUrls/patterns.js

@@ -1,214 +0,0 @@
-"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__, {
-    buildPathFromPattern: ()=>buildPathFromPattern,
-    doPathPatternsOverlap: ()=>doPathPatternsOverlap,
-    getOrderedPathParamSignature: ()=>getOrderedPathParamSignature,
-    getPathParamSignature: ()=>getPathParamSignature,
-    getPathPatternValidationIssue: ()=>getPathPatternValidationIssue,
-    getPhysicalPathPattern: ()=>getPhysicalPathPattern,
-    haveEqualPatternSpecificity: ()=>haveEqualPatternSpecificity,
-    matchPathPattern: ()=>matchPathPattern,
-    sortPatternsBySpecificity: ()=>sortPatternsBySpecificity
-});
-const external_normalise_js_namespaceObject = require("./normalise.js");
-const escapeRegExp = (value)=>value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-const getParamName = (segment)=>segment.slice(1).replace(/\?$/, '');
-const getOrderedPathParamSignature = (pattern)=>(0, external_normalise_js_namespaceObject.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 = (0, external_normalise_js_namespaceObject.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 = (0, external_normalise_js_namespaceObject.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 = (0, external_normalise_js_namespaceObject.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 = (0, external_normalise_js_namespaceObject.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 = (0, external_normalise_js_namespaceObject.normalisePathPattern)(left).split('/').filter(Boolean);
-    const rightSegments = (0, external_normalise_js_namespaceObject.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 = (0, external_normalise_js_namespaceObject.normalisePathPattern)(left);
-    const normalizedRight = (0, external_normalise_js_namespaceObject.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((0, external_normalise_js_namespaceObject.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 = (0, external_normalise_js_namespaceObject.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 "${(0, external_normalise_js_namespaceObject.normalisePathPattern)(pattern)}".`);
-            }
-            return encodeURIComponent(param);
-        }
-        if ('*' === segment) return encodeSplatParam(params['*'] || '');
-        return segment;
-    }).filter(Boolean).join('/');
-    return `/${path}`;
-};
-exports.buildPathFromPattern = __webpack_exports__.buildPathFromPattern;
-exports.doPathPatternsOverlap = __webpack_exports__.doPathPatternsOverlap;
-exports.getOrderedPathParamSignature = __webpack_exports__.getOrderedPathParamSignature;
-exports.getPathParamSignature = __webpack_exports__.getPathParamSignature;
-exports.getPathPatternValidationIssue = __webpack_exports__.getPathPatternValidationIssue;
-exports.getPhysicalPathPattern = __webpack_exports__.getPhysicalPathPattern;
-exports.haveEqualPatternSpecificity = __webpack_exports__.haveEqualPatternSpecificity;
-exports.matchPathPattern = __webpack_exports__.matchPathPattern;
-exports.sortPatternsBySpecificity = __webpack_exports__.sortPatternsBySpecificity;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "buildPathFromPattern",
-    "doPathPatternsOverlap",
-    "getOrderedPathParamSignature",
-    "getPathParamSignature",
-    "getPathPatternValidationIssue",
-    "getPhysicalPathPattern",
-    "haveEqualPatternSpecificity",
-    "matchPathPattern",
-    "sortPatternsBySpecificity"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});