@inlang/paraglide-js 2.0.0-beta.15 → 2.0.0-beta.17

package/dist/compiler/runtime/extract-locale-from-pathname.js

@@ -1,4 +1,6 @@
+import { assertIsLocale } from "./assert-is-locale.js";
 import { isLocale } from "./is-locale.js";
+import { baseLocale, pathnameBase, pathnames, TREE_SHAKE_IS_DEFAULT_PATHNAMES, } from "./variables.js";
 /**
  * Extracts the locale from a given pathname.
  *
@@ -11,9 +13,23 @@ import { isLocale } from "./is-locale.js";
  * @returns {Locale|undefined} The extracted locale, or undefined if no locale is found.
  */
 export function extractLocaleFromPathname(pathname) {
-    const [, maybeLocale] = pathname.split("/");
-    if (isLocale(maybeLocale)) {
-        return maybeLocale;
+    let path = pathnameBase
+        ? pathname.replace(pathnameBase, "") || "/"
+        : pathname;
+    // optimization to avoid loading the path-to-regexp library
+    // which saves around 2kb gzipped
+    if (TREE_SHAKE_IS_DEFAULT_PATHNAMES) {
+        const [, maybeLocale] = path.split("/");
+        return isLocale(maybeLocale) && maybeLocale !== baseLocale
+            ? maybeLocale
+            : baseLocale;
+    }
+    for (const patterns of Object.values(pathnames)) {
+        for (const [locale, localizedPattern] of Object.entries(patterns)) {
+            if (pathToRegexp.match(localizedPattern)(path)) {
+                return assertIsLocale(locale);
+            }
+        }
     }
     return undefined;
 }

package/dist/compiler/runtime/extract-locale-from-pathname.test.js

@@ -4,6 +4,14 @@ test("returns the locale from the path", async () => {
     const runtime = await createRuntimeForTesting({
         baseLocale: "en",
         locales: ["en", "en-US"],
+        compilerOptions: {
+            pathnames: {
+                "/{*path}": {
+                    en: "/en{/*path}",
+                    "en-US": "/en-US{/*path}",
+                },
+            },
+        },
     });
     const path = "/en-US/about";
     const locale = runtime.extractLocaleFromPathname(path);
@@ -13,8 +21,83 @@ test("returns undefined if isLocale is false", async () => {
     const runtime = await createRuntimeForTesting({
         baseLocale: "en",
         locales: ["en"],
+        compilerOptions: {
+            pathnames: {
+                "/{*path}": {
+                    en: "/en{/*path}",
+                },
+            },
+        },
     });
     const path = "/en-US/about";
     const locale = runtime.extractLocaleFromPathname(path);
     expect(locale).toBe(undefined);
 });
+test("works for static paths", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+        compilerOptions: {
+            pathnames: {
+                "/about": {
+                    en: "/about",
+                    de: "/ueber-uns",
+                },
+            },
+        },
+    });
+    expect(runtime.extractLocaleFromPathname("/about")).toBe("en");
+    expect(runtime.extractLocaleFromPathname("/ueber-uns")).toBe("de");
+});
+test("works for default pathnames", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+        compilerOptions: {
+            // undefined auto creates default pathnames
+            pathnames: undefined,
+        },
+    });
+    expect(runtime.extractLocaleFromPathname("/")).toBe("en");
+    expect(runtime.extractLocaleFromPathname("/de/")).toBe("de");
+    // the base path is not prefixed
+    expect(runtime.extractLocaleFromPathname("/en")).toBe("en");
+    expect(runtime.extractLocaleFromPathname("/about")).toBe("en");
+    expect(runtime.extractLocaleFromPathname("/de/about")).toBe("de");
+    expect(runtime.extractLocaleFromPathname("/de/about/")).toBe("de");
+    expect(runtime.extractLocaleFromPathname("/fr/ueber-uns")).toBe("en");
+});
+test("works with pathnameBase for default pathnames option", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+        compilerOptions: {
+            pathnameBase: "/base",
+        },
+    });
+    expect(runtime.extractLocaleFromPathname("/base")).toBe("en");
+    expect(runtime.extractLocaleFromPathname("/base/de/")).toBe("de");
+    expect(runtime.extractLocaleFromPathname("/base/de/about")).toBe("de");
+    expect(runtime.extractLocaleFromPathname("/base/de/about/")).toBe("de");
+    expect(runtime.extractLocaleFromPathname("/base/fr/ueber-uns")).toBe("en");
+});
+test("works with pathnameBase for matching pathnames option", async () => {
+    const runtime = await createRuntimeForTesting({
+        baseLocale: "en",
+        locales: ["en", "de"],
+        compilerOptions: {
+            pathnameBase: "/base",
+            pathnames: {
+                "/{*path}": {
+                    de: "/de{/*path}",
+                    en: "/{*path}",
+                },
+            },
+        },
+    });
+    expect(runtime.extractLocaleFromPathname("/base")).toBe("en");
+    expect(runtime.extractLocaleFromPathname("/base/de/")).toBe("de");
+    expect(runtime.extractLocaleFromPathname("/base/de/about")).toBe("de");
+    expect(runtime.extractLocaleFromPathname("/base/de/about/")).toBe("de");
+    expect(runtime.extractLocaleFromPathname("/base/fr/ueber-uns")).toBe("en");
+});

