@intlayer/core 9.4.1 → 9.4.3

package/README.md

@@ -330,4 +330,4 @@ Contribute on [GitHub](https://github.com/aymericzip/intlayer), [GitLab](https:/
 
 If you like Intlayer, give us a ⭐ on GitHub. It helps others discover the project! [See why GitHub Stars matter](https://github.com/aymericzip/intlayer/blob/main/CONTRIBUTING.md#why-github-stars-matter-).
 
-[![Star History Chart](https://star-history.dera.page/svg?repos=aymericzip/intlayer&type=Date)](https://star-history.dera.page/#aymericzip/intlayer&Date)
+[![Star History Chart](https://api.star-history.com/svg?repos=aymericzip/intlayer&type=Date)](https://api.star-history.com/#aymericzip/intlayer&Date)

package/dist/cjs/index.cjs

@@ -78,6 +78,8 @@ const require_utils_checkIsURLAbsolute = require('./utils/checkIsURLAbsolute.cjs
 const require_localization_getPathWithoutLocale = require('./localization/getPathWithoutLocale.cjs');
 const require_localization_comparePaths = require('./localization/comparePaths.cjs');
 const require_localization_domainUtils = require('./localization/domainUtils.cjs');
+const require_localization_rewriteMatch = require('./localization/rewriteMatch.cjs');
+const require_localization_getCanonicalPath = require('./localization/getCanonicalPath.cjs');
 const require_localization_getPrefix = require('./localization/getPrefix.cjs');
 const require_localization_rewriteUtils = require('./localization/rewriteUtils.cjs');
 const require_localization_getLocalizedPath = require('./localization/getLocalizedPath.cjs');
@@ -129,12 +131,12 @@ exports.CODE_INLINE_R = require_markdown_constants.CODE_INLINE_R;
 exports.COMPOSITE_ID_SEPARATOR = require_dictionaryManipulator_qualifiedDictionary.COMPOSITE_ID_SEPARATOR;
 exports.CONSECUTIVE_NEWLINE_R = require_markdown_constants.CONSECUTIVE_NEWLINE_R;
 exports.CR_NEWLINE_R = require_markdown_constants.CR_NEWLINE_R;
+exports.CUSTOM_COMPONENT_OPENING_TAG_R = require_markdown_constants.CUSTOM_COMPONENT_OPENING_TAG_R;
 exports.CUSTOM_COMPONENT_R = require_markdown_constants.CUSTOM_COMPONENT_R;
 exports.CachedIntl = require_utils_intl.CachedIntl;
 exports.Intl = require_utils_intl.CachedIntl;
 exports.DEFAULT_VARIANT_ID = require_dictionaryManipulator_qualifiedDictionary.DEFAULT_VARIANT_ID;
 exports.DO_NOT_PROCESS_HTML_ELEMENTS = require_markdown_constants.DO_NOT_PROCESS_HTML_ELEMENTS;
-exports.DURATION_DELAY_TRIGGER = require_markdown_constants.DURATION_DELAY_TRIGGER;
 exports.FENCE_DELIMITER_R = require_markdown_constants.FENCE_DELIMITER_R;
 exports.FOOTNOTE_R = require_markdown_constants.FOOTNOTE_R;
 exports.FOOTNOTE_REFERENCE_R = require_markdown_constants.FOOTNOTE_REFERENCE_R;
@@ -145,22 +147,24 @@ exports.HEADING_ATX_COMPLIANT_R = require_markdown_constants.HEADING_ATX_COMPLIA
 exports.HEADING_R = require_markdown_constants.HEADING_R;
 exports.HEADING_SETEXT_R = require_markdown_constants.HEADING_SETEXT_R;
 exports.HTML_BLOCK_ELEMENT_R = require_markdown_constants.HTML_BLOCK_ELEMENT_R;
+exports.HTML_BLOCK_OPENING_TAG_R = require_markdown_constants.HTML_BLOCK_OPENING_TAG_R;
 exports.HTML_CHAR_CODE_R = require_markdown_constants.HTML_CHAR_CODE_R;
 exports.HTML_COMMENT_R = require_markdown_constants.HTML_COMMENT_R;
 exports.HTML_CUSTOM_ATTR_R = require_markdown_constants.HTML_CUSTOM_ATTR_R;
 exports.HTML_LEFT_TRIM_AMOUNT_R = require_markdown_constants.HTML_LEFT_TRIM_AMOUNT_R;
 exports.HTML_SELF_CLOSING_ELEMENT_R = require_markdown_constants.HTML_SELF_CLOSING_ELEMENT_R;
+exports.HTML_SELF_CLOSING_OPENING_TAG_R = require_markdown_constants.HTML_SELF_CLOSING_OPENING_TAG_R;
 exports.HTML_TAGS = require_transpiler_html_htmlTags.HTML_TAGS;
 exports.INLINE_SKIP_R = require_markdown_constants.INLINE_SKIP_R;
 exports.INTERPOLATION_R = require_markdown_constants.INTERPOLATION_R;
 exports.LINK_AUTOLINK_BARE_URL_R = require_markdown_constants.LINK_AUTOLINK_BARE_URL_R;
 exports.LINK_AUTOLINK_R = require_markdown_constants.LINK_AUTOLINK_R;
-exports.LIST_LOOKBEHIND_R = require_markdown_constants.LIST_LOOKBEHIND_R;
 exports.LOOKAHEAD = require_markdown_constants.LOOKAHEAD;
 exports.LocaleStorage = require_utils_localeStorage.LocaleStorage;
 exports.LocaleStorageClient = require_utils_localeStorage.LocaleStorageClient;
 exports.LocaleStorageServer = require_utils_localeStorage.LocaleStorageServer;
 exports.NAMED_CODES_TO_UNICODE = require_markdown_constants.NAMED_CODES_TO_UNICODE;
+exports.NORMALIZE_WHITESPACE_R = require_markdown_constants.NORMALIZE_WHITESPACE_R;
 exports.NP_TABLE_R = require_markdown_constants.NP_TABLE_R;
 exports.ORDERED = require_markdown_constants.ORDERED;
 exports.ORDERED_LIST_BULLET = require_markdown_constants.ORDERED_LIST_BULLET;
@@ -242,7 +246,7 @@ exports.get = require_markdown_utils.get;
 exports.getBasePlugins = require_interpreter_getContent_getContent.getBasePlugins;
 exports.getBrowserLocale = require_localization_getBrowserLocale.getBrowserLocale;
 exports.getCachedIntl = require_utils_intl.getCachedIntl;
-exports.getCanonicalPath = require_localization_rewriteUtils.getCanonicalPath;
+exports.getCanonicalPath = require_localization_getCanonicalPath.getCanonicalPath;
 exports.getCondition = require_interpreter_getCondition.getCondition;
 exports.getContent = require_interpreter_getContent_getContent.getContent;
 exports.getContentNodeByKeyPath = require_dictionaryManipulator_getContentNodeByKeyPath.getContentNodeByKeyPath;
@@ -308,7 +312,7 @@ exports.getPreloadLocale = require_localization_resolveBrowserLocale.getPreloadL
 exports.getPreloadedDictionary = require_dictionaryManipulator_preloadedDynamicLoader.getPreloadedDictionary;
 exports.getReplacedValuesContent = require_deepTransformPlugins_getReplacedValuesContent.getReplacedValuesContent;
 exports.getRewritePath = require_localization_rewriteUtils.getRewritePath;
-exports.getRewriteRules = require_localization_rewriteUtils.getRewriteRules;
+exports.getRewriteRules = require_localization_rewriteMatch.getRewriteRules;
 exports.getSelect = require_interpreter_getSelect.getSelect;
 exports.getSplittedContent = require_deepTransformPlugins_getSplittedContent.getSplittedContent;
 exports.getSplittedDictionaryContent = require_deepTransformPlugins_getSplittedContent.getSplittedDictionaryContent;

package/dist/cjs/localization/getCanonicalPath.cjs

@@ -0,0 +1,52 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_localization_rewriteMatch = require('./rewriteMatch.cjs');
+let _intlayer_config_built = require("@intlayer/config/built");
+
+//#region src/localization/getCanonicalPath.ts
+/**
+* Decodes percent-encoding so an encoded pathname
+* (`/doc/%E3%83%AA%E3%83%AA%E3%83%BC%E3%82%B9/v8`, as `URL.pathname` and the
+* router hand it over) matches a rewrite pattern written with its literal
+* characters (`/doc/リリース/v8`). Reserved delimiters stay encoded, and a path
+* with no escape — or a malformed one — is returned untouched.
+*/
+const decodePath = (path) => {
+	if (!path.includes("%")) return path;
+	try {
+		return decodeURI(path);
+	} catch {
+		return path;
+	}
+};
+/**
+* Given a localized URL (e.g., "/produits/123"), finds the canonical internal path (e.g., "/products/123").
+* If locale is provided, only check for that locale. Otherwise, check for all locales.
+*
+* The lookup is encoding-insensitive: a percent-encoded path matches a pattern
+* written with literal (non-ASCII) characters.
+*
+* @param localizedPath - The path as seen in the browser, without locale prefix.
+* @param locale - Restricts the lookup to that locale's rules. Defaults to every locale.
+* @param rewriteRules - Raw `routing.rewrite` configuration or already-normalized
+*   rules. Defaults to the project configuration's `routing.rewrite`.
+*/
+const getCanonicalPath = (localizedPath, locale, rewriteRules) => {
+	const rules = require_localization_rewriteMatch.getRewriteRules(rewriteRules ?? _intlayer_config_built.routing?.rewrite, "url");
+	if (!rules || process.env.INTLAYER_ROUTING_REWRITE_RULES && process.env.INTLAYER_ROUTING_REWRITE_RULES === "false") return localizedPath;
+	const pathToMatch = decodePath(localizedPath);
+	for (const rule of rules.rules) {
+		const { canonical, localized } = rule;
+		const localesToCheck = locale ? [locale] : Object.keys(localized);
+		for (const locale of localesToCheck) {
+			const localizedPattern = localized[locale];
+			if (!localizedPattern) continue;
+			const params = require_localization_rewriteMatch.extractParams(pathToMatch, localizedPattern);
+			if (params) return require_localization_rewriteMatch.fillPath(canonical, params);
+		}
+	}
+	return localizedPath;
+};
+
+//#endregion
+exports.getCanonicalPath = getCanonicalPath;
+//# sourceMappingURL=getCanonicalPath.cjs.map

package/dist/cjs/localization/getCanonicalPath.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getCanonicalPath.cjs","names":["getRewriteRules","routing","extractParams","fillPath"],"sources":["../../../src/localization/getCanonicalPath.ts"],"sourcesContent":["import { routing } from '@intlayer/config/built';\nimport type { RewriteRules, RoutingConfig } from '@intlayer/types/config';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { extractParams, fillPath, getRewriteRules } from './rewriteMatch';\n\n/**\n * Decodes percent-encoding so an encoded pathname\n * (`/doc/%E3%83%AA%E3%83%AA%E3%83%BC%E3%82%B9/v8`, as `URL.pathname` and the\n * router hand it over) matches a rewrite pattern written with its literal\n * characters (`/doc/リリース/v8`). Reserved delimiters stay encoded, and a path\n * with no escape — or a malformed one — is returned untouched.\n */\nconst decodePath = (path: string): string => {\n  if (!path.includes('%')) return path;\n\n  try {\n    return decodeURI(path);\n  } catch {\n    return path;\n  }\n};\n\n/**\n * Given a localized URL (e.g., \"/produits/123\"), finds the canonical internal path (e.g., \"/products/123\").\n * If locale is provided, only check for that locale. Otherwise, check for all locales.\n *\n * The lookup is encoding-insensitive: a percent-encoded path matches a pattern\n * written with literal (non-ASCII) characters.\n *\n * @param localizedPath - The path as seen in the browser, without locale prefix.\n * @param locale - Restricts the lookup to that locale's rules. Defaults to every locale.\n * @param rewriteRules - Raw `routing.rewrite` configuration or already-normalized\n *   rules. Defaults to the project configuration's `routing.rewrite`.\n */\nexport const getCanonicalPath = <\n  const Path extends string,\n  const Locale extends LocalesValues = LocalesValues,\n>(\n  localizedPath: Path,\n  locale?: Locale,\n  rewriteRules?: RoutingConfig['rewrite'] | RewriteRules\n): string => {\n  const rules = getRewriteRules(rewriteRules ?? routing?.rewrite, 'url');\n\n  if (\n    !rules ||\n    (process.env.INTLAYER_ROUTING_REWRITE_RULES &&\n      process.env.INTLAYER_ROUTING_REWRITE_RULES === 'false')\n  )\n    return localizedPath;\n\n  const pathToMatch = decodePath(localizedPath);\n\n  for (const rule of rules.rules) {\n    const { canonical, localized } = rule;\n    const localesToCheck = locale ? [locale] : Object.keys(localized);\n\n    for (const locale of localesToCheck) {\n      const localizedPattern = localized[locale as keyof typeof localized];\n\n      if (!localizedPattern) continue;\n\n      const params = extractParams(pathToMatch, localizedPattern);\n\n      if (params) {\n        return fillPath(canonical, params);\n      }\n    }\n  }\n\n  return localizedPath;\n};\n"],"mappings":";;;;;;;;;;;;AAYA,MAAM,cAAc,SAAyB;CAC3C,IAAI,CAAC,KAAK,SAAS,GAAG,GAAG,OAAO;CAEhC,IAAI;EACF,OAAO,UAAU,IAAI;CACvB,QAAQ;EACN,OAAO;CACT;AACF;;;;;;;;;;;;;AAcA,MAAa,oBAIX,eACA,QACA,iBACW;CACX,MAAM,QAAQA,kDAAgB,gBAAgBC,gCAAS,SAAS,KAAK;CAErE,IACE,CAAC,SACA,QAAQ,IAAI,kCACX,QAAQ,IAAI,mCAAmC,SAEjD,OAAO;CAET,MAAM,cAAc,WAAW,aAAa;CAE5C,KAAK,MAAM,QAAQ,MAAM,OAAO;EAC9B,MAAM,EAAE,WAAW,cAAc;EACjC,MAAM,iBAAiB,SAAS,CAAC,MAAM,IAAI,OAAO,KAAK,SAAS;EAEhE,KAAK,MAAM,UAAU,gBAAgB;GACnC,MAAM,mBAAmB,UAAU;GAEnC,IAAI,CAAC,kBAAkB;GAEvB,MAAM,SAASC,gDAAc,aAAa,gBAAgB;GAE1D,IAAI,QACF,OAAOC,2CAAS,WAAW,MAAM;EAErC;CACF;CAEA,OAAO;AACT"}

package/dist/cjs/localization/getCanonicalPath.test-d.cjs

@@ -0,0 +1,12 @@
+const require_localization_getCanonicalPath = require('./getCanonicalPath.cjs');
+let vitest = require("vitest");
+
+//#region src/localization/getCanonicalPath.test-d.ts
+(0, vitest.describe)("getCanonicalPath", () => {
+	(0, vitest.it)("should accept an omitted locale (checks every locale)", () => {
+		(0, vitest.expectTypeOf)(require_localization_getCanonicalPath.getCanonicalPath("/a-propos")).toEqualTypeOf();
+	});
+});
+
+//#endregion
+//# sourceMappingURL=getCanonicalPath.test-d.cjs.map

package/dist/cjs/localization/getCanonicalPath.test-d.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getCanonicalPath.test-d.cjs","names":["describe","getCanonicalPath"],"sources":["../../../src/localization/getCanonicalPath.test-d.ts"],"sourcesContent":["import { describe, expectTypeOf, it } from 'vitest';\nimport { getCanonicalPath } from './getCanonicalPath';\n\ndescribe('getCanonicalPath', () => {\n  it('should accept an omitted locale (checks every locale)', () => {\n    expectTypeOf(getCanonicalPath('/a-propos')).toEqualTypeOf<string>();\n  });\n});\n"],"mappings":";;;;IAGAA,iBAAS,0BAA0B;CACjC,eAAG,+DAA+D;EAChE,yBAAaC,uDAAiB,WAAW,CAAC,CAAC,CAAC,cAAsB;CACpE,CAAC;AACH,CAAC"}

package/dist/cjs/localization/getLocalizedPath.cjs

@@ -1,5 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_localization_getPathWithoutLocale = require('./getPathWithoutLocale.cjs');
+const require_localization_rewriteMatch = require('./rewriteMatch.cjs');
+const require_localization_getCanonicalPath = require('./getCanonicalPath.cjs');
 const require_localization_getPrefix = require('./getPrefix.cjs');
 const require_localization_rewriteUtils = require('./rewriteUtils.cjs');
 let _intlayer_config_built = require("@intlayer/config/built");
@@ -51,9 +53,9 @@ let _intlayer_config_built = require("@intlayer/config/built");
 const getLocalizedPath = (canonicalPath, locale = _intlayer_config_built.internationalization?.defaultLocale, options = {}) => {
 	const { defaultLocale, mode, locales, rewrite, domains } = require_localization_getPrefix.resolveRoutingConfig(options);
 	const pathWithoutLocale = require_localization_getPathWithoutLocale.getPathWithoutLocale(canonicalPath, locales);
-	const rewriteRules = require_localization_rewriteUtils.getRewriteRules(rewrite, "url");
+	const rewriteRules = require_localization_rewriteMatch.getRewriteRules(rewrite, "url");
 	const parsedPath = new URL(pathWithoutLocale, "http://e.com");
-	const translatedPathname = require_localization_rewriteUtils.resolveLocalizedPath(require_localization_rewriteUtils.getCanonicalPath(parsedPath.pathname, void 0, rewriteRules), locale, rewriteRules).path;
+	const translatedPathname = require_localization_rewriteUtils.resolveLocalizedPath(require_localization_getCanonicalPath.getCanonicalPath(parsedPath.pathname, void 0, rewriteRules), locale, rewriteRules).path;
 	if (!(process.env.INTLAYER_ROUTING_MODE && process.env.INTLAYER_ROUTING_MODE !== "no-prefix") && mode === "no-prefix") return `${translatedPathname}${parsedPath.search}${parsedPath.hash}`;
 	if (!(process.env.INTLAYER_ROUTING_MODE && process.env.INTLAYER_ROUTING_MODE !== "search-params") && mode === "search-params") {
 		const searchParams = new URLSearchParams(parsedPath.search);

package/dist/cjs/localization/getLocalizedPath.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"getLocalizedPath.cjs","names":["internationalization","resolveRoutingConfig","getPathWithoutLocale","getRewriteRules","resolveLocalizedPath","getCanonicalPath","getPrefix"],"sources":["../../../src/localization/getLocalizedPath.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type {\n  LocalesValues,\n  LocalizedPathname,\n  ResolvedDefaultLocale,\n} from '@intlayer/types/module_augmentation';\nimport { getPathWithoutLocale } from './getPathWithoutLocale';\nimport {\n  getPrefix,\n  type RoutingOptions,\n  resolveRoutingConfig,\n} from './getPrefix';\nimport {\n  getCanonicalPath,\n  getRewriteRules,\n  resolveLocalizedPath,\n} from './rewriteUtils';\n\n/**\n * Localizes an application path for a locale: resolves the `routing.rewrite`\n * rules, then applies the locale representation of the routing mode — a path\n * prefix, a `locale` search parameter, or nothing at all.\n *\n * Any query string and hash of the input are preserved.\n *\n * This is the relative half of {@link getLocalizedUrl}, which builds on it to\n * add an origin and cross-domain routing. For a relative input both return the\n * same value; this one never returns an absolute URL — the origin of an\n * absolute input is dropped and only its path is localized.\n *\n * Use `resolveLocalizedPath` instead to apply the rewrite rules alone, without\n * any locale representation.\n *\n * @example\n * ```ts\n * // routing: { mode: 'prefix-no-default', rewrite: { '/about': { fr: '/a-propos' } } }\n * getLocalizedPath('/about', 'fr');       // '/fr/a-propos'\n * getLocalizedPath('/about', 'en');       // '/about'  (default locale, no prefix)\n * getLocalizedPath('/', 'fr');            // '/fr'\n * getLocalizedPath('/contact', 'fr');     // '/fr/contact' (no rewrite rule matches)\n * getLocalizedPath('https://intlayer.org/about', 'fr'); // '/fr/a-propos' (origin dropped)\n *\n * // routing: { domains: { zh: 'intlayer.cn' } } — zh is alone on that hostname\n * getLocalizedPath('/about', 'zh');       // '/about'  (the domain identifies the locale)\n *\n * // Manual rules, bypassing the configuration\n * getLocalizedPath('/contact', 'fr', {\n *   rewrite: { '/contact': { fr: '/contactez-nous' } },\n * });\n * // '/fr/contactez-nous'\n * ```\n *\n * @param canonicalPath - The internal application path (e.g. `/about`, `/product/123`).\n *   An absolute URL is accepted; only its path, query and hash are kept.\n * @param locale - The target locale. Defaults to the configured default locale.\n * @param options - Routing overrides (`locales`, `defaultLocale`, `mode`, `rewrite`,\n *   `domains`). Each one defaults to the project configuration. `domains` only\n *   suppresses the prefix of a locale served from its own domain — the origin\n *   itself is never emitted.\n * @returns The localized path for the target locale.\n */\nexport const getLocalizedPath = <\n  const CanonicalPath extends string,\n  const CurrentLocale extends LocalesValues = ResolvedDefaultLocale,\n>(\n  canonicalPath: CanonicalPath,\n  locale: CurrentLocale = internationalization?.defaultLocale as CurrentLocale,\n  options: RoutingOptions = {}\n): LocalizedPathname<CanonicalPath, CurrentLocale> => {\n  const { defaultLocale, mode, locales, rewrite, domains } =\n    resolveRoutingConfig(options);\n\n  const pathWithoutLocale = getPathWithoutLocale(canonicalPath, locales);\n  const rewriteRules = getRewriteRules(rewrite, 'url');\n\n  // Parsed against a dummy origin to split the path from its query and hash.\n  // An absolute input parses on its own, and only its path is kept.\n  const parsedPath = new URL(pathWithoutLocale, 'http://e.com');\n\n  const translatedPathname = resolveLocalizedPath(\n    getCanonicalPath(parsedPath.pathname, undefined, rewriteRules),\n    locale as Locale,\n    rewriteRules\n  ).path;\n\n  if (\n    !(\n      process.env.INTLAYER_ROUTING_MODE &&\n      process.env.INTLAYER_ROUTING_MODE !== 'no-prefix'\n    ) &&\n    mode === 'no-prefix'\n  ) {\n    return `${translatedPathname}${parsedPath.search}${parsedPath.hash}` as LocalizedPathname<\n      CanonicalPath,\n      CurrentLocale\n    >;\n  }\n\n  if (\n    !(\n      process.env.INTLAYER_ROUTING_MODE &&\n      process.env.INTLAYER_ROUTING_MODE !== 'search-params'\n    ) &&\n    mode === 'search-params'\n  ) {\n    const searchParams = new URLSearchParams(parsedPath.search);\n\n    searchParams.set('locale', locale.toString());\n\n    const queryParams = searchParams.toString();\n\n    return `${translatedPathname}${queryParams ? `?${queryParams}` : ''}${parsedPath.hash}` as LocalizedPathname<\n      CanonicalPath,\n      CurrentLocale\n    >;\n  }\n\n  const { prefix } = getPrefix(locale, {\n    defaultLocale,\n    mode,\n    locales,\n    domains,\n  });\n\n  let localizedPath = `/${prefix}${translatedPathname}`.replace(/\\/+/g, '/');\n\n  if (localizedPath.length > 1 && localizedPath.endsWith('/')) {\n    localizedPath = localizedPath.slice(0, -1);\n  }\n\n  return `${localizedPath}${parsedPath.search}${parsedPath.hash}` as LocalizedPathname<\n    CanonicalPath,\n    CurrentLocale\n  >;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DA,MAAa,oBAIX,eACA,SAAwBA,6CAAsB,eAC9C,UAA0B,CAAC,MACyB;CACpD,MAAM,EAAE,eAAe,MAAM,SAAS,SAAS,YAC7CC,oDAAqB,OAAO;CAE9B,MAAM,oBAAoBC,+DAAqB,eAAe,OAAO;CACrE,MAAM,eAAeC,kDAAgB,SAAS,KAAK;CAInD,MAAM,aAAa,IAAI,IAAI,mBAAmB,cAAc;CAE5D,MAAM,qBAAqBC,uDACzBC,mDAAiB,WAAW,UAAU,QAAW,YAAY,GAC7D,QACA,YACF,CAAC,CAAC;CAEF,IACE,EACE,QAAQ,IAAI,yBACZ,QAAQ,IAAI,0BAA0B,gBAExC,SAAS,aAET,OAAO,GAAG,qBAAqB,WAAW,SAAS,WAAW;CAMhE,IACE,EACE,QAAQ,IAAI,yBACZ,QAAQ,IAAI,0BAA0B,oBAExC,SAAS,iBACT;EACA,MAAM,eAAe,IAAI,gBAAgB,WAAW,MAAM;EAE1D,aAAa,IAAI,UAAU,OAAO,SAAS,CAAC;EAE5C,MAAM,cAAc,aAAa,SAAS;EAE1C,OAAO,GAAG,qBAAqB,cAAc,IAAI,gBAAgB,KAAK,WAAW;CAInF;CAEA,MAAM,EAAE,WAAWC,yCAAU,QAAQ;EACnC;EACA;EACA;EACA;CACF,CAAC;CAED,IAAI,gBAAgB,IAAI,SAAS,qBAAqB,QAAQ,QAAQ,GAAG;CAEzE,IAAI,cAAc,SAAS,KAAK,cAAc,SAAS,GAAG,GACxD,gBAAgB,cAAc,MAAM,GAAG,EAAE;CAG3C,OAAO,GAAG,gBAAgB,WAAW,SAAS,WAAW;AAI3D"}
+{"version":3,"file":"getLocalizedPath.cjs","names":["internationalization","resolveRoutingConfig","getPathWithoutLocale","getRewriteRules","resolveLocalizedPath","getCanonicalPath","getPrefix"],"sources":["../../../src/localization/getLocalizedPath.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport type {\n  LocalesValues,\n  LocalizedPathname,\n  ResolvedDefaultLocale,\n} from '@intlayer/types/module_augmentation';\nimport { getCanonicalPath } from './getCanonicalPath';\nimport { getPathWithoutLocale } from './getPathWithoutLocale';\nimport {\n  getPrefix,\n  type RoutingOptions,\n  resolveRoutingConfig,\n} from './getPrefix';\nimport { getRewriteRules } from './rewriteMatch';\nimport { resolveLocalizedPath } from './rewriteUtils';\n\n/**\n * Localizes an application path for a locale: resolves the `routing.rewrite`\n * rules, then applies the locale representation of the routing mode — a path\n * prefix, a `locale` search parameter, or nothing at all.\n *\n * Any query string and hash of the input are preserved.\n *\n * This is the relative half of {@link getLocalizedUrl}, which builds on it to\n * add an origin and cross-domain routing. For a relative input both return the\n * same value; this one never returns an absolute URL — the origin of an\n * absolute input is dropped and only its path is localized.\n *\n * Use `resolveLocalizedPath` instead to apply the rewrite rules alone, without\n * any locale representation.\n *\n * @example\n * ```ts\n * // routing: { mode: 'prefix-no-default', rewrite: { '/about': { fr: '/a-propos' } } }\n * getLocalizedPath('/about', 'fr');       // '/fr/a-propos'\n * getLocalizedPath('/about', 'en');       // '/about'  (default locale, no prefix)\n * getLocalizedPath('/', 'fr');            // '/fr'\n * getLocalizedPath('/contact', 'fr');     // '/fr/contact' (no rewrite rule matches)\n * getLocalizedPath('https://intlayer.org/about', 'fr'); // '/fr/a-propos' (origin dropped)\n *\n * // routing: { domains: { zh: 'intlayer.cn' } } — zh is alone on that hostname\n * getLocalizedPath('/about', 'zh');       // '/about'  (the domain identifies the locale)\n *\n * // Manual rules, bypassing the configuration\n * getLocalizedPath('/contact', 'fr', {\n *   rewrite: { '/contact': { fr: '/contactez-nous' } },\n * });\n * // '/fr/contactez-nous'\n * ```\n *\n * @param canonicalPath - The internal application path (e.g. `/about`, `/product/123`).\n *   An absolute URL is accepted; only its path, query and hash are kept.\n * @param locale - The target locale. Defaults to the configured default locale.\n * @param options - Routing overrides (`locales`, `defaultLocale`, `mode`, `rewrite`,\n *   `domains`). Each one defaults to the project configuration. `domains` only\n *   suppresses the prefix of a locale served from its own domain — the origin\n *   itself is never emitted.\n * @returns The localized path for the target locale.\n */\nexport const getLocalizedPath = <\n  const CanonicalPath extends string,\n  const CurrentLocale extends LocalesValues = ResolvedDefaultLocale,\n>(\n  canonicalPath: CanonicalPath,\n  locale: CurrentLocale = internationalization?.defaultLocale as CurrentLocale,\n  options: RoutingOptions = {}\n): LocalizedPathname<CanonicalPath, CurrentLocale> => {\n  const { defaultLocale, mode, locales, rewrite, domains } =\n    resolveRoutingConfig(options);\n\n  const pathWithoutLocale = getPathWithoutLocale(canonicalPath, locales);\n  const rewriteRules = getRewriteRules(rewrite, 'url');\n\n  // Parsed against a dummy origin to split the path from its query and hash.\n  // An absolute input parses on its own, and only its path is kept.\n  const parsedPath = new URL(pathWithoutLocale, 'http://e.com');\n\n  const translatedPathname = resolveLocalizedPath(\n    getCanonicalPath(parsedPath.pathname, undefined, rewriteRules),\n    locale as Locale,\n    rewriteRules\n  ).path;\n\n  if (\n    !(\n      process.env.INTLAYER_ROUTING_MODE &&\n      process.env.INTLAYER_ROUTING_MODE !== 'no-prefix'\n    ) &&\n    mode === 'no-prefix'\n  ) {\n    return `${translatedPathname}${parsedPath.search}${parsedPath.hash}` as LocalizedPathname<\n      CanonicalPath,\n      CurrentLocale\n    >;\n  }\n\n  if (\n    !(\n      process.env.INTLAYER_ROUTING_MODE &&\n      process.env.INTLAYER_ROUTING_MODE !== 'search-params'\n    ) &&\n    mode === 'search-params'\n  ) {\n    const searchParams = new URLSearchParams(parsedPath.search);\n\n    searchParams.set('locale', locale.toString());\n\n    const queryParams = searchParams.toString();\n\n    return `${translatedPathname}${queryParams ? `?${queryParams}` : ''}${parsedPath.hash}` as LocalizedPathname<\n      CanonicalPath,\n      CurrentLocale\n    >;\n  }\n\n  const { prefix } = getPrefix(locale, {\n    defaultLocale,\n    mode,\n    locales,\n    domains,\n  });\n\n  let localizedPath = `/${prefix}${translatedPathname}`.replace(/\\/+/g, '/');\n\n  if (localizedPath.length > 1 && localizedPath.endsWith('/')) {\n    localizedPath = localizedPath.slice(0, -1);\n  }\n\n  return `${localizedPath}${parsedPath.search}${parsedPath.hash}` as LocalizedPathname<\n    CanonicalPath,\n    CurrentLocale\n  >;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DA,MAAa,oBAIX,eACA,SAAwBA,6CAAsB,eAC9C,UAA0B,CAAC,MACyB;CACpD,MAAM,EAAE,eAAe,MAAM,SAAS,SAAS,YAC7CC,oDAAqB,OAAO;CAE9B,MAAM,oBAAoBC,+DAAqB,eAAe,OAAO;CACrE,MAAM,eAAeC,kDAAgB,SAAS,KAAK;CAInD,MAAM,aAAa,IAAI,IAAI,mBAAmB,cAAc;CAE5D,MAAM,qBAAqBC,uDACzBC,uDAAiB,WAAW,UAAU,QAAW,YAAY,GAC7D,QACA,YACF,CAAC,CAAC;CAEF,IACE,EACE,QAAQ,IAAI,yBACZ,QAAQ,IAAI,0BAA0B,gBAExC,SAAS,aAET,OAAO,GAAG,qBAAqB,WAAW,SAAS,WAAW;CAMhE,IACE,EACE,QAAQ,IAAI,yBACZ,QAAQ,IAAI,0BAA0B,oBAExC,SAAS,iBACT;EACA,MAAM,eAAe,IAAI,gBAAgB,WAAW,MAAM;EAE1D,aAAa,IAAI,UAAU,OAAO,SAAS,CAAC;EAE5C,MAAM,cAAc,aAAa,SAAS;EAE1C,OAAO,GAAG,qBAAqB,cAAc,IAAI,gBAAgB,KAAK,WAAW;CAInF;CAEA,MAAM,EAAE,WAAWC,yCAAU,QAAQ;EACnC;EACA;EACA;EACA;CACF,CAAC;CAED,IAAI,gBAAgB,IAAI,SAAS,qBAAqB,QAAQ,QAAQ,GAAG;CAEzE,IAAI,cAAc,SAAS,KAAK,cAAc,SAAS,GAAG,GACxD,gBAAgB,cAAc,MAAM,GAAG,EAAE;CAG3C,OAAO,GAAG,gBAAgB,WAAW,SAAS,WAAW;AAI3D"}

package/dist/cjs/localization/index.cjs

@@ -2,6 +2,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_localization_getPathWithoutLocale = require('./getPathWithoutLocale.cjs');
 const require_localization_comparePaths = require('./comparePaths.cjs');
 const require_localization_domainUtils = require('./domainUtils.cjs');
+const require_localization_rewriteMatch = require('./rewriteMatch.cjs');
+const require_localization_getCanonicalPath = require('./getCanonicalPath.cjs');
 const require_localization_getPrefix = require('./getPrefix.cjs');
 const require_localization_rewriteUtils = require('./rewriteUtils.cjs');
 const require_localization_getLocalizedPath = require('./getLocalizedPath.cjs');
@@ -26,7 +28,7 @@ exports.formatProxyEnabledMessage = require_localization_proxyMode.formatProxyEn
 exports.generateSitemap = require_localization_generateSitemap.generateSitemap;
 exports.generateSitemapUrl = require_localization_generateSitemap.generateSitemapUrl;
 exports.getBrowserLocale = require_localization_getBrowserLocale.getBrowserLocale;
-exports.getCanonicalPath = require_localization_rewriteUtils.getCanonicalPath;
+exports.getCanonicalPath = require_localization_getCanonicalPath.getCanonicalPath;
 exports.getDomainHostname = require_localization_domainUtils.getDomainHostname;
 exports.getDomainOrigin = require_localization_domainUtils.getDomainOrigin;
 exports.getHTMLTextDir = require_localization_getHTMLTextDir.getHTMLTextDir;
@@ -43,7 +45,7 @@ exports.getPathWithoutLocale = require_localization_getPathWithoutLocale.getPath
 exports.getPrefix = require_localization_getPrefix.getPrefix;
 exports.getPreloadLocale = require_localization_resolveBrowserLocale.getPreloadLocale;
 exports.getRewritePath = require_localization_rewriteUtils.getRewritePath;
-exports.getRewriteRules = require_localization_rewriteUtils.getRewriteRules;
+exports.getRewriteRules = require_localization_rewriteMatch.getRewriteRules;
 exports.isDeclaredLocale = require_localization_getPrefix.isDeclaredLocale;
 exports.isLocaleExclusiveOnDomain = require_localization_domainUtils.isLocaleExclusiveOnDomain;
 exports.isProxyStorageLocaleEnabled = require_localization_proxyMode.isProxyStorageLocaleEnabled;

package/dist/cjs/localization/rewriteMatch.cjs

@@ -0,0 +1,52 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region src/localization/rewriteMatch.ts
+/**
+* Normalizes legacy Record format or extracts specialized rules from RewriteObject.
+*
+* Idempotent: already-normalized rules are handed back untouched, so a caller
+* holding resolved rules can pass them on without re-normalizing.
+*/
+const getRewriteRules = (rewrite, context = "url") => {
+	if (!rewrite || process.env.INTLAYER_ROUTING_REWRITE_RULES && process.env.INTLAYER_ROUTING_REWRITE_RULES === "false") return void 0;
+	if (Array.isArray(rewrite.rules)) return rewrite;
+	if ("url" in rewrite) return rewrite[context];
+	return { rules: Object.entries(rewrite).map(([canonical, localized]) => ({
+		canonical: canonical.startsWith("/") ? canonical.replace(/\[([^\]]+)\]/g, ":$1") : `/${canonical.replace(/\[([^\]]+)\]/g, ":$1")}`,
+		localized: Object.fromEntries(Object.entries(localized).map(([locale, pattern]) => {
+			return [locale, pattern?.startsWith("/") ? pattern.replace(/\[([^\]]+)\]/g, ":$1") : `/${(pattern || "").replace(/\[([^\]]+)\]/g, ":$1")}`];
+		}))
+	})) };
+};
+/**
+* Converts normalized pattern to Regex.
+* Internal syntax supports:
+* - :param -> ([^/]+) (one segment)
+* - :param* -> (.*) (zero or more segments)
+* - :param+ -> (.+) (one or more segments)
+* - :param? -> ([^/]*) (zero or one segment)
+*/
+const patternToRegex = (pattern) => {
+	const regexString = pattern.replace(/\//g, "\\/").replace(/\\\/:(?:[^/\\*+?]+)\*/g, "(?:\\/(.*))?").replace(/\\\/:(?:[^/\\*+?]+)\?/g, "(?:\\/([^\\/]+))?").replace(/:([^/\\*+?]+)\*/g, "(.*)").replace(/:([^/\\*+?]+)\?/g, "([^\\/]*)").replace(/:([^/\\*+?]+)\+/g, "(.+)").replace(/:([^/\\*+?]+)/g, "([^\\/]+)");
+	return new RegExp(`^${regexString}$`);
+};
+/**
+* Replaces route parameters in a path with provided values.
+*/
+const fillPath = (pattern, params) => {
+	let index = 0;
+	return pattern.replace(/:([^/\\*+?]+)[*+?]?/g, () => params[index++] ?? "").replace(/\/+/g, "/").replace(/\/$/, "") || "/";
+};
+/**
+* Extract values from a URL based on a pattern.
+*/
+const extractParams = (url, pattern) => {
+	const regex = patternToRegex(pattern);
+	const match = url.match(regex);
+	return match ? match.slice(1) : null;
+};
+
+//#endregion
+exports.extractParams = extractParams;
+exports.fillPath = fillPath;
+exports.getRewriteRules = getRewriteRules;
+//# sourceMappingURL=rewriteMatch.cjs.map

package/dist/cjs/localization/rewriteMatch.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"rewriteMatch.cjs","names":["legacyRules"],"sources":["../../../src/localization/rewriteMatch.ts"],"sourcesContent":["import type {\n  RewriteObject,\n  RewriteRules,\n  RoutingConfig,\n} from '@intlayer/types/config';\n\n/**\n * Normalizes legacy Record format or extracts specialized rules from RewriteObject.\n *\n * Idempotent: already-normalized rules are handed back untouched, so a caller\n * holding resolved rules can pass them on without re-normalizing.\n */\nexport const getRewriteRules = <\n  const Context extends keyof RewriteObject = 'url',\n>(\n  rewrite: RoutingConfig['rewrite'] | RewriteRules,\n  context: Context = 'url' as Context\n): RewriteRules | undefined => {\n  if (\n    !rewrite ||\n    (process.env.INTLAYER_ROUTING_REWRITE_RULES &&\n      process.env.INTLAYER_ROUTING_REWRITE_RULES === 'false')\n  )\n    return undefined;\n\n  if (Array.isArray((rewrite as RewriteRules).rules)) {\n    return rewrite as RewriteRules;\n  }\n\n  if ('url' in rewrite) {\n    return (rewrite as RewriteObject)[context];\n  }\n\n  // Normalize legacy format\n  const legacyRules = rewrite as Record<string, Record<string, string>>;\n\n  return {\n    rules: Object.entries(legacyRules).map(([canonical, localized]) => ({\n      // Normalize canonical path\n      canonical: canonical.startsWith('/')\n        ? canonical.replace(/\\[([^\\]]+)\\]/g, ':$1')\n        : `/${canonical.replace(/\\[([^\\]]+)\\]/g, ':$1')}`,\n\n      // Normalize localized path\n      localized: Object.fromEntries(\n        Object.entries(localized).map(([locale, pattern]) => {\n          const normalizedPattern = pattern?.startsWith('/')\n            ? pattern.replace(/\\[([^\\]]+)\\]/g, ':$1')\n            : `/${(pattern || '').replace(/\\[([^\\]]+)\\]/g, ':$1')}`;\n          return [locale, normalizedPattern];\n        })\n      ),\n    })),\n  };\n};\n\n/**\n * Converts normalized pattern to Regex.\n * Internal syntax supports:\n * - :param -> ([^/]+) (one segment)\n * - :param* -> (.*) (zero or more segments)\n * - :param+ -> (.+) (one or more segments)\n * - :param? -> ([^/]*) (zero or one segment)\n */\nconst patternToRegex = (pattern: string) => {\n  const regexString = pattern\n    .replace(/\\//g, '\\\\/') // Escape slashes\n    .replace(/\\\\\\/:(?:[^/\\\\*+?]+)\\*/g, '(?:\\\\/(.*))?') // /:param*\n    .replace(/\\\\\\/:(?:[^/\\\\*+?]+)\\?/g, '(?:\\\\/([^\\\\/]+))?') // /:param?\n    .replace(/:([^/\\\\*+?]+)\\*/g, '(.*)') // :param* (if no leading slash)\n    .replace(/:([^/\\\\*+?]+)\\?/g, '([^\\\\/]*)') // :param? (if no leading slash)\n    .replace(/:([^/\\\\*+?]+)\\+/g, '(.+)') // :param+\n    .replace(/:([^/\\\\*+?]+)/g, '([^\\\\/]+)'); // :param\n\n  return new RegExp(`^${regexString}$`);\n};\n\n/**\n * Replaces route parameters in a path with provided values.\n */\nexport const fillPath = (pattern: string, params: string[]) => {\n  let index = 0;\n  return (\n    pattern\n      .replace(/:([^/\\\\*+?]+)[*+?]?/g, () => params[index++] ?? '')\n      .replace(/\\/+/g, '/')\n      .replace(/\\/$/, '') || '/'\n  );\n};\n\n/**\n * Extract values from a URL based on a pattern.\n */\nexport const extractParams = (\n  url: string,\n  pattern: string\n): string[] | null => {\n  const regex = patternToRegex(pattern);\n  const match = url.match(regex);\n  return match ? match.slice(1) : null;\n};\n"],"mappings":";;;;;;;;AAYA,MAAa,mBAGX,SACA,UAAmB,UACU;CAC7B,IACE,CAAC,WACA,QAAQ,IAAI,kCACX,QAAQ,IAAI,mCAAmC,SAEjD,OAAO;CAET,IAAI,MAAM,QAAS,QAAyB,KAAK,GAC/C,OAAO;CAGT,IAAI,SAAS,SACX,OAAQ,QAA0B;CAMpC,OAAO,EACL,OAAO,OAAO,QAAQA,OAAW,CAAC,CAAC,KAAK,CAAC,WAAW,gBAAgB;EAElE,WAAW,UAAU,WAAW,GAAG,IAC/B,UAAU,QAAQ,iBAAiB,KAAK,IACxC,IAAI,UAAU,QAAQ,iBAAiB,KAAK;EAGhD,WAAW,OAAO,YAChB,OAAO,QAAQ,SAAS,CAAC,CAAC,KAAK,CAAC,QAAQ,aAAa;GAInD,OAAO,CAAC,QAHkB,SAAS,WAAW,GAAG,IAC7C,QAAQ,QAAQ,iBAAiB,KAAK,IACtC,KAAK,WAAW,GAAE,CAAE,QAAQ,iBAAiB,KAAK,GACrB;EACnC,CAAC,CACH;CACF,EAAE,EACJ;AACF;;;;;;;;;AAUA,MAAM,kBAAkB,YAAoB;CAC1C,MAAM,cAAc,QACjB,QAAQ,OAAO,KAAK,CAAC,CACrB,QAAQ,0BAA0B,cAAc,CAAC,CACjD,QAAQ,0BAA0B,mBAAmB,CAAC,CACtD,QAAQ,oBAAoB,MAAM,CAAC,CACnC,QAAQ,oBAAoB,WAAW,CAAC,CACxC,QAAQ,oBAAoB,MAAM,CAAC,CACnC,QAAQ,kBAAkB,WAAW;CAExC,OAAO,IAAI,OAAO,IAAI,YAAY,EAAE;AACtC;;;;AAKA,MAAa,YAAY,SAAiB,WAAqB;CAC7D,IAAI,QAAQ;CACZ,OACE,QACG,QAAQ,8BAA8B,OAAO,YAAY,EAAE,CAAC,CAC5D,QAAQ,QAAQ,GAAG,CAAC,CACpB,QAAQ,OAAO,EAAE,KAAK;AAE7B;;;;AAKA,MAAa,iBACX,KACA,YACoB;CACpB,MAAM,QAAQ,eAAe,OAAO;CACpC,MAAM,QAAQ,IAAI,MAAM,KAAK;CAC7B,OAAO,QAAQ,MAAM,MAAM,CAAC,IAAI;AAClC"}

package/dist/cjs/localization/rewriteUtils.cjs

@@ -1,70 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_localization_rewriteMatch = require('./rewriteMatch.cjs');
+const require_localization_getCanonicalPath = require('./getCanonicalPath.cjs');
 let _intlayer_config_built = require("@intlayer/config/built");
 
 //#region src/localization/rewriteUtils.ts
 /**
-* Normalizes legacy Record format or extracts specialized rules from RewriteObject.
-*
-* Idempotent: already-normalized rules are handed back untouched, so a caller
-* holding resolved rules can pass them on without re-normalizing.
-*/
-const getRewriteRules = (rewrite, context = "url") => {
-	if (!rewrite || process.env.INTLAYER_ROUTING_REWRITE_RULES && process.env.INTLAYER_ROUTING_REWRITE_RULES === "false") return void 0;
-	if (Array.isArray(rewrite.rules)) return rewrite;
-	if ("url" in rewrite) return rewrite[context];
-	return { rules: Object.entries(rewrite).map(([canonical, localized]) => ({
-		canonical: canonical.startsWith("/") ? canonical.replace(/\[([^\]]+)\]/g, ":$1") : `/${canonical.replace(/\[([^\]]+)\]/g, ":$1")}`,
-		localized: Object.fromEntries(Object.entries(localized).map(([locale, pattern]) => {
-			return [locale, pattern?.startsWith("/") ? pattern.replace(/\[([^\]]+)\]/g, ":$1") : `/${(pattern || "").replace(/\[([^\]]+)\]/g, ":$1")}`];
-		}))
-	})) };
-};
-/**
-* Converts normalized pattern to Regex.
-* Internal syntax supports:
-* - :param -> ([^/]+) (one segment)
-* - :param* -> (.*) (zero or more segments)
-* - :param+ -> (.+) (one or more segments)
-* - :param? -> ([^/]*) (zero or one segment)
-*/
-const patternToRegex = (pattern) => {
-	const regexString = pattern.replace(/\//g, "\\/").replace(/\\\/:(?:[^/\\*+?]+)\*/g, "(?:\\/(.*))?").replace(/\\\/:(?:[^/\\*+?]+)\?/g, "(?:\\/([^\\/]+))?").replace(/:([^/\\*+?]+)\*/g, "(.*)").replace(/:([^/\\*+?]+)\?/g, "([^\\/]*)").replace(/:([^/\\*+?]+)\+/g, "(.+)").replace(/:([^/\\*+?]+)/g, "([^\\/]+)");
-	return new RegExp(`^${regexString}$`);
-};
-/**
-* Replaces route parameters in a path with provided values.
-*/
-const fillPath = (pattern, params) => {
-	let index = 0;
-	return pattern.replace(/:([^/\\*+?]+)[*+?]?/g, () => params[index++] ?? "").replace(/\/+/g, "/").replace(/\/$/, "") || "/";
-};
-/**
-* Extract values from a URL based on a pattern.
-*/
-const extractParams = (url, pattern) => {
-	const regex = patternToRegex(pattern);
-	const match = url.match(regex);
-	return match ? match.slice(1) : null;
-};
-/**
-* Given a localized URL (e.g., "/produits/123"), finds the canonical internal path (e.g., "/products/123").
-* If locale is provided, only check for that locale. Otherwise, check for all locales.
-*/
-const getCanonicalPath = (localizedPath, locale, rewriteRules) => {
-	if (!rewriteRules || process.env.INTLAYER_ROUTING_REWRITE_RULES && process.env.INTLAYER_ROUTING_REWRITE_RULES === "false") return localizedPath;
-	for (const rule of rewriteRules.rules) {
-		const { canonical, localized } = rule;
-		const localesToCheck = locale ? [locale] : Object.keys(localized);
-		for (const loc of localesToCheck) {
-			const localizedPattern = localized[loc];
-			if (!localizedPattern) continue;
-			const params = extractParams(localizedPath, localizedPattern);
-			if (params) return fillPath(canonical, params);
-		}
-	}
-	return localizedPath;
-};
-/**
 * Given a canonical path (e.g., "/products/123"), finds the localized URL pattern
 * (e.g., "/produits/123") and reports whether a rule actually matched.
 *
@@ -85,11 +25,11 @@ const resolveLocalizedPath = (canonicalPath, locale, rewriteRules) => {
 	};
 	for (const rule of rewriteRules.rules) {
 		const { canonical, localized } = rule;
-		const params = extractParams(canonicalPath, canonical);
+		const params = require_localization_rewriteMatch.extractParams(canonicalPath, canonical);
 		if (params) {
 			const targetPattern = localized[locale ?? _intlayer_config_built.internationalization.defaultLocale];
 			if (targetPattern) return {
-				path: fillPath(targetPattern, params),
+				path: require_localization_rewriteMatch.fillPath(targetPattern, params),
 				isRewritten: true
 			};
 		}
@@ -113,17 +53,15 @@ const getInternalPath = (canonicalPath, locale) => {
 */
 const getRewritePath = (pathname, locale, rewrite) => {
 	if (process.env.INTLAYER_ROUTING_REWRITE_RULES && process.env.INTLAYER_ROUTING_REWRITE_RULES === "false") return void 0;
-	const rules = getRewriteRules(rewrite, "url");
+	const rules = require_localization_rewriteMatch.getRewriteRules(rewrite, "url");
 	if (!rules) return void 0;
-	const canonicalPath = getCanonicalPath(pathname, void 0, rules);
+	const canonicalPath = require_localization_getCanonicalPath.getCanonicalPath(pathname, void 0, rules);
 	const { path: localizedPath, isRewritten } = resolveLocalizedPath(canonicalPath, locale, rules);
 	if (isRewritten && localizedPath !== pathname) return localizedPath;
 };
 
 //#endregion
-exports.getCanonicalPath = getCanonicalPath;
 exports.getInternalPath = getInternalPath;
 exports.getRewritePath = getRewritePath;
-exports.getRewriteRules = getRewriteRules;
 exports.resolveLocalizedPath = resolveLocalizedPath;
 //# sourceMappingURL=rewriteUtils.cjs.map

package/dist/cjs/localization/rewriteUtils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"rewriteUtils.cjs","names":["legacyRules","internationalization"],"sources":["../../../src/localization/rewriteUtils.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type {\n  RewriteObject,\n  RewriteRules,\n  RoutingConfig,\n} from '@intlayer/types/config';\nimport type {\n  LocalesValues,\n  ResolvedDefaultLocale,\n} from '@intlayer/types/module_augmentation';\n\n/**\n * Outcome of resolving a canonical path against the rewrite rules.\n *\n * Discriminated on `isRewritten`: when no rule matched, `path` is the very\n * input that was passed in, so a literal input keeps its literal type. Only a\n * rewritten path is computed at runtime and therefore widens to `string`.\n */\nexport type LocalizedPathResult<CanonicalPath extends string = string> =\n  | { path: CanonicalPath; isRewritten: false }\n  | { path: string; isRewritten: true };\n\n/** Adds the leading slash a path may be missing. */\ntype WithLeadingSlash<Path extends string> = Path extends `/${string}`\n  ? Path\n  : `/${Path}`;\n\n/**\n * Computes the locale-prefixed internal path for a path and a locale, mirroring\n * `getInternalPath`'s runtime behaviour: an already-prefixed path is returned\n * untouched, the root collapses to `/${Locale}` (never a trailing slash), and\n * anything else gets the prefix prepended.\n *\n * Falls back to `string` for a non-literal path, where the prefixed and\n * already-prefixed cases cannot be told apart.\n *\n * @example\n * type A = InternalPath<'/about', 'fr'>;    // '/fr/about'\n * type B = InternalPath<'/', 'fr'>;         // '/fr'\n * type C = InternalPath<'/fr/about', 'fr'>; // '/fr/about' (already prefixed)\n */\nexport type InternalPath<\n  Path extends string,\n  Locale extends string,\n> = string extends Path\n  ? string\n  : WithLeadingSlash<Path> extends infer Prefixed extends string\n    ? Prefixed extends `/${Locale}` | `/${Locale}/${string}`\n      ? Prefixed\n      : Prefixed extends '/'\n        ? `/${Locale}`\n        : `/${Locale}${Prefixed}`\n    : never;\n\n/**\n * Normalizes legacy Record format or extracts specialized rules from RewriteObject.\n *\n * Idempotent: already-normalized rules are handed back untouched, so a caller\n * holding resolved rules can pass them on without re-normalizing.\n */\nexport const getRewriteRules = <\n  const Context extends keyof RewriteObject = 'url',\n>(\n  rewrite: RoutingConfig['rewrite'] | RewriteRules,\n  context: Context = 'url' as Context\n): RewriteRules | undefined => {\n  if (\n    !rewrite ||\n    (process.env.INTLAYER_ROUTING_REWRITE_RULES &&\n      process.env.INTLAYER_ROUTING_REWRITE_RULES === 'false')\n  )\n    return undefined;\n\n  if (Array.isArray((rewrite as RewriteRules).rules)) {\n    return rewrite as RewriteRules;\n  }\n\n  if ('url' in rewrite) {\n    return (rewrite as RewriteObject)[context];\n  }\n\n  // Normalize legacy format\n  const legacyRules = rewrite as Record<string, Record<string, string>>;\n\n  return {\n    rules: Object.entries(legacyRules).map(([canonical, localized]) => ({\n      // Normalize canonical path\n      canonical: canonical.startsWith('/')\n        ? canonical.replace(/\\[([^\\]]+)\\]/g, ':$1')\n        : `/${canonical.replace(/\\[([^\\]]+)\\]/g, ':$1')}`,\n\n      // Normalize localized path\n      localized: Object.fromEntries(\n        Object.entries(localized).map(([locale, pattern]) => {\n          const normalizedPattern = pattern?.startsWith('/')\n            ? pattern.replace(/\\[([^\\]]+)\\]/g, ':$1')\n            : `/${(pattern || '').replace(/\\[([^\\]]+)\\]/g, ':$1')}`;\n          return [locale, normalizedPattern];\n        })\n      ),\n    })),\n  };\n};\n\n/**\n * Converts normalized pattern to Regex.\n * Internal syntax supports:\n * - :param -> ([^/]+) (one segment)\n * - :param* -> (.*) (zero or more segments)\n * - :param+ -> (.+) (one or more segments)\n * - :param? -> ([^/]*) (zero or one segment)\n */\nconst patternToRegex = (pattern: string) => {\n  const regexString = pattern\n    .replace(/\\//g, '\\\\/') // Escape slashes\n    .replace(/\\\\\\/:(?:[^/\\\\*+?]+)\\*/g, '(?:\\\\/(.*))?') // /:param*\n    .replace(/\\\\\\/:(?:[^/\\\\*+?]+)\\?/g, '(?:\\\\/([^\\\\/]+))?') // /:param?\n    .replace(/:([^/\\\\*+?]+)\\*/g, '(.*)') // :param* (if no leading slash)\n    .replace(/:([^/\\\\*+?]+)\\?/g, '([^\\\\/]*)') // :param? (if no leading slash)\n    .replace(/:([^/\\\\*+?]+)\\+/g, '(.+)') // :param+\n    .replace(/:([^/\\\\*+?]+)/g, '([^\\\\/]+)'); // :param\n\n  return new RegExp(`^${regexString}$`);\n};\n\n/**\n * Replaces route parameters in a path with provided values.\n */\nconst fillPath = (pattern: string, params: string[]) => {\n  let index = 0;\n  return (\n    pattern\n      .replace(/:([^/\\\\*+?]+)[*+?]?/g, () => params[index++] ?? '')\n      .replace(/\\/+/g, '/')\n      .replace(/\\/$/, '') || '/'\n  );\n};\n\n/**\n * Extract values from a URL based on a pattern.\n */\nconst extractParams = (url: string, pattern: string): string[] | null => {\n  const regex = patternToRegex(pattern);\n  const match = url.match(regex);\n  return match ? match.slice(1) : null;\n};\n\n/**\n * Given a localized URL (e.g., \"/produits/123\"), finds the canonical internal path (e.g., \"/products/123\").\n * If locale is provided, only check for that locale. Otherwise, check for all locales.\n */\nexport const getCanonicalPath = <\n  const Path extends string,\n  const Locale extends LocalesValues = LocalesValues,\n>(\n  localizedPath: Path,\n  locale?: Locale,\n  rewriteRules?: RewriteRules\n): string => {\n  if (\n    !rewriteRules ||\n    (process.env.INTLAYER_ROUTING_REWRITE_RULES &&\n      process.env.INTLAYER_ROUTING_REWRITE_RULES === 'false')\n  )\n    return localizedPath;\n\n  for (const rule of rewriteRules.rules) {\n    const { canonical, localized } = rule;\n    const localesToCheck = locale ? [locale] : Object.keys(localized);\n\n    for (const loc of localesToCheck) {\n      const localizedPattern = localized[loc as keyof typeof localized];\n\n      if (!localizedPattern) continue;\n\n      const params = extractParams(localizedPath, localizedPattern);\n\n      if (params) {\n        return fillPath(canonical, params);\n      }\n    }\n  }\n\n  return localizedPath;\n};\n\n/**\n * Given a canonical path (e.g., \"/products/123\"), finds the localized URL pattern\n * (e.g., \"/produits/123\") and reports whether a rule actually matched.\n *\n * Takes already-normalized rules, so callers that resolve the rules once (proxies,\n * static emitters) can reuse them. {@link getLocalizedPath} is the user-facing\n * counterpart: it accepts the raw `routing.rewrite` configuration, defaults to the\n * project configuration, and returns the path alone.\n *\n * @param canonicalPath - The internal application path (e.g. `/product/:id`, `/about`).\n * @param locale - The target locale. Defaults to the configured default locale.\n * @param rewriteRules - Normalized rules, as returned by {@link getRewriteRules}.\n * @returns The localized path, discriminated on whether a rewrite rule matched.\n */\nexport const resolveLocalizedPath = <\n  const CanonicalPath extends string,\n  const Locale extends LocalesValues = ResolvedDefaultLocale,\n>(\n  canonicalPath: CanonicalPath,\n  locale?: Locale,\n  rewriteRules?: RewriteRules\n): LocalizedPathResult<CanonicalPath> => {\n  if (\n    !rewriteRules ||\n    (process.env.INTLAYER_ROUTING_REWRITE_RULES &&\n      process.env.INTLAYER_ROUTING_REWRITE_RULES === 'false')\n  )\n    return { path: canonicalPath, isRewritten: false };\n\n  for (const rule of rewriteRules.rules) {\n    const { canonical, localized } = rule;\n\n    // Check if the input path matches a configured canonical pattern\n    const params = extractParams(canonicalPath, canonical);\n\n    if (params) {\n      const targetLocale = locale ?? internationalization.defaultLocale;\n      const targetPattern = localized[targetLocale as keyof typeof localized];\n\n      if (targetPattern) {\n        return {\n          path: fillPath(targetPattern, params),\n          isRewritten: true,\n        };\n      }\n    }\n  }\n\n  return { path: canonicalPath, isRewritten: false };\n};\n\n/**\n * Returns the internal path for a given canonical path and locale.\n * Ensures the locale prefix is present exactly once.\n */\nexport const getInternalPath = <\n  const Path extends string,\n  const Locale extends LocalesValues,\n>(\n  canonicalPath: Path,\n  locale: Locale\n): InternalPath<Path, Locale> => {\n  const pathWithLeadingSlash = canonicalPath.startsWith('/')\n    ? canonicalPath\n    : `/${canonicalPath}`;\n\n  if (\n    pathWithLeadingSlash.startsWith(`/${locale}/`) ||\n    pathWithLeadingSlash === `/${locale}`\n  ) {\n    return pathWithLeadingSlash as InternalPath<Path, Locale>;\n  }\n\n  return `/${locale}${\n    pathWithLeadingSlash === '/' ? '' : pathWithLeadingSlash\n  }` as InternalPath<Path, Locale>;\n};\n\n/**\n * Given a current pathname and locale, returns the pretty localized path if a rewrite rule exists and the path is not already localized.\n */\nexport const getRewritePath = <\n  const Path extends string,\n  const Locale extends LocalesValues = ResolvedDefaultLocale,\n>(\n  pathname: Path,\n  locale: Locale,\n  rewrite?: RoutingConfig['rewrite']\n): string | undefined => {\n  if (\n    process.env.INTLAYER_ROUTING_REWRITE_RULES &&\n    process.env.INTLAYER_ROUTING_REWRITE_RULES === 'false'\n  )\n    return undefined;\n  const rules = getRewriteRules(rewrite, 'url');\n  if (!rules) return undefined;\n\n  // Identify canonical path (relative to root, no locale prefix expected in 'url' context)\n  const canonicalPath = getCanonicalPath(pathname, undefined, rules);\n\n  // Get the localized path for the current locale\n  const { path: localizedPath, isRewritten } = resolveLocalizedPath(\n    canonicalPath,\n    locale,\n    rules\n  );\n\n  if (isRewritten && localizedPath !== pathname) {\n    return localizedPath;\n  }\n\n  return undefined;\n};\n"],"mappings":";;;;;;;;;;AA4DA,MAAa,mBAGX,SACA,UAAmB,UACU;CAC7B,IACE,CAAC,WACA,QAAQ,IAAI,kCACX,QAAQ,IAAI,mCAAmC,SAEjD,OAAO;CAET,IAAI,MAAM,QAAS,QAAyB,KAAK,GAC/C,OAAO;CAGT,IAAI,SAAS,SACX,OAAQ,QAA0B;CAMpC,OAAO,EACL,OAAO,OAAO,QAAQA,OAAW,CAAC,CAAC,KAAK,CAAC,WAAW,gBAAgB;EAElE,WAAW,UAAU,WAAW,GAAG,IAC/B,UAAU,QAAQ,iBAAiB,KAAK,IACxC,IAAI,UAAU,QAAQ,iBAAiB,KAAK;EAGhD,WAAW,OAAO,YAChB,OAAO,QAAQ,SAAS,CAAC,CAAC,KAAK,CAAC,QAAQ,aAAa;GAInD,OAAO,CAAC,QAHkB,SAAS,WAAW,GAAG,IAC7C,QAAQ,QAAQ,iBAAiB,KAAK,IACtC,KAAK,WAAW,GAAE,CAAE,QAAQ,iBAAiB,KAAK,GACrB;EACnC,CAAC,CACH;CACF,EAAE,EACJ;AACF;;;;;;;;;AAUA,MAAM,kBAAkB,YAAoB;CAC1C,MAAM,cAAc,QACjB,QAAQ,OAAO,KAAK,CAAC,CACrB,QAAQ,0BAA0B,cAAc,CAAC,CACjD,QAAQ,0BAA0B,mBAAmB,CAAC,CACtD,QAAQ,oBAAoB,MAAM,CAAC,CACnC,QAAQ,oBAAoB,WAAW,CAAC,CACxC,QAAQ,oBAAoB,MAAM,CAAC,CACnC,QAAQ,kBAAkB,WAAW;CAExC,OAAO,IAAI,OAAO,IAAI,YAAY,EAAE;AACtC;;;;AAKA,MAAM,YAAY,SAAiB,WAAqB;CACtD,IAAI,QAAQ;CACZ,OACE,QACG,QAAQ,8BAA8B,OAAO,YAAY,EAAE,CAAC,CAC5D,QAAQ,QAAQ,GAAG,CAAC,CACpB,QAAQ,OAAO,EAAE,KAAK;AAE7B;;;;AAKA,MAAM,iBAAiB,KAAa,YAAqC;CACvE,MAAM,QAAQ,eAAe,OAAO;CACpC,MAAM,QAAQ,IAAI,MAAM,KAAK;CAC7B,OAAO,QAAQ,MAAM,MAAM,CAAC,IAAI;AAClC;;;;;AAMA,MAAa,oBAIX,eACA,QACA,iBACW;CACX,IACE,CAAC,gBACA,QAAQ,IAAI,kCACX,QAAQ,IAAI,mCAAmC,SAEjD,OAAO;CAET,KAAK,MAAM,QAAQ,aAAa,OAAO;EACrC,MAAM,EAAE,WAAW,cAAc;EACjC,MAAM,iBAAiB,SAAS,CAAC,MAAM,IAAI,OAAO,KAAK,SAAS;EAEhE,KAAK,MAAM,OAAO,gBAAgB;GAChC,MAAM,mBAAmB,UAAU;GAEnC,IAAI,CAAC,kBAAkB;GAEvB,MAAM,SAAS,cAAc,eAAe,gBAAgB;GAE5D,IAAI,QACF,OAAO,SAAS,WAAW,MAAM;EAErC;CACF;CAEA,OAAO;AACT;;;;;;;;;;;;;;;AAgBA,MAAa,wBAIX,eACA,QACA,iBACuC;CACvC,IACE,CAAC,gBACA,QAAQ,IAAI,kCACX,QAAQ,IAAI,mCAAmC,SAEjD,OAAO;EAAE,MAAM;EAAe,aAAa;CAAM;CAEnD,KAAK,MAAM,QAAQ,aAAa,OAAO;EACrC,MAAM,EAAE,WAAW,cAAc;EAGjC,MAAM,SAAS,cAAc,eAAe,SAAS;EAErD,IAAI,QAAQ;GAEV,MAAM,gBAAgB,UADD,UAAUC,4CAAqB;GAGpD,IAAI,eACF,OAAO;IACL,MAAM,SAAS,eAAe,MAAM;IACpC,aAAa;GACf;EAEJ;CACF;CAEA,OAAO;EAAE,MAAM;EAAe,aAAa;CAAM;AACnD;;;;;AAMA,MAAa,mBAIX,eACA,WAC+B;CAC/B,MAAM,uBAAuB,cAAc,WAAW,GAAG,IACrD,gBACA,IAAI;CAER,IACE,qBAAqB,WAAW,IAAI,OAAO,EAAE,KAC7C,yBAAyB,IAAI,UAE7B,OAAO;CAGT,OAAO,IAAI,SACT,yBAAyB,MAAM,KAAK;AAExC;;;;AAKA,MAAa,kBAIX,UACA,QACA,YACuB;CACvB,IACE,QAAQ,IAAI,kCACZ,QAAQ,IAAI,mCAAmC,SAE/C,OAAO;CACT,MAAM,QAAQ,gBAAgB,SAAS,KAAK;CAC5C,IAAI,CAAC,OAAO,OAAO;CAGnB,MAAM,gBAAgB,iBAAiB,UAAU,QAAW,KAAK;CAGjE,MAAM,EAAE,MAAM,eAAe,gBAAgB,qBAC3C,eACA,QACA,KACF;CAEA,IAAI,eAAe,kBAAkB,UACnC,OAAO;AAIX"}
+{"version":3,"file":"rewriteUtils.cjs","names":["extractParams","internationalization","fillPath","getRewriteRules","getCanonicalPath"],"sources":["../../../src/localization/rewriteUtils.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { RewriteRules, RoutingConfig } from '@intlayer/types/config';\nimport type {\n  LocalesValues,\n  ResolvedDefaultLocale,\n} from '@intlayer/types/module_augmentation';\nimport { getCanonicalPath } from './getCanonicalPath';\nimport { extractParams, fillPath, getRewriteRules } from './rewriteMatch';\n\n/**\n * Outcome of resolving a canonical path against the rewrite rules.\n *\n * Discriminated on `isRewritten`: when no rule matched, `path` is the very\n * input that was passed in, so a literal input keeps its literal type. Only a\n * rewritten path is computed at runtime and therefore widens to `string`.\n */\nexport type LocalizedPathResult<CanonicalPath extends string = string> =\n  | { path: CanonicalPath; isRewritten: false }\n  | { path: string; isRewritten: true };\n\n/** Adds the leading slash a path may be missing. */\ntype WithLeadingSlash<Path extends string> = Path extends `/${string}`\n  ? Path\n  : `/${Path}`;\n\n/**\n * Computes the locale-prefixed internal path for a path and a locale, mirroring\n * `getInternalPath`'s runtime behaviour: an already-prefixed path is returned\n * untouched, the root collapses to `/${Locale}` (never a trailing slash), and\n * anything else gets the prefix prepended.\n *\n * Falls back to `string` for a non-literal path, where the prefixed and\n * already-prefixed cases cannot be told apart.\n *\n * @example\n * type A = InternalPath<'/about', 'fr'>;    // '/fr/about'\n * type B = InternalPath<'/', 'fr'>;         // '/fr'\n * type C = InternalPath<'/fr/about', 'fr'>; // '/fr/about' (already prefixed)\n */\nexport type InternalPath<\n  Path extends string,\n  Locale extends string,\n> = string extends Path\n  ? string\n  : WithLeadingSlash<Path> extends infer Prefixed extends string\n    ? Prefixed extends `/${Locale}` | `/${Locale}/${string}`\n      ? Prefixed\n      : Prefixed extends '/'\n        ? `/${Locale}`\n        : `/${Locale}${Prefixed}`\n    : never;\n\n/**\n * Given a canonical path (e.g., \"/products/123\"), finds the localized URL pattern\n * (e.g., \"/produits/123\") and reports whether a rule actually matched.\n *\n * Takes already-normalized rules, so callers that resolve the rules once (proxies,\n * static emitters) can reuse them. {@link getLocalizedPath} is the user-facing\n * counterpart: it accepts the raw `routing.rewrite` configuration, defaults to the\n * project configuration, and returns the path alone.\n *\n * @param canonicalPath - The internal application path (e.g. `/product/:id`, `/about`).\n * @param locale - The target locale. Defaults to the configured default locale.\n * @param rewriteRules - Normalized rules, as returned by {@link getRewriteRules}.\n * @returns The localized path, discriminated on whether a rewrite rule matched.\n */\nexport const resolveLocalizedPath = <\n  const CanonicalPath extends string,\n  const Locale extends LocalesValues = ResolvedDefaultLocale,\n>(\n  canonicalPath: CanonicalPath,\n  locale?: Locale,\n  rewriteRules?: RewriteRules\n): LocalizedPathResult<CanonicalPath> => {\n  if (\n    !rewriteRules ||\n    (process.env.INTLAYER_ROUTING_REWRITE_RULES &&\n      process.env.INTLAYER_ROUTING_REWRITE_RULES === 'false')\n  )\n    return { path: canonicalPath, isRewritten: false };\n\n  for (const rule of rewriteRules.rules) {\n    const { canonical, localized } = rule;\n\n    // Check if the input path matches a configured canonical pattern\n    const params = extractParams(canonicalPath, canonical);\n\n    if (params) {\n      const targetLocale = locale ?? internationalization.defaultLocale;\n      const targetPattern = localized[targetLocale as keyof typeof localized];\n\n      if (targetPattern) {\n        return {\n          path: fillPath(targetPattern, params),\n          isRewritten: true,\n        };\n      }\n    }\n  }\n\n  return { path: canonicalPath, isRewritten: false };\n};\n\n/**\n * Returns the internal path for a given canonical path and locale.\n * Ensures the locale prefix is present exactly once.\n */\nexport const getInternalPath = <\n  const Path extends string,\n  const Locale extends LocalesValues,\n>(\n  canonicalPath: Path,\n  locale: Locale\n): InternalPath<Path, Locale> => {\n  const pathWithLeadingSlash = canonicalPath.startsWith('/')\n    ? canonicalPath\n    : `/${canonicalPath}`;\n\n  if (\n    pathWithLeadingSlash.startsWith(`/${locale}/`) ||\n    pathWithLeadingSlash === `/${locale}`\n  ) {\n    return pathWithLeadingSlash as InternalPath<Path, Locale>;\n  }\n\n  return `/${locale}${\n    pathWithLeadingSlash === '/' ? '' : pathWithLeadingSlash\n  }` as InternalPath<Path, Locale>;\n};\n\n/**\n * Given a current pathname and locale, returns the pretty localized path if a rewrite rule exists and the path is not already localized.\n */\nexport const getRewritePath = <\n  const Path extends string,\n  const Locale extends LocalesValues = ResolvedDefaultLocale,\n>(\n  pathname: Path,\n  locale: Locale,\n  rewrite?: RoutingConfig['rewrite']\n): string | undefined => {\n  if (\n    process.env.INTLAYER_ROUTING_REWRITE_RULES &&\n    process.env.INTLAYER_ROUTING_REWRITE_RULES === 'false'\n  )\n    return undefined;\n  const rules = getRewriteRules(rewrite, 'url');\n  if (!rules) return undefined;\n\n  // Identify canonical path (relative to root, no locale prefix expected in 'url' context)\n  const canonicalPath = getCanonicalPath(pathname, undefined, rules);\n\n  // Get the localized path for the current locale\n  const { path: localizedPath, isRewritten } = resolveLocalizedPath(\n    canonicalPath,\n    locale,\n    rules\n  );\n\n  if (isRewritten && localizedPath !== pathname) {\n    return localizedPath;\n  }\n\n  return undefined;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAkEA,MAAa,wBAIX,eACA,QACA,iBACuC;CACvC,IACE,CAAC,gBACA,QAAQ,IAAI,kCACX,QAAQ,IAAI,mCAAmC,SAEjD,OAAO;EAAE,MAAM;EAAe,aAAa;CAAM;CAEnD,KAAK,MAAM,QAAQ,aAAa,OAAO;EACrC,MAAM,EAAE,WAAW,cAAc;EAGjC,MAAM,SAASA,gDAAc,eAAe,SAAS;EAErD,IAAI,QAAQ;GAEV,MAAM,gBAAgB,UADD,UAAUC,4CAAqB;GAGpD,IAAI,eACF,OAAO;IACL,MAAMC,2CAAS,eAAe,MAAM;IACpC,aAAa;GACf;EAEJ;CACF;CAEA,OAAO;EAAE,MAAM;EAAe,aAAa;CAAM;AACnD;;;;;AAMA,MAAa,mBAIX,eACA,WAC+B;CAC/B,MAAM,uBAAuB,cAAc,WAAW,GAAG,IACrD,gBACA,IAAI;CAER,IACE,qBAAqB,WAAW,IAAI,OAAO,EAAE,KAC7C,yBAAyB,IAAI,UAE7B,OAAO;CAGT,OAAO,IAAI,SACT,yBAAyB,MAAM,KAAK;AAExC;;;;AAKA,MAAa,kBAIX,UACA,QACA,YACuB;CACvB,IACE,QAAQ,IAAI,kCACZ,QAAQ,IAAI,mCAAmC,SAE/C,OAAO;CACT,MAAM,QAAQC,kDAAgB,SAAS,KAAK;CAC5C,IAAI,CAAC,OAAO,OAAO;CAGnB,MAAM,gBAAgBC,uDAAiB,UAAU,QAAW,KAAK;CAGjE,MAAM,EAAE,MAAM,eAAe,gBAAgB,qBAC3C,eACA,QACA,KACF;CAEA,IAAI,eAAe,kBAAkB,UACnC,OAAO;AAIX"}

package/dist/cjs/localization/rewriteUtils.test-d.cjs

@@ -38,11 +38,6 @@ let vitest = require("vitest");
 		(0, vitest.expectTypeOf)(require_localization_rewriteUtils.resolveLocalizedPath("/about")).toEqualTypeOf();
 	});
 });
-(0, vitest.describe)("getCanonicalPath", () => {
-	(0, vitest.it)("should accept an omitted locale (checks every locale)", () => {
-		(0, vitest.expectTypeOf)(require_localization_rewriteUtils.getCanonicalPath("/a-propos")).toEqualTypeOf();
-	});
-});
 
 //#endregion
 //# sourceMappingURL=rewriteUtils.test-d.cjs.map

package/dist/cjs/localization/rewriteUtils.test-d.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"rewriteUtils.test-d.cjs","names":["describe","getInternalPath","resolveLocalizedPath","getCanonicalPath"],"sources":["../../../src/localization/rewriteUtils.test-d.ts"],"sourcesContent":["import { describe, expectTypeOf, it } from 'vitest';\nimport {\n  getCanonicalPath,\n  getInternalPath,\n  resolveLocalizedPath,\n} from './rewriteUtils';\n\n/**\n * `getInternalPath` is pure string surgery — no rewrite rules involved — so its\n * result is fully derivable from the arguments whenever both are literals.\n */\ndescribe('getInternalPath', () => {\n  it('should prefix a literal path with the locale', () => {\n    expectTypeOf(getInternalPath('/about', 'fr')).toEqualTypeOf<'/fr/about'>();\n  });\n\n  it('should collapse the root to a bare prefix, never a trailing slash', () => {\n    expectTypeOf(getInternalPath('/', 'fr')).toEqualTypeOf<'/fr'>();\n  });\n\n  it('should leave an already-prefixed path untouched', () => {\n    expectTypeOf(\n      getInternalPath('/fr/about', 'fr')\n    ).toEqualTypeOf<'/fr/about'>();\n    expectTypeOf(getInternalPath('/fr', 'fr')).toEqualTypeOf<'/fr'>();\n  });\n\n  it('should add the leading slash a path is missing', () => {\n    expectTypeOf(getInternalPath('about', 'fr')).toEqualTypeOf<'/fr/about'>();\n  });\n\n  it('should widen to string when the path is not a literal', () => {\n    const dynamicPath = '/about' as string;\n\n    expectTypeOf(getInternalPath(dynamicPath, 'fr')).toEqualTypeOf<string>();\n  });\n});\n\n/**\n * `resolveLocalizedPath` only computes a new path when a rule matched, so the\n * `isRewritten: false` branch still carries the exact input it was given.\n */\ndescribe('resolveLocalizedPath', () => {\n  it('should keep the input literal on the non-rewritten branch', () => {\n    const result = resolveLocalizedPath('/about', 'fr');\n\n    if (!result.isRewritten) {\n      expectTypeOf(result.path).toEqualTypeOf<'/about'>();\n    } else {\n      expectTypeOf(result.path).toEqualTypeOf<string>();\n    }\n  });\n\n  it('should discriminate on isRewritten', () => {\n    expectTypeOf(resolveLocalizedPath('/about')).toEqualTypeOf<\n      | { path: '/about'; isRewritten: false }\n      | { path: string; isRewritten: true }\n    >();\n  });\n});\n\ndescribe('getCanonicalPath', () => {\n  it('should accept an omitted locale (checks every locale)', () => {\n    expectTypeOf(getCanonicalPath('/a-propos')).toEqualTypeOf<string>();\n  });\n});\n"],"mappings":";;;;;;;;IAWAA,iBAAS,yBAAyB;CAChC,eAAG,sDAAsD;EACvD,yBAAaC,kDAAgB,UAAU,IAAI,CAAC,CAAC,CAAC,cAA2B;CAC3E,CAAC;CAED,eAAG,2EAA2E;EAC5E,yBAAaA,kDAAgB,KAAK,IAAI,CAAC,CAAC,CAAC,cAAqB;CAChE,CAAC;CAED,eAAG,yDAAyD;EAC1D,yBACEA,kDAAgB,aAAa,IAAI,CACnC,CAAC,CAAC,cAA2B;EAC7B,yBAAaA,kDAAgB,OAAO,IAAI,CAAC,CAAC,CAAC,cAAqB;CAClE,CAAC;CAED,eAAG,wDAAwD;EACzD,yBAAaA,kDAAgB,SAAS,IAAI,CAAC,CAAC,CAAC,cAA2B;CAC1E,CAAC;CAED,eAAG,+DAA+D;EAGhE,yBAAaA,kDAAgB,UAAa,IAAI,CAAC,CAAC,CAAC,cAAsB;CACzE,CAAC;AACH,CAAC;;;;;IAMDD,iBAAS,8BAA8B;CACrC,eAAG,mEAAmE;EACpE,MAAM,SAASE,uDAAqB,UAAU,IAAI;EAElD,IAAI,CAAC,OAAO,aACV,yBAAa,OAAO,IAAI,CAAC,CAAC,cAAwB;OAElD,yBAAa,OAAO,IAAI,CAAC,CAAC,cAAsB;CAEpD,CAAC;CAED,eAAG,4CAA4C;EAC7C,yBAAaA,uDAAqB,QAAQ,CAAC,CAAC,CAAC,cAG3C;CACJ,CAAC;AACH,CAAC;IAEDF,iBAAS,0BAA0B;CACjC,eAAG,+DAA+D;EAChE,yBAAaG,mDAAiB,WAAW,CAAC,CAAC,CAAC,cAAsB;CACpE,CAAC;AACH,CAAC"}
+{"version":3,"file":"rewriteUtils.test-d.cjs","names":["describe","getInternalPath","resolveLocalizedPath"],"sources":["../../../src/localization/rewriteUtils.test-d.ts"],"sourcesContent":["import { describe, expectTypeOf, it } from 'vitest';\nimport { getInternalPath, resolveLocalizedPath } from './rewriteUtils';\n\n/**\n * `getInternalPath` is pure string surgery — no rewrite rules involved — so its\n * result is fully derivable from the arguments whenever both are literals.\n */\ndescribe('getInternalPath', () => {\n  it('should prefix a literal path with the locale', () => {\n    expectTypeOf(getInternalPath('/about', 'fr')).toEqualTypeOf<'/fr/about'>();\n  });\n\n  it('should collapse the root to a bare prefix, never a trailing slash', () => {\n    expectTypeOf(getInternalPath('/', 'fr')).toEqualTypeOf<'/fr'>();\n  });\n\n  it('should leave an already-prefixed path untouched', () => {\n    expectTypeOf(\n      getInternalPath('/fr/about', 'fr')\n    ).toEqualTypeOf<'/fr/about'>();\n    expectTypeOf(getInternalPath('/fr', 'fr')).toEqualTypeOf<'/fr'>();\n  });\n\n  it('should add the leading slash a path is missing', () => {\n    expectTypeOf(getInternalPath('about', 'fr')).toEqualTypeOf<'/fr/about'>();\n  });\n\n  it('should widen to string when the path is not a literal', () => {\n    const dynamicPath = '/about' as string;\n\n    expectTypeOf(getInternalPath(dynamicPath, 'fr')).toEqualTypeOf<string>();\n  });\n});\n\n/**\n * `resolveLocalizedPath` only computes a new path when a rule matched, so the\n * `isRewritten: false` branch still carries the exact input it was given.\n */\ndescribe('resolveLocalizedPath', () => {\n  it('should keep the input literal on the non-rewritten branch', () => {\n    const result = resolveLocalizedPath('/about', 'fr');\n\n    if (!result.isRewritten) {\n      expectTypeOf(result.path).toEqualTypeOf<'/about'>();\n    } else {\n      expectTypeOf(result.path).toEqualTypeOf<string>();\n    }\n  });\n\n  it('should discriminate on isRewritten', () => {\n    expectTypeOf(resolveLocalizedPath('/about')).toEqualTypeOf<\n      | { path: '/about'; isRewritten: false }\n      | { path: string; isRewritten: true }\n    >();\n  });\n});\n"],"mappings":";;;;;;;;IAOAA,iBAAS,yBAAyB;CAChC,eAAG,sDAAsD;EACvD,yBAAaC,kDAAgB,UAAU,IAAI,CAAC,CAAC,CAAC,cAA2B;CAC3E,CAAC;CAED,eAAG,2EAA2E;EAC5E,yBAAaA,kDAAgB,KAAK,IAAI,CAAC,CAAC,CAAC,cAAqB;CAChE,CAAC;CAED,eAAG,yDAAyD;EAC1D,yBACEA,kDAAgB,aAAa,IAAI,CACnC,CAAC,CAAC,cAA2B;EAC7B,yBAAaA,kDAAgB,OAAO,IAAI,CAAC,CAAC,CAAC,cAAqB;CAClE,CAAC;CAED,eAAG,wDAAwD;EACzD,yBAAaA,kDAAgB,SAAS,IAAI,CAAC,CAAC,CAAC,cAA2B;CAC1E,CAAC;CAED,eAAG,+DAA+D;EAGhE,yBAAaA,kDAAgB,UAAa,IAAI,CAAC,CAAC,CAAC,cAAsB;CACzE,CAAC;AACH,CAAC;;;;;IAMDD,iBAAS,8BAA8B;CACrC,eAAG,mEAAmE;EACpE,MAAM,SAASE,uDAAqB,UAAU,IAAI;EAElD,IAAI,CAAC,OAAO,aACV,yBAAa,OAAO,IAAI,CAAC,CAAC,cAAwB;OAElD,yBAAa,OAAO,IAAI,CAAC,CAAC,cAAsB;CAEpD,CAAC;CAED,eAAG,4CAA4C;EAC7C,yBAAaA,uDAAqB,QAAQ,CAAC,CAAC,CAAC,cAG3C;CACJ,CAAC;AACH,CAAC"}