package/dist/compiler/runtime/extract-locale-from-request.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extract-locale-from-request.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/extract-locale-from-request.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,uCAFU,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CA6BpC"}
+{"version":3,"file":"extract-locale-from-request.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/extract-locale-from-request.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,uCAFU,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CA6BpC"}

package/dist/compiler/runtime/extract-locale-from-request.js

@@ -1,8 +1,6 @@
 import { assertIsLocale } from "./assert-is-locale.js";
-import { baseLocale } from "./base-locale.js";
-import { cookieName } from "./cookie-name.js";
+import { baseLocale, cookieName, strategy } from "./variables.js";
 import { extractLocaleFromPathname } from "./extract-locale-from-pathname.js";
-import { strategy } from "./strategy.js";
 /**
  * Detect a locale from a request.
  *
@@ -25,7 +23,7 @@ export const extractLocaleFromRequest = (request) => {
         else if (strat === "pathname") {
             locale = extractLocaleFromPathname(new URL(request.url).pathname);
         }
-        else if (strat === "variable") {
+        else if (strat === "globalVariable") {
             locale = _locale;
         }
         else if (strat === "baseLocale") {

package/dist/compiler/runtime/extract-locale-from-request.test.js

@@ -23,6 +23,11 @@ test("returns the locale from the pathname", async () => {
         locales: ["en"],
         compilerOptions: {
             strategy: ["pathname"],
+            pathnames: {
+                "/{*path}": {
+                    en: "/en{/*path}",
+                },
+            },
         },
     });
     const request = new Request("http://example.com/en/home");

package/dist/compiler/runtime/get-locale-from-path.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Extracts the locale from a given path.
+ *
+ * @example
+ *   const path = '/en/home';
+ *   const locale = getLocaleFromPath(path);
+ *   console.log(locale); // 'en'
+ *
+ * @param {string} path - The path from which to extract the locale.
+ * @returns {Locale|undefined} The extracted locale, or undefined if no locale is found.
+ */
+export function getLocaleFromPath(path: string): Locale | undefined;
+//# sourceMappingURL=get-locale-from-path.d.ts.map

package/dist/compiler/runtime/get-locale-from-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-locale-from-path.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/get-locale-from-path.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wCAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAO5B"}

package/dist/compiler/runtime/get-locale-from-path.js

@@ -0,0 +1,17 @@
+/**
+ * Extracts the locale from a given path.
+ *
+ * @example
+ *   const path = '/en/home';
+ *   const locale = getLocaleFromPath(path);
+ *   console.log(locale); // 'en'
+ *
+ * @param {string} path - The path from which to extract the locale.
+ * @returns {Locale|undefined} The extracted locale, or undefined if no locale is found.
+ */
+export function getLocaleFromPath(path) {
+    const [, maybeLocale] = path.split("/");
+    if (isLocale(maybeLocale)) {
+        return maybeLocale;
+    }
+}

package/dist/compiler/runtime/get-locale-from-path.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=get-locale-from-path.test.d.ts.map

package/dist/compiler/runtime/get-locale-from-path.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-locale-from-path.test.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/get-locale-from-path.test.ts"],"names":[],"mappings":""}

package/dist/compiler/runtime/get-locale-from-path.test.js

@@ -0,0 +1,22 @@
+import { test, expect, vi, describe, afterEach } from "vitest";
+import { getLocaleFromPath } from "./get-locale-from-path.js";
+// sequential to avoid global variable conflicts
+describe.sequential("", () => {
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    test("returns the locale from the path", () => {
+        // @ts-expect-error - global variable definition
+        globalThis.isLocale = vi.fn().mockReturnValue(true);
+        const path = "/en-US/about";
+        const locale = getLocaleFromPath(path);
+        expect(locale).toBe("en-US");
+    });
+    test("returns undefined if isLocale is false", () => {
+        // @ts-expect-error - global variable definition
+        globalThis.isLocale = vi.fn().mockReturnValue(false);
+        const path = "/en-US/about";
+        const locale = getLocaleFromPath(path);
+        expect(locale).toBe(undefined);
+    });
+});

package/dist/compiler/runtime/get-locale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-locale.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/get-locale.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;GAWG;AACH,sBAFU,MAAM,MAAM,CA8BpB"}
+{"version":3,"file":"get-locale.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/get-locale.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;GAWG;AACH,sBAFU,MAAM,MAAM,CAmCpB"}

package/dist/compiler/runtime/get-locale.js

@@ -1,8 +1,7 @@
 import { assertIsLocale } from "./assert-is-locale.js";
-import { baseLocale } from "./base-locale.js";
+import { baseLocale, strategy, TREE_SHAKE_COOKIE_STRATEGY_USED, TREE_SHAKE_PATHNAME_STRATEGY_USED, TREE_SHAKE_GLOBAL_VARIABLE_STRATEGY_USED, } from "./variables.js";
 import { extractLocaleFromCookie } from "./extract-locale-from-cookie.js";
 import { extractLocaleFromPathname } from "./extract-locale-from-pathname.js";
-import { strategy } from "./strategy.js";
 /**
  * This is a fallback to get started with a custom
  * strategy and avoid type errors.
@@ -29,18 +28,21 @@ export let getLocale = () => {
     /** @type {string | undefined} */
     let locale;
     for (const strat of strategy) {
-        if (strat === "cookie") {
+        if (TREE_SHAKE_COOKIE_STRATEGY_USED && strat === "cookie") {
             locale = extractLocaleFromCookie();
         }
         if (strat === "baseLocale") {
             locale = baseLocale;
         }
-        if (strat === "pathname" &&
+        if (TREE_SHAKE_PATHNAME_STRATEGY_USED &&
+            strat === "pathname" &&
             typeof window !== "undefined" &&
             window.location?.pathname) {
             locale = extractLocaleFromPathname(window.location.pathname);
         }
-        if (strat === "variable" && _locale !== undefined) {
+        if (TREE_SHAKE_GLOBAL_VARIABLE_STRATEGY_USED &&
+            strat === "globalVariable" &&
+            _locale !== undefined) {
             locale = _locale;
         }
         // check if match, else continue loop

package/dist/compiler/runtime/get-locale.test.js

@@ -22,7 +22,7 @@ test("doesn't throw when using pathname strategy on the server", async () => {
         baseLocale,
         locales: ["en", "de"],
         compilerOptions: {
-            strategy: ["pathname", "variable", "baseLocale"],
+            strategy: ["pathname", "globalVariable", "baseLocale"],
         },
     });
     expect(() => runtime.getLocale()).not.toThrow();
@@ -33,7 +33,7 @@ test("throws if variable is used without baseLocale as fallback strategy", async
         baseLocale: "en",
         locales: ["en", "de"],
         compilerOptions: {
-            strategy: ["variable"],
+            strategy: ["globalVariable"],
         },
     });
     expect(() => runtime.getLocale()).toThrow();

package/dist/compiler/runtime/is-locale.js

@@ -1,4 +1,4 @@
-import { locales } from "./locales.js";
+import { locales } from "./variables.js";
 /**
  * Check if something is an available locale.
  *

package/dist/compiler/runtime/jsdoc-runtime.d.ts

@@ -0,0 +1,2 @@
+export const jsdocRuntime: string;
+//# sourceMappingURL=jsdoc-runtime.d.ts.map

package/dist/compiler/runtime/jsdoc-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsdoc-runtime.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/jsdoc-runtime.js"],"names":[],"mappings":"AAaA,kCAyHE"}

package/dist/compiler/runtime/jsdoc-runtime.js

@@ -0,0 +1,131 @@
+import fs from "node:fs";
+/**
+ * Load a file from the current directory.
+ *
+ * @param {string} path
+ * @returns {string}
+ */
+const injectCode = (path) => fs.readFileSync(new URL(path, import.meta.url), "utf-8");
+// to modify the runtime, outcomment the export const jsdocRuntime line
+export const jsdocRuntime = `
+
+/**
+ * The project's base locale.
+ *
+ * @example
+ *   if (locale === baseLocale) {
+ *     // do something
+ *   }
+ */
+export const baseLocale = "<replace>";
+
+/**
+ * The project's locales that have been specified in the settings.
+ *
+ * @example
+ *   if (locales.includes(userSelectedLocale) === false) {
+ *     throw new Error('Locale is not available');
+ *   }
+ */
+export const locales = /** @type {const} */ (["<replace>"]);
+
+/**
+ * This is a default implementation that is almost always
+ * overwritten by \`defineGetLocale()\` and \`defineSetLocale()\`.
+ *
+ * @type {Locale}
+ */
+let _locale = baseLocale;
+
+/**
+ * Define the \`getLocale()\` function.
+ *
+ * Use this function to define how the locale is resolved. For example,
+ * you can resolve the locale from the browser's preferred language,
+ * a cookie, env variable, or a user's preference.
+ *
+ * @example
+ *   defineGetLocale(() => {
+ *     // resolve the locale from a cookie. fallback to the base locale.
+ *     return Cookies.get('locale') ?? baseLocale
+ *   }
+ *
+ * @param {() => Locale} fn
+ * @type {(fn: () => Locale) => void}
+ */
+export const defineGetLocale = (fn) => {
+	getLocale = fn;
+};
+
+/**
+ * Define the \`setLocale()\` function.
+ *
+ * Use this function to define how the locale is set. For example,
+ * modify a cookie, env variable, or a user's preference.
+ *
+ * @example
+ *   defineSetLocale((newLocale) => {
+ *     // set the locale in a cookie
+ *     return Cookies.set('locale', newLocale)
+ *   });
+ *
+ * @param {(newLocale: Locale) => void} fn
+ */
+export const defineSetLocale = (fn) => {
+	setLocale = fn;
+};
+
+/**
+ * Get the current locale.
+ *
+ * @example
+ *   if (getLocale() === 'de') {
+ *     console.log('Germany 🇩🇪');
+ *   } else if (getLocale() === 'nl') {
+ *     console.log('Netherlands 🇳🇱');
+ *   }
+ *
+ * @type {() => Locale}
+ */
+export let getLocale =
+	/** default implementation likely overwritten by \`defineGetLocale()\` */ () =>
+		_locale;
+
+/**
+ * Set the locale.
+ *
+ * @example
+ *   setLocale('en');
+ *
+ * @param {Locale} newLocale
+ * @type {(newLocale: Locale) => void}
+ */
+export let setLocale =
+	/** default implementation likely overwritten by \`defineSetLocale()\` */ (
+		newLocale
+	) => {
+		_locale = newLocale;
+	};
+
+${injectCode("./is-locale.js")}
+
+${injectCode("./assert-is-locale.js")}
+
+${injectCode("./locale-in-path.js")}
+
+${injectCode("./localize-path.js")}
+
+${injectCode("./de-localize-path.js")}
+
+// ------ TYPES ------
+
+/**
+ * A locale that is available in the project.
+ *
+ * @example
+ *   setLocale(request.locale as Locale)
+ *
+ * @typedef {(typeof locales)[number]} Locale
+ */
+
+`;

package/dist/compiler/runtime/locale-in-path.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Extracts the locale from a given path.
+ *
+ * @example
+ *   const path = '/en/home';
+ *   const locale = localeInPath(path);
+ *   console.log(locale); // 'en'
+ *
+ * @param {string} path - The path from which to extract the locale.
+ * @returns {Locale|undefined} The extracted locale, or undefined if no locale is found.
+ */
+export function localeInPath(path: string): Locale | undefined;
+//# sourceMappingURL=locale-in-path.d.ts.map

package/dist/compiler/runtime/locale-in-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-in-path.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/locale-in-path.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,mCAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAO5B"}

package/dist/compiler/runtime/locale-in-path.js

@@ -0,0 +1,17 @@
+/**
+ * Extracts the locale from a given path.
+ *
+ * @example
+ *   const path = '/en/home';
+ *   const locale = localeInPath(path);
+ *   console.log(locale); // 'en'
+ *
+ * @param {string} path - The path from which to extract the locale.
+ * @returns {Locale|undefined} The extracted locale, or undefined if no locale is found.
+ */
+export function localeInPath(path) {
+    const [, maybeLocale] = path.split("/");
+    if (isLocale(maybeLocale)) {
+        return maybeLocale;
+    }
+}

package/dist/compiler/runtime/locale-in-path.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=locale-in-path.test.d.ts.map

package/dist/compiler/runtime/locale-in-path.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-in-path.test.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/locale-in-path.test.ts"],"names":[],"mappings":""}

package/dist/compiler/runtime/locale-in-path.test.js

@@ -0,0 +1,22 @@
+import { test, expect, vi, describe, afterEach } from "vitest";
+import { localeInPath } from "./locale-in-path.js";
+// sequential to avoid global variable conflicts
+describe.sequential("", () => {
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+    test("returns the locale from the path", () => {
+        // @ts-expect-error - global variable definition
+        globalThis.isLocale = vi.fn().mockReturnValue(true);
+        const path = "/en-US/about";
+        const locale = localeInPath(path);
+        expect(locale).toBe("en-US");
+    });
+    test("returns undefined if isLocale is false", () => {
+        // @ts-expect-error - global variable definition
+        globalThis.isLocale = vi.fn().mockReturnValue(false);
+        const path = "/en-US/about";
+        const locale = localeInPath(path);
+        expect(locale).toBe(undefined);
+    });
+});

package/dist/compiler/runtime/localize-path.d.ts

@@ -21,12 +21,12 @@
  * @example
  *   <a href={localizePath('/home')}>Home</a>
  *
- * @param {string} path
+ * @param {string} pathname
  * @param {Object} [options] - Optional parameters.
  * @param {Locale} [options.locale] - The locale to use for the path.
  * @returns {string}
  */
-export function localizePath(path: string, options?: {
+export function localizePath(pathname: string, options?: {
     locale?: Locale;
 }): string;
 //# sourceMappingURL=localize-path.d.ts.map

package/dist/compiler/runtime/localize-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localize-path.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/localize-path.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,mCALW,MAAM,YAEd;IAAyB,MAAM,GAAvB,MAAM;CACd,GAAU,MAAM,CAgBlB"}
+{"version":3,"file":"localize-path.d.ts","sourceRoot":"","sources":["../../../src/compiler/runtime/localize-path.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,uCALW,MAAM,YAEd;IAAyB,MAAM,GAAvB,MAAM;CACd,GAAU,MAAM,CAqElB"}

package/dist/compiler/runtime/localize-path.js

@@ -1,4 +1,4 @@
-import { baseLocale } from "./base-locale.js";
+import { baseLocale, pathnameBase, pathnames, TREE_SHAKE_IS_DEFAULT_PATHNAMES, } from "./variables.js";
 import { getLocale } from "./get-locale.js";
 import { extractLocaleFromPathname } from "./extract-locale-from-pathname.js";
 /**
@@ -24,24 +24,72 @@ import { extractLocaleFromPathname } from "./extract-locale-from-pathname.js";
  * @example
  *   <a href={localizePath('/home')}>Home</a>
  *
- * @param {string} path
+ * @param {string} pathname
  * @param {Object} [options] - Optional parameters.
  * @param {Locale} [options.locale] - The locale to use for the path.
  * @returns {string}
  */
-export function localizePath(path, options) {
+export function localizePath(pathname, options) {
+    const url = new URL(pathname, "http://y.com");
     const locale = options?.locale ?? getLocale();
-    const hasLocale = extractLocaleFromPathname(path);
-    const pathWithoutLocale = hasLocale
-        ? "/" + path.split("/").slice(2).join("/")
-        : path;
-    if (locale === baseLocale) {
-        return pathWithoutLocale;
+    const pathnameLocale = extractLocaleFromPathname(url.pathname);
+    // If the path is already localized, return it as is
+    if (pathnameLocale === locale) {
+        if (pathnameBase && !url.pathname.startsWith(pathnameBase)) {
+            return pathnameBase + pathname + url.search;
+        }
+        else {
+            return pathname + url.search;
+        }
     }
-    else if (path === "/" || pathWithoutLocale === "/") {
-        return `/${locale}`;
+    // no dynamic matching is needed if the default pathnames are used
+    // this is a tree-shaking optimization to avoid loading the path-to-regexp library
+    if (TREE_SHAKE_IS_DEFAULT_PATHNAMES) {
+        if (locale === baseLocale) {
+            let path = url.pathname;
+            if (pathnameBase && !path.startsWith(pathnameBase)) {
+                path = pathnameBase + path;
+            }
+            // remove the locale from the path
+            if (pathnameLocale) {
+                path = path.replace(`/${pathnameLocale}`, "");
+            }
+            return path + url.search;
+        }
+        else {
+            if (pathnameBase) {
+                return (`${pathnameBase}/${locale}${url.pathname.replace(pathnameBase, "")}` +
+                    url.search);
+            }
+            return `/${locale}${url.pathname}` + url.search;
+        }
     }
-    else {
-        return `/${locale}${pathWithoutLocale}`;
+    // dynamic matching is needed
+    for (const [pattern, locales] of Object.entries(pathnames)) {
+        let path = url.pathname;
+        if (pathnameBase && path.startsWith(pathnameBase)) {
+            path = path.replace(pathnameBase, "");
+        }
+        if (pathnameLocale) {
+            path = path.replace(`/${pathnameLocale}`, "");
+        }
+        if (path === "") {
+            path = "/";
+        }
+        const hasMatch = pathToRegexp.match(pattern)(path);
+        if (hasMatch) {
+            const localizedPattern = /** @type {string} */ (locales[locale]);
+            const localizedPath = pathToRegexp.compile(localizedPattern)(hasMatch.params) + url.search;
+            if (pathnameBase && localizedPath !== "/") {
+                return pathnameBase + localizedPath;
+            }
+            else if (pathnameBase) {
+                return pathnameBase;
+            }
+            else {
+                return localizedPath;
+            }
+        }
     }
+    throw new Error("No match found for localized path. Refer to the documentation on how to define pathnames.");
 }