@intlayer/core 9.3.2 → 9.4.0-canary.0

package/dist/esm/dictionaryManipulator/plainDynamicLoader.mjs

@@ -0,0 +1,70 @@
+import { PRELOADED_DYNAMIC_KEY } from "./preloadedDynamicLoader.mjs";
+import { QUALIFIER_DYNAMIC_TYPES_KEY } from "./qualifiedDynamicLoader.mjs";
+import { internationalization } from "@intlayer/config/built";
+
+//#region src/dictionaryManipulator/plainDynamicLoader.ts
+/** Marker properties a loader map carries alongside its per-locale loaders. */
+const MARKER_KEYS = [PRELOADED_DYNAMIC_KEY, QUALIFIER_DYNAMIC_TYPES_KEY];
+/**
+* Ordered locale candidates for a chunk lookup, mirroring the static fallback
+* chain `getTranslation` applies: the requested locale, its base language, then
+* the default locale and its base language.
+*/
+const getLocaleCandidates = (locale) => {
+	const candidates = [];
+	const addCandidate = (candidate) => {
+		if (candidate && !candidates.includes(candidate)) candidates.push(candidate);
+	};
+	addCandidate(locale);
+	addCandidate(locale.split("-")[0]);
+	addCandidate(internationalization.defaultLocale);
+	addCandidate(internationalization.defaultLocale?.split("-")[0]);
+	return candidates;
+};
+/**
+* Picks the chunk loader serving a locale out of a plain dynamic loader map.
+*
+* A dictionary is only emitted for the locales it declares, so a read for any
+* other locale — an undeclared one, or a partially translated dictionary under
+* `requiredLocales` — has no chunk of its own. Static mode answers such a read
+* with the default locale's content rather than nothing, and this walks the
+* same chain so dynamic mode stays interchangeable with it.
+*
+* @param loaderMap - Default export of a generated dynamic entry point.
+* @param locale - Locale the caller is about to render.
+* @returns The loader to invoke and the locale its chunk holds, or `undefined`
+*          when the map holds no chunk for the locale nor for any fallback.
+*/
+const findPlainDynamicLoader = (loaderMap, locale) => {
+	for (const candidate of getLocaleCandidates(locale)) {
+		const loader = loaderMap[candidate];
+		if (typeof loader === "function") return {
+			locale: candidate,
+			loader
+		};
+	}
+};
+/** Lists the locales a loader map actually emitted a chunk for. */
+const getEmittedLocales = (loaderMap) => Object.keys(loaderMap).filter((loaderKey) => !MARKER_KEYS.includes(loaderKey) && typeof loaderMap[loaderKey] === "function");
+/**
+* {@link findPlainDynamicLoader}, for callers that cannot render without a
+* chunk and would otherwise fail on an `undefined` loader with an error naming
+* neither the dictionary nor the locale.
+*
+* @param loaderMap - Default export of a generated dynamic entry point.
+* @param key - Dictionary key, used to describe an unresolvable lookup.
+* @param locale - Locale the caller is about to render.
+* @returns The loader to invoke, and the locale its chunk holds.
+* @throws When neither the locale nor any of its fallbacks has a chunk, which
+*         only happens on a malformed or empty entry point.
+*/
+const resolvePlainDynamicLoader = (loaderMap, key, locale) => {
+	const resolved = findPlainDynamicLoader(loaderMap, locale);
+	if (resolved) return resolved;
+	const emittedLocales = getEmittedLocales(loaderMap);
+	throw new Error(`[intlayer] No dynamic chunk found for dictionary "${key}" and locale "${locale}". Emitted locales: ${emittedLocales.length > 0 ? emittedLocales.join(", ") : "(none)"}.`);
+};
+
+//#endregion
+export { findPlainDynamicLoader, resolvePlainDynamicLoader };
+//# sourceMappingURL=plainDynamicLoader.mjs.map

package/dist/esm/dictionaryManipulator/plainDynamicLoader.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"plainDynamicLoader.mjs","names":[],"sources":["../../../src/dictionaryManipulator/plainDynamicLoader.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { PRELOADED_DYNAMIC_KEY } from './preloadedDynamicLoader';\nimport { QUALIFIER_DYNAMIC_TYPES_KEY } from './qualifiedDynamicLoader';\n\n/**\n * Default export shape of a generated dynamic entry point for a plain (non\n * qualified) key: one lazy chunk loader per emitted locale.\n */\nexport type PlainDynamicLoaderMap<T extends Dictionary = Dictionary> = {\n  [locale: string]: (() => Promise<T>) | undefined;\n};\n\n/** A chunk loader together with the locale it was emitted for. */\nexport type ResolvedDynamicLoader<T extends Dictionary = Dictionary> = {\n  /**\n   * Locale the returned loader actually serves, which differs from the\n   * requested one whenever the fallback chain was walked.\n   */\n  locale: LocalesValues;\n  loader: () => Promise<T>;\n};\n\n/** Marker properties a loader map carries alongside its per-locale loaders. */\nconst MARKER_KEYS: string[] = [\n  PRELOADED_DYNAMIC_KEY,\n  QUALIFIER_DYNAMIC_TYPES_KEY,\n];\n\n/**\n * Ordered locale candidates for a chunk lookup, mirroring the static fallback\n * chain `getTranslation` applies: the requested locale, its base language, then\n * the default locale and its base language.\n */\nconst getLocaleCandidates = (locale: LocalesValues): string[] => {\n  const candidates: string[] = [];\n\n  const addCandidate = (candidate?: string) => {\n    if (candidate && !candidates.includes(candidate))\n      candidates.push(candidate);\n  };\n\n  addCandidate(locale);\n  addCandidate(locale.split('-')[0]);\n  addCandidate(internationalization.defaultLocale);\n  addCandidate(internationalization.defaultLocale?.split('-')[0]);\n\n  return candidates;\n};\n\n/**\n * Picks the chunk loader serving a locale out of a plain dynamic loader map.\n *\n * A dictionary is only emitted for the locales it declares, so a read for any\n * other locale — an undeclared one, or a partially translated dictionary under\n * `requiredLocales` — has no chunk of its own. Static mode answers such a read\n * with the default locale's content rather than nothing, and this walks the\n * same chain so dynamic mode stays interchangeable with it.\n *\n * @param loaderMap - Default export of a generated dynamic entry point.\n * @param locale - Locale the caller is about to render.\n * @returns The loader to invoke and the locale its chunk holds, or `undefined`\n *          when the map holds no chunk for the locale nor for any fallback.\n */\nexport const findPlainDynamicLoader = <T extends Dictionary>(\n  loaderMap: PlainDynamicLoaderMap<T>,\n  locale: LocalesValues\n): ResolvedDynamicLoader<T> | undefined => {\n  for (const candidate of getLocaleCandidates(locale)) {\n    const loader = loaderMap[candidate];\n\n    if (typeof loader === 'function') {\n      return { locale: candidate as LocalesValues, loader };\n    }\n  }\n\n  return undefined;\n};\n\n/** Lists the locales a loader map actually emitted a chunk for. */\nconst getEmittedLocales = (loaderMap: PlainDynamicLoaderMap): string[] =>\n  Object.keys(loaderMap).filter(\n    (loaderKey) =>\n      !MARKER_KEYS.includes(loaderKey) &&\n      typeof loaderMap[loaderKey] === 'function'\n  );\n\n/**\n * {@link findPlainDynamicLoader}, for callers that cannot render without a\n * chunk and would otherwise fail on an `undefined` loader with an error naming\n * neither the dictionary nor the locale.\n *\n * @param loaderMap - Default export of a generated dynamic entry point.\n * @param key - Dictionary key, used to describe an unresolvable lookup.\n * @param locale - Locale the caller is about to render.\n * @returns The loader to invoke, and the locale its chunk holds.\n * @throws When neither the locale nor any of its fallbacks has a chunk, which\n *         only happens on a malformed or empty entry point.\n */\nexport const resolvePlainDynamicLoader = <T extends Dictionary>(\n  loaderMap: PlainDynamicLoaderMap<T>,\n  key: string,\n  locale: LocalesValues\n): ResolvedDynamicLoader<T> => {\n  const resolved = findPlainDynamicLoader<T>(loaderMap, locale);\n\n  if (resolved) return resolved;\n\n  const emittedLocales = getEmittedLocales(loaderMap);\n\n  throw new Error(\n    `[intlayer] No dynamic chunk found for dictionary \"${key}\" and locale \"${locale}\". Emitted locales: ${\n      emittedLocales.length > 0 ? emittedLocales.join(', ') : '(none)'\n    }.`\n  );\n};\n"],"mappings":";;;;;;AAyBA,MAAM,cAAwB,CAC5B,uBACA,2BACF;;;;;;AAOA,MAAM,uBAAuB,WAAoC;CAC/D,MAAM,aAAuB,CAAC;CAE9B,MAAM,gBAAgB,cAAuB;EAC3C,IAAI,aAAa,CAAC,WAAW,SAAS,SAAS,GAC7C,WAAW,KAAK,SAAS;CAC7B;CAEA,aAAa,MAAM;CACnB,aAAa,OAAO,MAAM,GAAG,CAAC,CAAC,EAAE;CACjC,aAAa,qBAAqB,aAAa;CAC/C,aAAa,qBAAqB,eAAe,MAAM,GAAG,CAAC,CAAC,EAAE;CAE9D,OAAO;AACT;;;;;;;;;;;;;;;AAgBA,MAAa,0BACX,WACA,WACyC;CACzC,KAAK,MAAM,aAAa,oBAAoB,MAAM,GAAG;EACnD,MAAM,SAAS,UAAU;EAEzB,IAAI,OAAO,WAAW,YACpB,OAAO;GAAE,QAAQ;GAA4B;EAAO;CAExD;AAGF;;AAGA,MAAM,qBAAqB,cACzB,OAAO,KAAK,SAAS,CAAC,CAAC,QACpB,cACC,CAAC,YAAY,SAAS,SAAS,KAC/B,OAAO,UAAU,eAAe,UACpC;;;;;;;;;;;;;AAcF,MAAa,6BACX,WACA,KACA,WAC6B;CAC7B,MAAM,WAAW,uBAA0B,WAAW,MAAM;CAE5D,IAAI,UAAU,OAAO;CAErB,MAAM,iBAAiB,kBAAkB,SAAS;CAElD,MAAM,IAAI,MACR,qDAAqD,IAAI,gBAAgB,OAAO,sBAC9E,eAAe,SAAS,IAAI,eAAe,KAAK,IAAI,IAAI,SACzD,EACH;AACF"}

package/dist/esm/dictionaryManipulator/preloadedDynamicLoader.mjs

@@ -0,0 +1,27 @@
+import { PRELOADED_DYNAMIC_KEY } from "@intlayer/config/defaultValues";
+
+//#region src/dictionaryManipulator/preloadedDynamicLoader.ts
+/**
+* Reads the preloaded dictionary of a dynamic loader map, when one was resolved
+* for the requested locale.
+*
+* Deliberately synchronous, and deliberately not routed through the suspender
+* cache: a suspender only leaves `pending` inside a `.then` callback, so feeding
+* it an already-resolved promise would still suspend for one microtask — long
+* enough for a pending fallback to paint, which is the flash this whole
+* mechanism exists to remove.
+*
+* @param loaderMap - Default export of a generated dynamic entry point.
+* @param locale - Locale the caller is about to render.
+* @returns The dictionary when it was preloaded for `locale`, else `undefined`.
+*/
+const getPreloadedDictionary = (loaderMap, locale) => {
+	if (typeof loaderMap !== "object" || loaderMap === null) return void 0;
+	const preloaded = loaderMap[PRELOADED_DYNAMIC_KEY];
+	if (!preloaded || preloaded.locale !== locale) return void 0;
+	return preloaded.dictionary;
+};
+
+//#endregion
+export { PRELOADED_DYNAMIC_KEY, getPreloadedDictionary };
+//# sourceMappingURL=preloadedDynamicLoader.mjs.map

package/dist/esm/dictionaryManipulator/preloadedDynamicLoader.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"preloadedDynamicLoader.mjs","names":[],"sources":["../../../src/dictionaryManipulator/preloadedDynamicLoader.ts"],"sourcesContent":["import { PRELOADED_DYNAMIC_KEY } from '@intlayer/config/defaultValues';\nimport type { Dictionary } from '@intlayer/types/dictionary';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\n\n/**\n * Marker under which a generated dynamic entry point carries the dictionary it\n * preloaded while evaluating. Defined in `@intlayer/config` so the code\n * generator and the build plugins can read it without pulling the runtime in,\n * and re-exported here where the consumers of the loaded content live.\n */\nexport { PRELOADED_DYNAMIC_KEY };\n\n/**\n * The value attached under {@link PRELOADED_DYNAMIC_KEY}.\n *\n * `locale` is the locale the preamble resolved at module-evaluation time. It is\n * compared against the locale the read actually asks for, so a disagreement\n * (a client-side locale switch, or a resolution the provider overrode) falls\n * back to loading rather than serving content in the wrong language.\n */\nexport type PreloadedDynamicEntry = {\n  locale: LocalesValues;\n  dictionary: Dictionary;\n};\n\n/** A plain dynamic loader map that may carry a preloaded entry. */\nexport type PreloadableDynamicLoaderMap = {\n  [PRELOADED_DYNAMIC_KEY]?: PreloadedDynamicEntry;\n};\n\n/**\n * Reads the preloaded dictionary of a dynamic loader map, when one was resolved\n * for the requested locale.\n *\n * Deliberately synchronous, and deliberately not routed through the suspender\n * cache: a suspender only leaves `pending` inside a `.then` callback, so feeding\n * it an already-resolved promise would still suspend for one microtask — long\n * enough for a pending fallback to paint, which is the flash this whole\n * mechanism exists to remove.\n *\n * @param loaderMap - Default export of a generated dynamic entry point.\n * @param locale - Locale the caller is about to render.\n * @returns The dictionary when it was preloaded for `locale`, else `undefined`.\n */\nexport const getPreloadedDictionary = (\n  loaderMap: unknown,\n  locale: LocalesValues\n): Dictionary | undefined => {\n  if (typeof loaderMap !== 'object' || loaderMap === null) return undefined;\n\n  const preloaded = (loaderMap as PreloadableDynamicLoaderMap)[\n    PRELOADED_DYNAMIC_KEY\n  ];\n\n  if (!preloaded || preloaded.locale !== locale) return undefined;\n\n  return preloaded.dictionary;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;AA4CA,MAAa,0BACX,WACA,WAC2B;CAC3B,IAAI,OAAO,cAAc,YAAY,cAAc,MAAM,OAAO;CAEhE,MAAM,YAAa,UACjB;CAGF,IAAI,CAAC,aAAa,UAAU,WAAW,QAAQ,OAAO;CAEtD,OAAO,UAAU;AACnB"}

package/dist/esm/dictionaryManipulator/qualifiedDynamicLoader.mjs

@@ -1,18 +1,12 @@
 import { COMPOSITE_ID_SEPARATOR, resolveEffectiveVariantId, serializeVariantChain } from "./qualifiedDictionary.mjs";
+import { QUALIFIER_DYNAMIC_TYPES_KEY } from "@intlayer/config/defaultValues";
 
 //#region src/dictionaryManipulator/qualifiedDynamicLoader.ts
 /**
-* Marker property carrying the ordered qualifier dimensions on a dynamic loader
-* map. Its presence distinguishes a qualified group loader map (a nested tree
-* of chunks) from a plain dynamic loader map (one chunk per `locale`). Prefixed
-* and unlikely to collide with a real locale code.
-*/
-const QUALIFIER_DYNAMIC_TYPES_KEY = "__intlayerQualifierTypes";
-/**
 * Type guard discriminating a qualified dynamic loader map (collections /
 * variants, possibly combined) from a plain dynamic loader map.
 */
-const isQualifiedDynamicLoaderMap = (value) => typeof value === "object" && value !== null && "__intlayerQualifierTypes" in value;
+const isQualifiedDynamicLoaderMap = (value) => typeof value === "object" && value !== null && QUALIFIER_DYNAMIC_TYPES_KEY in value;
 /**
 * Walks the loader tree following the selector and collects the chunk loaders
 * it targets — shared by the sync ({@link resolveQualifiedDynamicContent}) and

package/dist/esm/dictionaryManipulator/qualifiedDynamicLoader.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"qualifiedDynamicLoader.mjs","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDynamicLoader.ts"],"sourcesContent":["import type {\n  Dictionary,\n  DictionaryQualifierType,\n  DictionarySelector,\n} from '@intlayer/types/dictionary';\nimport {\n  COMPOSITE_ID_SEPARATOR,\n  resolveEffectiveVariantId,\n  serializeVariantChain,\n} from './qualifiedDictionary';\n\n/**\n * Marker property carrying the ordered qualifier dimensions on a dynamic loader\n * map. Its presence distinguishes a qualified group loader map (a nested tree\n * of chunks) from a plain dynamic loader map (one chunk per `locale`). Prefixed\n * and unlikely to collide with a real locale code.\n */\nexport const QUALIFIER_DYNAMIC_TYPES_KEY = '__intlayerQualifierTypes';\n\n/**\n * A lazily-imported per-locale dictionary chunk loader.\n */\nexport type DynamicDictionaryLoader = () => Promise<Dictionary>;\n\n/**\n * Nested tree of chunk loaders: one nesting level per declared dimension (in\n * canonical order), leaves are loaders.\n */\nexport type QualifiedDynamicLoaderTree = {\n  [segment: string]: QualifiedDynamicLoaderTree | DynamicDictionaryLoader;\n};\n\n/**\n * Default export shape of a generated dynamic entry point for a qualified key.\n * One nesting level per dimension under each locale, plus the dimension marker.\n *\n * ```ts\n * {\n *   __intlayerQualifierTypes: ['variant', 'item'],\n *   en: { promo: { '1': () => import('./json/x/promo/1/en.json'), … }, … },\n *   fr: { … },\n * }\n * ```\n */\nexport type QualifiedDynamicLoaderMap = {\n  [QUALIFIER_DYNAMIC_TYPES_KEY]: DictionaryQualifierType[];\n  [locale: string]: QualifiedDynamicLoaderTree | DictionaryQualifierType[];\n};\n\n/**\n * Type guard discriminating a qualified dynamic loader map (collections /\n * variants, possibly combined) from a plain dynamic loader map.\n */\nexport const isQualifiedDynamicLoaderMap = (\n  value: unknown\n): value is QualifiedDynamicLoaderMap =>\n  typeof value === 'object' &&\n  value !== null &&\n  QUALIFIER_DYNAMIC_TYPES_KEY in value;\n\n/** One targeted chunk: its stable cache key and lazy loader. */\ntype CollectedChunk = {\n  cacheKey: string;\n  loader: DynamicDictionaryLoader;\n};\n\ntype CollectedChunks = {\n  /** True when the `item` axis is open (collection result → array). */\n  itemAxisOpen: boolean;\n  /** True when a required coordinate is absent (result → [] or null). */\n  missed: boolean;\n  /** The chunks the selector targets (in collection order for the item axis). */\n  chunks: CollectedChunk[];\n};\n\n/**\n * Walks the loader tree following the selector and collects the chunk loaders\n * it targets — shared by the sync ({@link resolveQualifiedDynamicContent}) and\n * async ({@link resolveQualifiedDynamicContentAsync}) resolvers.\n */\nconst collectQualifiedChunks = (\n  loaderMap: QualifiedDynamicLoaderMap,\n  key: string,\n  locale: string,\n  selector: DictionarySelector | undefined\n): CollectedChunks => {\n  const qualifierTypes = loaderMap[QUALIFIER_DYNAMIC_TYPES_KEY];\n  const localeTree = loaderMap[locale] as\n    | QualifiedDynamicLoaderTree\n    | undefined;\n\n  const itemAxisOpen =\n    qualifierTypes.includes('item') && selector?.item === undefined;\n\n  if (!localeTree) return { itemAxisOpen, missed: true, chunks: [] };\n\n  const chunks: CollectedChunk[] = [];\n\n  const walk = (\n    node: QualifiedDynamicLoaderTree | DynamicDictionaryLoader,\n    dimensions: DictionaryQualifierType[],\n    segments: string[]\n  ): boolean => {\n    if (dimensions.length === 0) {\n      chunks.push({\n        cacheKey: `${key}.${locale}.${segments.join(COMPOSITE_ID_SEPARATOR)}`,\n        loader: node as DynamicDictionaryLoader,\n      });\n      return true;\n    }\n\n    const [dimension, ...rest] = dimensions;\n    const tree = node as QualifiedDynamicLoaderTree;\n\n    if (dimension === 'item' && selector?.item === undefined) {\n      // Open collection axis: fan out into every sibling chunk, ordered.\n      for (const segment of Object.keys(tree).sort(\n        (left, right) => Number(left) - Number(right)\n      )) {\n        walk(tree[segment]!, rest, [...segments, segment]);\n      }\n      return true;\n    }\n\n    // A variant with no chunk of its own falls back to the `default` chunk, so\n    // only the entries that actually differ need to be emitted.\n    const segment =\n      dimension === 'variant'\n        ? resolveEffectiveVariantId(\n            serializeVariantChain(selector?.variant),\n            (variantId) => tree[variantId] !== undefined\n          )\n        : String(selector?.item);\n\n    const child = tree[segment];\n    if (!child) return false;\n\n    return walk(child, rest, [...segments, segment]);\n  };\n\n  const found = walk(localeTree, qualifierTypes, []);\n\n  return { itemAxisOpen, missed: !found, chunks };\n};\n\n/**\n * Resolves the content of a qualified dynamic loader map against a selector,\n * loading only the chunk(s) the selector actually targets.\n *\n * Walks the nested loader tree one dimension at a time (canonical order\n * `variant → item`): `variant` descends by the serialized id, falling back to\n * `default` when the selected variant has no chunk of its own, and `item`\n * either narrows to the selected index or — when no item is given — expands\n * into every sibling chunk (the collection axis). Semantics mirror\n * `resolveQualifiedDictionary` so dynamic and static modes behave alike.\n *\n * The Suspense mechanism is injected through `loadChunk` so the same logic\n * serves both the client (suspender cache) and the server (`react.use`). Every\n * targeted loader is started before the first chunk is read, so sibling chunks\n * load in parallel rather than waterfalling.\n *\n * @param loaderMap - The qualified dynamic loader map (entry point default export).\n * @param key - The dictionary key (used to build stable chunk cache keys).\n * @param locale - The resolved locale to load chunks for.\n * @param selector - The selector splitting the qualifier dimensions.\n * @param loadChunk - Reads a started chunk promise, suspending until it resolves.\n * @param transform - Turns a resolved chunk dictionary into final content.\n */\nexport const resolveQualifiedDynamicContent = <Content>(params: {\n  loaderMap: QualifiedDynamicLoaderMap;\n  key: string;\n  locale: string;\n  selector: DictionarySelector | undefined;\n  loadChunk: (cacheKey: string, promise: Promise<Dictionary>) => Dictionary;\n  transform: (dictionary: Dictionary) => Content;\n}): Content | Content[] | null => {\n  const { loaderMap, key, locale, selector, loadChunk, transform } = params;\n\n  const { itemAxisOpen, missed, chunks } = collectQualifiedChunks(\n    loaderMap,\n    key,\n    locale,\n    selector\n  );\n\n  if (missed) return itemAxisOpen ? [] : null;\n\n  // Start every loader before reading, so siblings load in parallel.\n  const dictionaries = chunks.map(({ cacheKey, loader }) =>\n    loadChunk(cacheKey, loader())\n  );\n\n  if (itemAxisOpen) return dictionaries.map(transform);\n\n  const [dictionary] = dictionaries;\n  return dictionary ? transform(dictionary) : null;\n};\n\n/**\n * Async counterpart of {@link resolveQualifiedDynamicContent} for frameworks\n * that load dictionaries with `await` instead of Suspense (Vue, Svelte, Lit,\n * vanilla). Awaits every targeted chunk in parallel, then resolves identically.\n *\n * @param loaderMap - The qualified dynamic loader map.\n * @param key - The dictionary key (used to build stable chunk cache keys).\n * @param locale - The resolved locale to load chunks for.\n * @param selector - The selector splitting the qualifier dimensions.\n * @param transform - Turns a resolved chunk dictionary into final content.\n */\nexport const resolveQualifiedDynamicContentAsync = async <Content>(params: {\n  loaderMap: QualifiedDynamicLoaderMap;\n  key: string;\n  locale: string;\n  selector: DictionarySelector | undefined;\n  transform: (dictionary: Dictionary) => Content;\n}): Promise<Content | Content[] | null> => {\n  const { loaderMap, key, locale, selector, transform } = params;\n\n  const { itemAxisOpen, missed, chunks } = collectQualifiedChunks(\n    loaderMap,\n    key,\n    locale,\n    selector\n  );\n\n  if (missed) return itemAxisOpen ? [] : null;\n\n  const dictionaries = await Promise.all(chunks.map(({ loader }) => loader()));\n\n  if (itemAxisOpen) return dictionaries.map(transform);\n\n  const [dictionary] = dictionaries;\n  return dictionary ? transform(dictionary) : null;\n};\n"],"mappings":";;;;;;;;;AAiBA,MAAa,8BAA8B;;;;;AAoC3C,MAAa,+BACX,UAEA,OAAO,UAAU,YACjB,UAAU,sCACqB;;;;;;AAsBjC,MAAM,0BACJ,WACA,KACA,QACA,aACoB;CACpB,MAAM,iBAAiB,UAAU;CACjC,MAAM,aAAa,UAAU;CAI7B,MAAM,eACJ,eAAe,SAAS,MAAM,KAAK,UAAU,SAAS;CAExD,IAAI,CAAC,YAAY,OAAO;EAAE;EAAc,QAAQ;EAAM,QAAQ,CAAC;CAAE;CAEjE,MAAM,SAA2B,CAAC;CAElC,MAAM,QACJ,MACA,YACA,aACY;EACZ,IAAI,WAAW,WAAW,GAAG;GAC3B,OAAO,KAAK;IACV,UAAU,GAAG,IAAI,GAAG,OAAO,GAAG,SAAS,QAA2B;IAClE,QAAQ;GACV,CAAC;GACD,OAAO;EACT;EAEA,MAAM,CAAC,WAAW,GAAG,QAAQ;EAC7B,MAAM,OAAO;EAEb,IAAI,cAAc,UAAU,UAAU,SAAS,QAAW;GAExD,KAAK,MAAM,WAAW,OAAO,KAAK,IAAI,CAAC,CAAC,MACrC,MAAM,UAAU,OAAO,IAAI,IAAI,OAAO,KAAK,CAC9C,GACE,KAAK,KAAK,UAAW,MAAM,CAAC,GAAG,UAAU,OAAO,CAAC;GAEnD,OAAO;EACT;EAIA,MAAM,UACJ,cAAc,YACV,0BACE,sBAAsB,UAAU,OAAO,IACtC,cAAc,KAAK,eAAe,MACrC,IACA,OAAO,UAAU,IAAI;EAE3B,MAAM,QAAQ,KAAK;EACnB,IAAI,CAAC,OAAO,OAAO;EAEnB,OAAO,KAAK,OAAO,MAAM,CAAC,GAAG,UAAU,OAAO,CAAC;CACjD;CAIA,OAAO;EAAE;EAAc,QAAQ,CAFjB,KAAK,YAAY,gBAAgB,CAAC,CAEZ;EAAG;CAAO;AAChD;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAa,kCAA2C,WAOtB;CAChC,MAAM,EAAE,WAAW,KAAK,QAAQ,UAAU,WAAW,cAAc;CAEnE,MAAM,EAAE,cAAc,QAAQ,WAAW,uBACvC,WACA,KACA,QACA,QACF;CAEA,IAAI,QAAQ,OAAO,eAAe,CAAC,IAAI;CAGvC,MAAM,eAAe,OAAO,KAAK,EAAE,UAAU,aAC3C,UAAU,UAAU,OAAO,CAAC,CAC9B;CAEA,IAAI,cAAc,OAAO,aAAa,IAAI,SAAS;CAEnD,MAAM,CAAC,cAAc;CACrB,OAAO,aAAa,UAAU,UAAU,IAAI;AAC9C;;;;;;;;;;;;AAaA,MAAa,sCAAsC,OAAgB,WAMxB;CACzC,MAAM,EAAE,WAAW,KAAK,QAAQ,UAAU,cAAc;CAExD,MAAM,EAAE,cAAc,QAAQ,WAAW,uBACvC,WACA,KACA,QACA,QACF;CAEA,IAAI,QAAQ,OAAO,eAAe,CAAC,IAAI;CAEvC,MAAM,eAAe,MAAM,QAAQ,IAAI,OAAO,KAAK,EAAE,aAAa,OAAO,CAAC,CAAC;CAE3E,IAAI,cAAc,OAAO,aAAa,IAAI,SAAS;CAEnD,MAAM,CAAC,cAAc;CACrB,OAAO,aAAa,UAAU,UAAU,IAAI;AAC9C"}
+{"version":3,"file":"qualifiedDynamicLoader.mjs","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDynamicLoader.ts"],"sourcesContent":["import { QUALIFIER_DYNAMIC_TYPES_KEY } from '@intlayer/config/defaultValues';\nimport type {\n  Dictionary,\n  DictionaryQualifierType,\n  DictionarySelector,\n} from '@intlayer/types/dictionary';\nimport {\n  COMPOSITE_ID_SEPARATOR,\n  resolveEffectiveVariantId,\n  serializeVariantChain,\n} from './qualifiedDictionary';\n\n/**\n * Marker property carrying the ordered qualifier dimensions on a dynamic loader\n * map. Defined in `@intlayer/config` so the code generator and the build\n * plugins can read it without pulling the runtime in, and re-exported here\n * where its consumers live.\n */\nexport { QUALIFIER_DYNAMIC_TYPES_KEY };\n\n/**\n * A lazily-imported per-locale dictionary chunk loader.\n */\nexport type DynamicDictionaryLoader = () => Promise<Dictionary>;\n\n/**\n * Nested tree of chunk loaders: one nesting level per declared dimension (in\n * canonical order), leaves are loaders.\n */\nexport type QualifiedDynamicLoaderTree = {\n  [segment: string]: QualifiedDynamicLoaderTree | DynamicDictionaryLoader;\n};\n\n/**\n * Default export shape of a generated dynamic entry point for a qualified key.\n * One nesting level per dimension under each locale, plus the dimension marker.\n *\n * ```ts\n * {\n *   __intlayerQualifierTypes: ['variant', 'item'],\n *   en: { promo: { '1': () => import('./json/x/promo/1/en.json'), … }, … },\n *   fr: { … },\n * }\n * ```\n */\nexport type QualifiedDynamicLoaderMap = {\n  [QUALIFIER_DYNAMIC_TYPES_KEY]: DictionaryQualifierType[];\n  [locale: string]: QualifiedDynamicLoaderTree | DictionaryQualifierType[];\n};\n\n/**\n * Type guard discriminating a qualified dynamic loader map (collections /\n * variants, possibly combined) from a plain dynamic loader map.\n */\nexport const isQualifiedDynamicLoaderMap = (\n  value: unknown\n): value is QualifiedDynamicLoaderMap =>\n  typeof value === 'object' &&\n  value !== null &&\n  QUALIFIER_DYNAMIC_TYPES_KEY in value;\n\n/** One targeted chunk: its stable cache key and lazy loader. */\ntype CollectedChunk = {\n  cacheKey: string;\n  loader: DynamicDictionaryLoader;\n};\n\ntype CollectedChunks = {\n  /** True when the `item` axis is open (collection result → array). */\n  itemAxisOpen: boolean;\n  /** True when a required coordinate is absent (result → [] or null). */\n  missed: boolean;\n  /** The chunks the selector targets (in collection order for the item axis). */\n  chunks: CollectedChunk[];\n};\n\n/**\n * Walks the loader tree following the selector and collects the chunk loaders\n * it targets — shared by the sync ({@link resolveQualifiedDynamicContent}) and\n * async ({@link resolveQualifiedDynamicContentAsync}) resolvers.\n */\nconst collectQualifiedChunks = (\n  loaderMap: QualifiedDynamicLoaderMap,\n  key: string,\n  locale: string,\n  selector: DictionarySelector | undefined\n): CollectedChunks => {\n  const qualifierTypes = loaderMap[QUALIFIER_DYNAMIC_TYPES_KEY];\n  const localeTree = loaderMap[locale] as\n    | QualifiedDynamicLoaderTree\n    | undefined;\n\n  const itemAxisOpen =\n    qualifierTypes.includes('item') && selector?.item === undefined;\n\n  if (!localeTree) return { itemAxisOpen, missed: true, chunks: [] };\n\n  const chunks: CollectedChunk[] = [];\n\n  const walk = (\n    node: QualifiedDynamicLoaderTree | DynamicDictionaryLoader,\n    dimensions: DictionaryQualifierType[],\n    segments: string[]\n  ): boolean => {\n    if (dimensions.length === 0) {\n      chunks.push({\n        cacheKey: `${key}.${locale}.${segments.join(COMPOSITE_ID_SEPARATOR)}`,\n        loader: node as DynamicDictionaryLoader,\n      });\n      return true;\n    }\n\n    const [dimension, ...rest] = dimensions;\n    const tree = node as QualifiedDynamicLoaderTree;\n\n    if (dimension === 'item' && selector?.item === undefined) {\n      // Open collection axis: fan out into every sibling chunk, ordered.\n      for (const segment of Object.keys(tree).sort(\n        (left, right) => Number(left) - Number(right)\n      )) {\n        walk(tree[segment]!, rest, [...segments, segment]);\n      }\n      return true;\n    }\n\n    // A variant with no chunk of its own falls back to the `default` chunk, so\n    // only the entries that actually differ need to be emitted.\n    const segment =\n      dimension === 'variant'\n        ? resolveEffectiveVariantId(\n            serializeVariantChain(selector?.variant),\n            (variantId) => tree[variantId] !== undefined\n          )\n        : String(selector?.item);\n\n    const child = tree[segment];\n    if (!child) return false;\n\n    return walk(child, rest, [...segments, segment]);\n  };\n\n  const found = walk(localeTree, qualifierTypes, []);\n\n  return { itemAxisOpen, missed: !found, chunks };\n};\n\n/**\n * Resolves the content of a qualified dynamic loader map against a selector,\n * loading only the chunk(s) the selector actually targets.\n *\n * Walks the nested loader tree one dimension at a time (canonical order\n * `variant → item`): `variant` descends by the serialized id, falling back to\n * `default` when the selected variant has no chunk of its own, and `item`\n * either narrows to the selected index or — when no item is given — expands\n * into every sibling chunk (the collection axis). Semantics mirror\n * `resolveQualifiedDictionary` so dynamic and static modes behave alike.\n *\n * The Suspense mechanism is injected through `loadChunk` so the same logic\n * serves both the client (suspender cache) and the server (`react.use`). Every\n * targeted loader is started before the first chunk is read, so sibling chunks\n * load in parallel rather than waterfalling.\n *\n * @param loaderMap - The qualified dynamic loader map (entry point default export).\n * @param key - The dictionary key (used to build stable chunk cache keys).\n * @param locale - The resolved locale to load chunks for.\n * @param selector - The selector splitting the qualifier dimensions.\n * @param loadChunk - Reads a started chunk promise, suspending until it resolves.\n * @param transform - Turns a resolved chunk dictionary into final content.\n */\nexport const resolveQualifiedDynamicContent = <Content>(params: {\n  loaderMap: QualifiedDynamicLoaderMap;\n  key: string;\n  locale: string;\n  selector: DictionarySelector | undefined;\n  loadChunk: (cacheKey: string, promise: Promise<Dictionary>) => Dictionary;\n  transform: (dictionary: Dictionary) => Content;\n}): Content | Content[] | null => {\n  const { loaderMap, key, locale, selector, loadChunk, transform } = params;\n\n  const { itemAxisOpen, missed, chunks } = collectQualifiedChunks(\n    loaderMap,\n    key,\n    locale,\n    selector\n  );\n\n  if (missed) return itemAxisOpen ? [] : null;\n\n  // Start every loader before reading, so siblings load in parallel.\n  const dictionaries = chunks.map(({ cacheKey, loader }) =>\n    loadChunk(cacheKey, loader())\n  );\n\n  if (itemAxisOpen) return dictionaries.map(transform);\n\n  const [dictionary] = dictionaries;\n  return dictionary ? transform(dictionary) : null;\n};\n\n/**\n * Async counterpart of {@link resolveQualifiedDynamicContent} for frameworks\n * that load dictionaries with `await` instead of Suspense (Vue, Svelte, Lit,\n * vanilla). Awaits every targeted chunk in parallel, then resolves identically.\n *\n * @param loaderMap - The qualified dynamic loader map.\n * @param key - The dictionary key (used to build stable chunk cache keys).\n * @param locale - The resolved locale to load chunks for.\n * @param selector - The selector splitting the qualifier dimensions.\n * @param transform - Turns a resolved chunk dictionary into final content.\n */\nexport const resolveQualifiedDynamicContentAsync = async <Content>(params: {\n  loaderMap: QualifiedDynamicLoaderMap;\n  key: string;\n  locale: string;\n  selector: DictionarySelector | undefined;\n  transform: (dictionary: Dictionary) => Content;\n}): Promise<Content | Content[] | null> => {\n  const { loaderMap, key, locale, selector, transform } = params;\n\n  const { itemAxisOpen, missed, chunks } = collectQualifiedChunks(\n    loaderMap,\n    key,\n    locale,\n    selector\n  );\n\n  if (missed) return itemAxisOpen ? [] : null;\n\n  const dictionaries = await Promise.all(chunks.map(({ loader }) => loader()));\n\n  if (itemAxisOpen) return dictionaries.map(transform);\n\n  const [dictionary] = dictionaries;\n  return dictionary ? transform(dictionary) : null;\n};\n"],"mappings":";;;;;;;;AAsDA,MAAa,+BACX,UAEA,OAAO,UAAU,YACjB,UAAU,QACV,+BAA+B;;;;;;AAsBjC,MAAM,0BACJ,WACA,KACA,QACA,aACoB;CACpB,MAAM,iBAAiB,UAAU;CACjC,MAAM,aAAa,UAAU;CAI7B,MAAM,eACJ,eAAe,SAAS,MAAM,KAAK,UAAU,SAAS;CAExD,IAAI,CAAC,YAAY,OAAO;EAAE;EAAc,QAAQ;EAAM,QAAQ,CAAC;CAAE;CAEjE,MAAM,SAA2B,CAAC;CAElC,MAAM,QACJ,MACA,YACA,aACY;EACZ,IAAI,WAAW,WAAW,GAAG;GAC3B,OAAO,KAAK;IACV,UAAU,GAAG,IAAI,GAAG,OAAO,GAAG,SAAS,QAA2B;IAClE,QAAQ;GACV,CAAC;GACD,OAAO;EACT;EAEA,MAAM,CAAC,WAAW,GAAG,QAAQ;EAC7B,MAAM,OAAO;EAEb,IAAI,cAAc,UAAU,UAAU,SAAS,QAAW;GAExD,KAAK,MAAM,WAAW,OAAO,KAAK,IAAI,CAAC,CAAC,MACrC,MAAM,UAAU,OAAO,IAAI,IAAI,OAAO,KAAK,CAC9C,GACE,KAAK,KAAK,UAAW,MAAM,CAAC,GAAG,UAAU,OAAO,CAAC;GAEnD,OAAO;EACT;EAIA,MAAM,UACJ,cAAc,YACV,0BACE,sBAAsB,UAAU,OAAO,IACtC,cAAc,KAAK,eAAe,MACrC,IACA,OAAO,UAAU,IAAI;EAE3B,MAAM,QAAQ,KAAK;EACnB,IAAI,CAAC,OAAO,OAAO;EAEnB,OAAO,KAAK,OAAO,MAAM,CAAC,GAAG,UAAU,OAAO,CAAC;CACjD;CAIA,OAAO;EAAE;EAAc,QAAQ,CAFjB,KAAK,YAAY,gBAAgB,CAAC,CAEZ;EAAG;CAAO;AAChD;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,MAAa,kCAA2C,WAOtB;CAChC,MAAM,EAAE,WAAW,KAAK,QAAQ,UAAU,WAAW,cAAc;CAEnE,MAAM,EAAE,cAAc,QAAQ,WAAW,uBACvC,WACA,KACA,QACA,QACF;CAEA,IAAI,QAAQ,OAAO,eAAe,CAAC,IAAI;CAGvC,MAAM,eAAe,OAAO,KAAK,EAAE,UAAU,aAC3C,UAAU,UAAU,OAAO,CAAC,CAC9B;CAEA,IAAI,cAAc,OAAO,aAAa,IAAI,SAAS;CAEnD,MAAM,CAAC,cAAc;CACrB,OAAO,aAAa,UAAU,UAAU,IAAI;AAC9C;;;;;;;;;;;;AAaA,MAAa,sCAAsC,OAAgB,WAMxB;CACzC,MAAM,EAAE,WAAW,KAAK,QAAQ,UAAU,cAAc;CAExD,MAAM,EAAE,cAAc,QAAQ,WAAW,uBACvC,WACA,KACA,QACA,QACF;CAEA,IAAI,QAAQ,OAAO,eAAe,CAAC,IAAI;CAEvC,MAAM,eAAe,MAAM,QAAQ,IAAI,OAAO,KAAK,EAAE,aAAa,OAAO,CAAC,CAAC;CAE3E,IAAI,cAAc,OAAO,aAAa,IAAI,SAAS;CAEnD,MAAM,CAAC,cAAc;CACrB,OAAO,aAAa,UAAU,UAAU,IAAI;AAC9C"}

package/dist/esm/index.mjs

@@ -64,6 +64,7 @@ import { QUALIFIER_ORDER, getDictionaryCompositeIds, getDictionaryQualifierIds,
 import { mergeQualifiedDictionaries } from "./dictionaryManipulator/mergeQualifiedDictionaries.mjs";
 import { orderDictionaries } from "./dictionaryManipulator/orderDictionaries.mjs";
 import { normalizeDictionaries, normalizeDictionary } from "./dictionaryManipulator/normalizeDictionary.mjs";
+import { PRELOADED_DYNAMIC_KEY, getPreloadedDictionary } from "./dictionaryManipulator/preloadedDynamicLoader.mjs";
 import { QUALIFIER_DYNAMIC_TYPES_KEY, isQualifiedDynamicLoaderMap, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync } from "./dictionaryManipulator/qualifiedDynamicLoader.mjs";
 import { removeContentNodeByKeyPath } from "./dictionaryManipulator/removeContentNodeByKeyPath.mjs";
 import { renameContentNodeByKeyPath } from "./dictionaryManipulator/renameContentNodeByKeyPath.mjs";
@@ -72,8 +73,9 @@ import { checkIsURLAbsolute } from "./utils/checkIsURLAbsolute.mjs";
 import { getPathWithoutLocale } from "./localization/getPathWithoutLocale.mjs";
 import { comparePaths, normalizePath } from "./localization/comparePaths.mjs";
 import { getDomainHostname, getDomainOrigin, getLocaleFromDomain, isLocaleExclusiveOnDomain } from "./localization/domainUtils.mjs";
-import { getPrefix } from "./localization/getPrefix.mjs";
-import { getCanonicalPath, getInternalPath, getLocalizedPath, getRewritePath, getRewriteRules } from "./localization/rewriteUtils.mjs";
+import { getPrefix, isDeclaredLocale } from "./localization/getPrefix.mjs";
+import { getCanonicalPath, getInternalPath, getRewritePath, getRewriteRules, resolveLocalizedPath } from "./localization/rewriteUtils.mjs";
+import { getLocalizedPath } from "./localization/getLocalizedPath.mjs";
 import { getLocalizedUrl } from "./localization/getLocalizedUrl.mjs";
 import { getMultilingualUrls } from "./localization/getMultilingualUrls.mjs";
 import { generateSitemap, generateSitemapUrl } from "./localization/generateSitemap.mjs";
@@ -89,8 +91,9 @@ import { getLocaleLang } from "./localization/getLocaleLang.mjs";
 import { getLocaleName } from "./localization/getLocaleName.mjs";
 import { localeFlatMap, localeMap, localeRecord } from "./localization/localeMapper.mjs";
 import { formatProxyEnabledMessage, isProxyStorageLocaleEnabled, resolveProxyMode } from "./localization/proxyMode.mjs";
+import { getPreloadLocale, resolveBrowserLocale } from "./localization/resolveBrowserLocale.mjs";
 import { validatePrefix } from "./localization/validatePrefix.mjs";
-import { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_R, DO_NOT_PROCESS_HTML_ELEMENTS, DURATION_DELAY_TRIGGER, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, GFM_TASK_R, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, HTML_BLOCK_ELEMENT_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, INLINE_SKIP_R, INTERPOLATION_R, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, LOOKAHEAD, NAMED_CODES_TO_UNICODE, NP_TABLE_R, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, PARAGRAPH_R, Priority, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleType, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex } from "./markdown/constants.mjs";
+import { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_R, DO_NOT_PROCESS_HTML_ELEMENTS, DURATION_DELAY_TRIGGER, FENCE_DELIMITER_R, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, GFM_TASK_R, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, HTML_BLOCK_ELEMENT_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, INLINE_SKIP_R, INTERPOLATION_R, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, LOOKAHEAD, NAMED_CODES_TO_UNICODE, NP_TABLE_R, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, PARAGRAPH_R, Priority, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleType, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex } from "./markdown/constants.mjs";
 import { allowInline, anyScopeRegex, attributeValueToNodePropValue, blockRegex, captureNothing, cx, get, inlineRegex, normalizeAttributeKey, normalizeWhitespace, parseBlock, parseCaptureInline, parseInline, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, qualifies, renderNothing, sanitizer, simpleInlineRegex, slugify, some, startsWith, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, unquote } from "./markdown/utils.mjs";
 import { parserFor } from "./markdown/parser.mjs";
 import { createRenderer, renderFor } from "./markdown/renderer.mjs";
@@ -104,4 +107,4 @@ import { interpolateMessage, parseTaggedMessage, resolveMessage, resolveMessageN
 import { isSameKeyPath } from "./utils/isSameKeyPath.mjs";
 import { stringifyYaml } from "./utils/stringifyYaml.mjs";
 
-export { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, COMPOSITE_ID_SEPARATOR, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_R, CachedIntl, CachedIntl as Intl, DEFAULT_VARIANT_ID, DO_NOT_PROCESS_HTML_ELEMENTS, DURATION_DELAY_TRIGGER, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, GFM_TASK_R, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, HTML_BLOCK_ELEMENT_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, HTML_TAGS, INLINE_SKIP_R, INTERPOLATION_R, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, LOOKAHEAD, LocaleStorage, LocaleStorageClient, LocaleStorageServer, NAMED_CODES_TO_UNICODE, NP_TABLE_R, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, PARAGRAPH_R, Priority, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleType, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, VOID_HTML_ELEMENTS, allowInline, anyScopeRegex, attributeValueToNodePropValue, bindIntl, blockRegex, buildMaskPlugin, captureNothing, checkIsURLAbsolute, checkMissingLocalesPlugin, compact, comparePaths, compile, compileWithOptions, condition as cond, conditionPlugin, createCompiler, createRenderer, currency, cx, date, deepTransformNode, editDictionaryByKeyPath, enumeration as enu, enumerationPlugin, fallbackPlugin, filePlugin, filterMissingTranslationsOnlyPlugin, filterTranslationsOnlyPlugin, findMatchingCondition, formatProxyEnabledMessage, gender, genderPlugin, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex, generateSitemap, generateSitemapUrl, get, getBasePlugins, getBrowserLocale, getCachedIntl, getCanonicalPath, getCondition, getContent, getContentNodeByKeyPath, getCookie, getDefaultNode, getDictionary, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getDomainHostname, getDomainOrigin, getEditedContent, getEditedDictionary, getEmptyNode, getEnumeration, getFilterMissingTranslationsContent, getFilterMissingTranslationsDictionary, getFilterTranslationsOnlyContent, getFilterTranslationsOnlyDictionary, getFilteredLocalesContent, getFilteredLocalesDictionary, getGender, getHTML, getHTMLTextDir, getInsertion, getInsertionValues, getInternalPath, getInterpolableContent, getIntlayer, getLocale, getLocaleFromDomain, getLocaleFromPath, getLocaleFromStorage, getLocaleFromStorageClient, getLocaleFromStorageServer, getLocaleLang, getLocaleName, getLocalizedContent, getLocalizedPath, getLocalizedUrl, getMarkdownMetadata, getMaskContent, getMissingLocalesContent, getMissingLocalesContentFromDictionary, getMultilingualDictionary, getMultilingualUrls, getNestedDictionaryGraph, getNestedDictionaryKeys, getNestedDictionaryReferences, getNesting, getNodeChildren, getNodeType, getPathWithoutLocale, getPerLocaleDictionary, getPlural, getPrefix, getReplacedValuesContent, getRewritePath, getRewriteRules, getSelect, getSplittedContent, getSplittedDictionaryContent, getTranslation, getVariantIds, html, i18nextToIntlayerFormatter, icuToIntlayerFormatter, inlineRegex, insertion as insert, insertContentInDictionary, insertionPlugin, interpolateMessage, intlayerToI18nextFormatter, intlayerToICUFormatter, intlayerToPortableObjectFormatter, intlayerToVueI18nFormatter, isInterpolableWrapperNode, isLocaleExclusiveOnDomain, isProxyStorageLocaleEnabled, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, isSameKeyPath, isValidElement, list, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, localeStorageOptions, markdown as md, mergeDictionaries, mergeQualifiedDictionaries, navigatePath, nesting as nest, nestedPlugin, normalizeAttributeKey, normalizeDictionaries, normalizeDictionary, normalizePath, normalizeWhitespace, number, orderDictionaries, parseBlock, parseCaptureInline, parseDictionarySelector, parseInline, parseMarkdown, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, parseTaggedMessage, parseYaml, parserFor, percentage, plural, pluralPlugin, portableObjectToIntlayerFormatter, presets, qualifies, rebuildInterpolableContent, reconstructQualifiedEntry, relativeTime, removeContentNodeByKeyPath, renameContentNodeByKeyPath, renderFor, renderMarkdownAst, renderNothing, resolveDictionaryArgument, resolveEffectiveVariantId, resolveMessage, resolveMessageNode, resolveProviderVariant, resolveProxyMode, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, sanitizer, select, selectPlugin, serializeVariant, serializeVariantChain, setLocaleInStorage, setLocaleInStorageClient, setLocaleInStorageServer, simpleInlineRegex, slugify, some, splitInsertionTemplate, startsWith, stringifyYaml, translation as t, transformInterpolableNode, translationPlugin, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, units, unquote, updateNodeChildren, validateHTML, validateMarkdown, validatePrefix, vueI18nToIntlayerFormatter };
+export { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, COMPOSITE_ID_SEPARATOR, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_R, CachedIntl, CachedIntl as Intl, DEFAULT_VARIANT_ID, DO_NOT_PROCESS_HTML_ELEMENTS, DURATION_DELAY_TRIGGER, FENCE_DELIMITER_R, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, GFM_TASK_R, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, HTML_BLOCK_ELEMENT_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, HTML_TAGS, INLINE_SKIP_R, INTERPOLATION_R, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, LOOKAHEAD, LocaleStorage, LocaleStorageClient, LocaleStorageServer, NAMED_CODES_TO_UNICODE, NP_TABLE_R, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, PARAGRAPH_R, PRELOADED_DYNAMIC_KEY, Priority, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleType, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, VOID_HTML_ELEMENTS, allowInline, anyScopeRegex, attributeValueToNodePropValue, bindIntl, blockRegex, buildMaskPlugin, captureNothing, checkIsURLAbsolute, checkMissingLocalesPlugin, compact, comparePaths, compile, compileWithOptions, condition as cond, conditionPlugin, createCompiler, createRenderer, currency, cx, date, deepTransformNode, editDictionaryByKeyPath, enumeration as enu, enumerationPlugin, fallbackPlugin, filePlugin, filterMissingTranslationsOnlyPlugin, filterTranslationsOnlyPlugin, findMatchingCondition, formatProxyEnabledMessage, gender, genderPlugin, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex, generateSitemap, generateSitemapUrl, get, getBasePlugins, getBrowserLocale, getCachedIntl, getCanonicalPath, getCondition, getContent, getContentNodeByKeyPath, getCookie, getDefaultNode, getDictionary, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getDomainHostname, getDomainOrigin, getEditedContent, getEditedDictionary, getEmptyNode, getEnumeration, getFilterMissingTranslationsContent, getFilterMissingTranslationsDictionary, getFilterTranslationsOnlyContent, getFilterTranslationsOnlyDictionary, getFilteredLocalesContent, getFilteredLocalesDictionary, getGender, getHTML, getHTMLTextDir, getInsertion, getInsertionValues, getInternalPath, getInterpolableContent, getIntlayer, getLocale, getLocaleFromDomain, getLocaleFromPath, getLocaleFromStorage, getLocaleFromStorageClient, getLocaleFromStorageServer, getLocaleLang, getLocaleName, getLocalizedContent, getLocalizedPath, getLocalizedUrl, getMarkdownMetadata, getMaskContent, getMissingLocalesContent, getMissingLocalesContentFromDictionary, getMultilingualDictionary, getMultilingualUrls, getNestedDictionaryGraph, getNestedDictionaryKeys, getNestedDictionaryReferences, getNesting, getNodeChildren, getNodeType, getPathWithoutLocale, getPerLocaleDictionary, getPlural, getPrefix, getPreloadLocale, getPreloadedDictionary, getReplacedValuesContent, getRewritePath, getRewriteRules, getSelect, getSplittedContent, getSplittedDictionaryContent, getTranslation, getVariantIds, html, i18nextToIntlayerFormatter, icuToIntlayerFormatter, inlineRegex, insertion as insert, insertContentInDictionary, insertionPlugin, interpolateMessage, intlayerToI18nextFormatter, intlayerToICUFormatter, intlayerToPortableObjectFormatter, intlayerToVueI18nFormatter, isDeclaredLocale, isInterpolableWrapperNode, isLocaleExclusiveOnDomain, isProxyStorageLocaleEnabled, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, isSameKeyPath, isValidElement, list, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, localeStorageOptions, markdown as md, mergeDictionaries, mergeQualifiedDictionaries, navigatePath, nesting as nest, nestedPlugin, normalizeAttributeKey, normalizeDictionaries, normalizeDictionary, normalizePath, normalizeWhitespace, number, orderDictionaries, parseBlock, parseCaptureInline, parseDictionarySelector, parseInline, parseMarkdown, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, parseTaggedMessage, parseYaml, parserFor, percentage, plural, pluralPlugin, portableObjectToIntlayerFormatter, presets, qualifies, rebuildInterpolableContent, reconstructQualifiedEntry, relativeTime, removeContentNodeByKeyPath, renameContentNodeByKeyPath, renderFor, renderMarkdownAst, renderNothing, resolveBrowserLocale, resolveDictionaryArgument, resolveEffectiveVariantId, resolveLocalizedPath, resolveMessage, resolveMessageNode, resolveProviderVariant, resolveProxyMode, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, sanitizer, select, selectPlugin, serializeVariant, serializeVariantChain, setLocaleInStorage, setLocaleInStorageClient, setLocaleInStorageServer, simpleInlineRegex, slugify, some, splitInsertionTemplate, startsWith, stringifyYaml, translation as t, transformInterpolableNode, translationPlugin, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, units, unquote, updateNodeChildren, validateHTML, validateMarkdown, validatePrefix, vueI18nToIntlayerFormatter };

package/dist/esm/localization/comparePaths.mjs

@@ -34,7 +34,7 @@ import { getPathWithoutLocale } from "./getPathWithoutLocale.mjs";
 */
 const normalizePath = (inputUrl, locales) => {
 	const withoutLocale = getPathWithoutLocale(inputUrl || "/", locales);
-	const { pathname } = checkIsURLAbsolute(withoutLocale) ? new URL(withoutLocale) : new URL(withoutLocale, "http://example.com");
+	const { pathname } = checkIsURLAbsolute(withoutLocale) ? new URL(withoutLocale) : new URL(withoutLocale, "http://e.com");
 	if (pathname.length > 1 && pathname.endsWith("/")) return pathname.slice(0, -1);
 	return pathname || "/";
 };

package/dist/esm/localization/comparePaths.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"comparePaths.mjs","names":[],"sources":["../../../src/localization/comparePaths.ts"],"sourcesContent":["import type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { checkIsURLAbsolute } from '../utils/checkIsURLAbsolute';\nimport { getPathWithoutLocale } from './getPathWithoutLocale';\n\n/**\n * Normalizes a URL or pathname into a canonical, locale-agnostic pathname so\n * that two paths pointing to the same page compare equal — useful for\n * highlighting the active navigation link.\n *\n * The normalization:\n * - strips the locale segment (reusing {@link getPathWithoutLocale})\n * - strips the protocol/host so absolute and relative inputs compare equally\n * - drops the query string and hash\n * - ensures a single leading slash\n * - removes any trailing slash (except for the root path)\n * - falls back to `'/'` for empty values\n *\n * Example:\n *\n * ```ts\n * normalizePath('/ru/path')                    // '/path'\n * normalizePath('/ru/path/')                   // '/path'\n * normalizePath('ru/path')                     // '/path'\n * normalizePath('/ru/')                        // '/'\n * normalizePath('/ru')                         // '/'\n * normalizePath('')                            // '/'\n * normalizePath('https://example.com/ru/path') // '/path'\n * ```\n *\n * @param inputUrl - The URL string or pathname to normalize.\n * @param locales - Optional array of supported locales. Defaults to the\n *   configured locales.\n * @returns The normalized, locale-agnostic pathname.\n */\nexport const normalizePath = <const L extends LocalesValues = DeclaredLocales>(\n  inputUrl: string,\n  locales?: L[]\n): string => {\n  const withoutLocale = getPathWithoutLocale(inputUrl || '/', locales);\n\n  // Reuse the URL API to isolate the pathname from any host/query/hash.\n  const url = checkIsURLAbsolute(withoutLocale)\n    ? new URL(withoutLocale)\n    : new URL(withoutLocale, 'http://example.com');\n\n  const { pathname } = url;\n\n  // Remove a trailing slash, keeping the root path intact.\n  if (pathname.length > 1 && pathname.endsWith('/')) {\n    return pathname.slice(0, -1);\n  }\n\n  return pathname || '/';\n};\n\n/**\n * Compares two URLs or pathnames for equality, ignoring locale segment,\n * protocol/host, query string, hash and trailing slashes.\n *\n * Both inputs are normalized through {@link normalizePath} before comparison,\n * making this ideal for matching the current pathname against a navigation\n * link's `href`.\n *\n * Example:\n *\n * ```ts\n * comparePaths('/ru/path', '/path')   // true\n * comparePaths('/ru/path/', '/path')  // true\n * comparePaths('/ru/path', '/path/')  // true\n * comparePaths('/ru/', '/')           // true\n * comparePaths('/ru', '/')            // true\n * comparePaths('ru/path', '/path')    // true\n * comparePaths('', '/')               // true\n * comparePaths('/ru', '')             // true\n * comparePaths('/ru/path', '/other')  // false\n * ```\n *\n * @param pathname - The first URL string or pathname to compare.\n * @param href - The second URL string or pathname to compare.\n * @param locales - Optional array of supported locales. Defaults to the\n *   configured locales.\n * @returns `true` when both inputs resolve to the same locale-agnostic path.\n */\nexport const comparePaths = <const L extends LocalesValues = DeclaredLocales>(\n  pathname: string,\n  href: string,\n  locales?: L[]\n): boolean => normalizePath(pathname, locales) === normalizePath(href, locales);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,MAAa,iBACX,UACA,YACW;CACX,MAAM,gBAAgB,qBAAqB,YAAY,KAAK,OAAO;CAOnE,MAAM,EAAE,aAJI,mBAAmB,aAAa,IACxC,IAAI,IAAI,aAAa,IACrB,IAAI,IAAI,eAAe,oBAAoB;CAK/C,IAAI,SAAS,SAAS,KAAK,SAAS,SAAS,GAAG,GAC9C,OAAO,SAAS,MAAM,GAAG,EAAE;CAG7B,OAAO,YAAY;AACrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,gBACX,UACA,MACA,YACY,cAAc,UAAU,OAAO,MAAM,cAAc,MAAM,OAAO"}
+{"version":3,"file":"comparePaths.mjs","names":[],"sources":["../../../src/localization/comparePaths.ts"],"sourcesContent":["import type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\nimport { checkIsURLAbsolute } from '../utils/checkIsURLAbsolute';\nimport { getPathWithoutLocale } from './getPathWithoutLocale';\n\n/**\n * Normalizes a URL or pathname into a canonical, locale-agnostic pathname so\n * that two paths pointing to the same page compare equal — useful for\n * highlighting the active navigation link.\n *\n * The normalization:\n * - strips the locale segment (reusing {@link getPathWithoutLocale})\n * - strips the protocol/host so absolute and relative inputs compare equally\n * - drops the query string and hash\n * - ensures a single leading slash\n * - removes any trailing slash (except for the root path)\n * - falls back to `'/'` for empty values\n *\n * Example:\n *\n * ```ts\n * normalizePath('/ru/path')                    // '/path'\n * normalizePath('/ru/path/')                   // '/path'\n * normalizePath('ru/path')                     // '/path'\n * normalizePath('/ru/')                        // '/'\n * normalizePath('/ru')                         // '/'\n * normalizePath('')                            // '/'\n * normalizePath('https://example.com/ru/path') // '/path'\n * ```\n *\n * @param inputUrl - The URL string or pathname to normalize.\n * @param locales - Optional array of supported locales. Defaults to the\n *   configured locales.\n * @returns The normalized, locale-agnostic pathname.\n */\nexport const normalizePath = <const L extends LocalesValues = DeclaredLocales>(\n  inputUrl: string,\n  locales?: L[]\n): string => {\n  const withoutLocale = getPathWithoutLocale(inputUrl || '/', locales);\n\n  // Reuse the URL API to isolate the pathname from any host/query/hash.\n  const url = checkIsURLAbsolute(withoutLocale)\n    ? new URL(withoutLocale)\n    : new URL(withoutLocale, 'http://e.com');\n\n  const { pathname } = url;\n\n  // Remove a trailing slash, keeping the root path intact.\n  if (pathname.length > 1 && pathname.endsWith('/')) {\n    return pathname.slice(0, -1);\n  }\n\n  return pathname || '/';\n};\n\n/**\n * Compares two URLs or pathnames for equality, ignoring locale segment,\n * protocol/host, query string, hash and trailing slashes.\n *\n * Both inputs are normalized through {@link normalizePath} before comparison,\n * making this ideal for matching the current pathname against a navigation\n * link's `href`.\n *\n * Example:\n *\n * ```ts\n * comparePaths('/ru/path', '/path')   // true\n * comparePaths('/ru/path/', '/path')  // true\n * comparePaths('/ru/path', '/path/')  // true\n * comparePaths('/ru/', '/')           // true\n * comparePaths('/ru', '/')            // true\n * comparePaths('ru/path', '/path')    // true\n * comparePaths('', '/')               // true\n * comparePaths('/ru', '')             // true\n * comparePaths('/ru/path', '/other')  // false\n * ```\n *\n * @param pathname - The first URL string or pathname to compare.\n * @param href - The second URL string or pathname to compare.\n * @param locales - Optional array of supported locales. Defaults to the\n *   configured locales.\n * @returns `true` when both inputs resolve to the same locale-agnostic path.\n */\nexport const comparePaths = <const L extends LocalesValues = DeclaredLocales>(\n  pathname: string,\n  href: string,\n  locales?: L[]\n): boolean => normalizePath(pathname, locales) === normalizePath(href, locales);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,MAAa,iBACX,UACA,YACW;CACX,MAAM,gBAAgB,qBAAqB,YAAY,KAAK,OAAO;CAOnE,MAAM,EAAE,aAJI,mBAAmB,aAAa,IACxC,IAAI,IAAI,aAAa,IACrB,IAAI,IAAI,eAAe,cAAc;CAKzC,IAAI,SAAS,SAAS,KAAK,SAAS,SAAS,GAAG,GAC9C,OAAO,SAAS,MAAM,GAAG,EAAE;CAG7B,OAAO,YAAY;AACrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAa,gBACX,UACA,MACA,YACY,cAAc,UAAU,OAAO,MAAM,cAAc,MAAM,OAAO"}

package/dist/esm/localization/domainUtils.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"domainUtils.mjs","names":[],"sources":["../../../src/localization/domainUtils.ts"],"sourcesContent":["import type { Locale } from '@intlayer/types/allLocales';\nimport type { RoutingConfig } from '@intlayer/types/config';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\n\n/**\n * The locale → domain map configured under `routing.domains`\n * (e.g. `{ en: 'intlayer.org', zh: 'intlayer.cn' }`).\n */\nexport type LocaleDomainMap = RoutingConfig['domains'];\n\n/**\n * Strips the protocol from a domain string and returns only the hostname.\n *\n * Example:\n *\n * ```ts\n * getDomainHostname('https://intlayer.cn') // 'intlayer.cn'\n * getDomainHostname('intlayer.cn')         // 'intlayer.cn'\n * ```\n *\n * @param domain - A domain value from `routing.domains`, with or without protocol.\n * @returns The bare hostname.\n */\nexport const getDomainHostname = (domain: string): string => {\n  try {\n    return /^https?:\\/\\//.test(domain) ? new URL(domain).hostname : domain;\n  } catch {\n    return domain;\n  }\n};\n\n/**\n * Returns the absolute origin for a domain value, prepending `https://`\n * when no protocol is present.\n *\n * Example:\n *\n * ```ts\n * getDomainOrigin('intlayer.cn')        // 'https://intlayer.cn'\n * getDomainOrigin('http://intlayer.cn') // 'http://intlayer.cn'\n * ```\n *\n * @param domain - A domain value from `routing.domains`, with or without protocol.\n * @returns The origin usable as a URL base.\n */\nexport const getDomainOrigin = (domain: string): string =>\n  /^https?:\\/\\//.test(domain) ? domain : `https://${domain}`;\n\n/**\n * Returns the locale exclusively mapped to a given hostname via `routing.domains`,\n * or `undefined` when zero or more than one locale share that hostname.\n *\n * Example: with `domains = { zh: 'intlayer.cn', en: 'intlayer.org', fr: 'intlayer.org' }`\n *\n * ```ts\n * getLocaleFromDomain('intlayer.cn', domains)  // 'zh'\n * getLocaleFromDomain('intlayer.org', domains) // undefined (en and fr share it)\n * getLocaleFromDomain('example.com', domains)  // undefined (not mapped)\n * ```\n *\n * @param hostname - The bare hostname of the incoming request.\n * @param domains - The configured locale → domain map.\n * @returns The exclusively mapped locale, or `undefined`.\n */\nexport const getLocaleFromDomain = (\n  hostname: string,\n  domains: LocaleDomainMap\n): Locale | undefined => {\n  if (!domains) return undefined;\n\n  const matchingLocales = Object.entries(domains).filter(\n    ([, domain]) =>\n      typeof domain === 'string' && getDomainHostname(domain) === hostname\n  );\n\n  return matchingLocales.length === 1\n    ? (matchingLocales[0]?.[0] as Locale)\n    : undefined;\n};\n\n/**\n * Checks whether a locale is the only locale mapped to its configured domain.\n * When true, the domain alone identifies the locale and no URL prefix is needed.\n * Hostnames are compared after protocol stripping, so\n * `{ en: 'https://intlayer.org', fr: 'intlayer.org' }` counts as a shared domain.\n *\n * @param locale - The locale to check.\n * @param domains - The configured locale → domain map.\n * @returns `true` when the locale has a domain shared with no other locale.\n */\nexport const isLocaleExclusiveOnDomain = (\n  locale: LocalesValues,\n  domains: LocaleDomainMap\n): boolean => {\n  const localeDomain = domains?.[locale];\n\n  if (!localeDomain) return false;\n\n  const localeHostname = getDomainHostname(localeDomain);\n\n  const localesOnSameDomain = Object.values(domains).filter(\n    (domain) =>\n      typeof domain === 'string' && getDomainHostname(domain) === localeHostname\n  ).length;\n\n  return localesOnSameDomain === 1;\n};\n"],"mappings":";;;;;;;;;;;;;;AAuBA,MAAa,qBAAqB,WAA2B;CAC3D,IAAI;EACF,OAAO,eAAe,KAAK,MAAM,IAAI,IAAI,IAAI,MAAM,CAAC,CAAC,WAAW;CAClE,QAAQ;EACN,OAAO;CACT;AACF;;;;;;;;;;;;;;;AAgBA,MAAa,mBAAmB,WAC9B,eAAe,KAAK,MAAM,IAAI,SAAS,WAAW;;;;;;;;;;;;;;;;;AAkBpD,MAAa,uBACX,UACA,YACuB;CACvB,IAAI,CAAC,SAAS,OAAO;CAErB,MAAM,kBAAkB,OAAO,QAAQ,OAAO,CAAC,CAAC,QAC7C,GAAG,YACF,OAAO,WAAW,YAAY,kBAAkB,MAAM,MAAM,QAChE;CAEA,OAAO,gBAAgB,WAAW,IAC7B,gBAAgB,EAAE,GAAG,KACtB;AACN;;;;;;;;;;;AAYA,MAAa,6BACX,QACA,YACY;CACZ,MAAM,eAAe,UAAU;CAE/B,IAAI,CAAC,cAAc,OAAO;CAE1B,MAAM,iBAAiB,kBAAkB,YAAY;CAOrD,OAL4B,OAAO,OAAO,OAAO,CAAC,CAAC,QAChD,WACC,OAAO,WAAW,YAAY,kBAAkB,MAAM,MAAM,cAChE,CAAC,CAAC,WAE6B;AACjC"}
+{"version":3,"file":"domainUtils.mjs","names":[],"sources":["../../../src/localization/domainUtils.ts"],"sourcesContent":["import type { RoutingConfig } from '@intlayer/types/config';\nimport type {\n  DeclaredLocales,\n  LocalesValues,\n} from '@intlayer/types/module_augmentation';\n\n/**\n * The locale → domain map configured under `routing.domains`\n * (e.g. `{ en: 'intlayer.org', zh: 'intlayer.cn' }`).\n */\nexport type LocaleDomainMap = RoutingConfig['domains'];\n\n/**\n * Strips the protocol from a domain string and returns only the hostname.\n *\n * Example:\n *\n * ```ts\n * getDomainHostname('https://intlayer.cn') // 'intlayer.cn'\n * getDomainHostname('intlayer.cn')         // 'intlayer.cn'\n * ```\n *\n * @param domain - A domain value from `routing.domains`, with or without protocol.\n * @returns The bare hostname.\n */\nexport const getDomainHostname = (domain: string): string => {\n  try {\n    return /^https?:\\/\\//.test(domain) ? new URL(domain).hostname : domain;\n  } catch {\n    return domain;\n  }\n};\n\n/**\n * Returns the absolute origin for a domain value, prepending `https://`\n * when no protocol is present.\n *\n * Example:\n *\n * ```ts\n * getDomainOrigin('intlayer.cn')        // 'https://intlayer.cn'\n * getDomainOrigin('http://intlayer.cn') // 'http://intlayer.cn'\n * ```\n *\n * @param domain - A domain value from `routing.domains`, with or without protocol.\n * @returns The origin usable as a URL base.\n */\nexport const getDomainOrigin = (domain: string): string =>\n  /^https?:\\/\\//.test(domain) ? domain : `https://${domain}`;\n\n/**\n * Returns the locale exclusively mapped to a given hostname via `routing.domains`,\n * or `undefined` when zero or more than one locale share that hostname.\n *\n * Example: with `domains = { zh: 'intlayer.cn', en: 'intlayer.org', fr: 'intlayer.org' }`\n *\n * ```ts\n * getLocaleFromDomain('intlayer.cn', domains)  // 'zh'\n * getLocaleFromDomain('intlayer.org', domains) // undefined (en and fr share it)\n * getLocaleFromDomain('example.com', domains)  // undefined (not mapped)\n * ```\n *\n * @param hostname - The bare hostname of the incoming request.\n * @param domains - The configured locale → domain map.\n * @returns The exclusively mapped locale, or `undefined`.\n */\nexport const getLocaleFromDomain = (\n  hostname: string,\n  domains: LocaleDomainMap\n): DeclaredLocales | undefined => {\n  if (!domains) return undefined;\n\n  const matchingLocales = Object.entries(domains).filter(\n    ([, domain]) =>\n      typeof domain === 'string' && getDomainHostname(domain) === hostname\n  );\n\n  return matchingLocales.length === 1\n    ? (matchingLocales[0]?.[0] as DeclaredLocales)\n    : undefined;\n};\n\n/**\n * Checks whether a locale is the only locale mapped to its configured domain.\n * When true, the domain alone identifies the locale and no URL prefix is needed.\n * Hostnames are compared after protocol stripping, so\n * `{ en: 'https://intlayer.org', fr: 'intlayer.org' }` counts as a shared domain.\n *\n * @param locale - The locale to check.\n * @param domains - The configured locale → domain map.\n * @returns `true` when the locale has a domain shared with no other locale.\n */\nexport const isLocaleExclusiveOnDomain = (\n  locale: LocalesValues,\n  domains: LocaleDomainMap\n): boolean => {\n  const localeDomain = domains?.[locale];\n\n  if (!localeDomain) return false;\n\n  const localeHostname = getDomainHostname(localeDomain);\n\n  const localesOnSameDomain = Object.values(domains).filter(\n    (domain) =>\n      typeof domain === 'string' && getDomainHostname(domain) === localeHostname\n  ).length;\n\n  return localesOnSameDomain === 1;\n};\n"],"mappings":";;;;;;;;;;;;;;AAyBA,MAAa,qBAAqB,WAA2B;CAC3D,IAAI;EACF,OAAO,eAAe,KAAK,MAAM,IAAI,IAAI,IAAI,MAAM,CAAC,CAAC,WAAW;CAClE,QAAQ;EACN,OAAO;CACT;AACF;;;;;;;;;;;;;;;AAgBA,MAAa,mBAAmB,WAC9B,eAAe,KAAK,MAAM,IAAI,SAAS,WAAW;;;;;;;;;;;;;;;;;AAkBpD,MAAa,uBACX,UACA,YACgC;CAChC,IAAI,CAAC,SAAS,OAAO;CAErB,MAAM,kBAAkB,OAAO,QAAQ,OAAO,CAAC,CAAC,QAC7C,GAAG,YACF,OAAO,WAAW,YAAY,kBAAkB,MAAM,MAAM,QAChE;CAEA,OAAO,gBAAgB,WAAW,IAC7B,gBAAgB,EAAE,GAAG,KACtB;AACN;;;;;;;;;;;AAYA,MAAa,6BACX,QACA,YACY;CACZ,MAAM,eAAe,UAAU;CAE/B,IAAI,CAAC,cAAc,OAAO;CAE1B,MAAM,iBAAiB,kBAAkB,YAAY;CAOrD,OAL4B,OAAO,OAAO,OAAO,CAAC,CAAC,QAChD,WACC,OAAO,WAAW,YAAY,kBAAkB,MAAM,MAAM,cAChE,CAAC,CAAC,WAE6B;AACjC"}

package/dist/esm/localization/getHTMLTextDir.mjs

@@ -1,4 +1,14 @@
 //#region src/localization/getHTMLTextDir.ts
+const rtlScripts = [
+	"Arab",
+	"Hebr",
+	"Thaa",
+	"Syrc",
+	"Mand",
+	"Adlm",
+	"Rohg",
+	"Nkoo"
+];
 /**
 * Returns the text direction of the given locale.
 *
@@ -19,16 +29,7 @@ const getHTMLTextDir = (locale) => {
 		if ("getTextInfo" in localeInfo) return localeInfo.getTextInfo().direction;
 		if ("textInfo" in localeInfo) return localeInfo.textInfo.direction;
 		const maximized = localeInfo.maximize();
-		return [
-			"Arab",
-			"Hebr",
-			"Thaa",
-			"Syrc",
-			"Mand",
-			"Adlm",
-			"Rohg",
-			"Nkoo"
-		].includes(maximized.script ?? "") ? "rtl" : "ltr";
+		return rtlScripts.includes(maximized.script ?? "") ? "rtl" : "ltr";
 	} catch {
 		return "ltr";
 	}

package/dist/esm/localization/getHTMLTextDir.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getHTMLTextDir.mjs","names":[],"sources":["../../../src/localization/getHTMLTextDir.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/types/module_augmentation';\n\ntype Dir = 'ltr' | 'rtl' | 'auto';\n\n/**\n * Returns the text direction of the given locale.\n *\n * Example:\n *\n * getHTMLTextDir('en-US') // 'ltr'\n * getHTMLTextDir('en') // 'ltr'\n * getHTMLTextDir('fr-CA') // 'ltr'\n * getHTMLTextDir('fr') // 'ltr'\n *\n * @param locale The locale to get the text direction for.\n * @returns The text direction of the given locale.\n */\nexport const getHTMLTextDir = (locale?: LocalesValues): Dir => {\n  if (!locale) return 'ltr';\n\n  try {\n    const localeInfo = new Intl.Locale(locale);\n\n    // Check for the 'textInfo' property (part of the Intl Enumeration API)\n    // Most modern browsers support 'direction' via 'getTextInfo()' or 'textInfo'\n    if ('getTextInfo' in localeInfo) {\n      return (localeInfo as any).getTextInfo().direction as Dir;\n    }\n\n    // Fallback for environments supporting 'textInfo' property\n    if ('textInfo' in localeInfo) {\n      return (localeInfo as any).textInfo.direction as Dir;\n    }\n\n    // Manual fallback for older environments using script detection\n    const maximized = localeInfo.maximize();\n    const rtlScripts = [\n      'Arab',\n      'Hebr',\n      'Thaa',\n      'Syrc',\n      'Mand',\n      'Adlm',\n      'Rohg',\n      'Nkoo',\n    ];\n\n    return rtlScripts.includes(maximized.script ?? '') ? 'rtl' : 'ltr';\n  } catch {\n    return 'ltr';\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;AAiBA,MAAa,kBAAkB,WAAgC;CAC7D,IAAI,CAAC,QAAQ,OAAO;CAEpB,IAAI;EACF,MAAM,aAAa,IAAI,KAAK,OAAO,MAAM;EAIzC,IAAI,iBAAiB,YACnB,OAAQ,WAAmB,YAAY,CAAC,CAAC;EAI3C,IAAI,cAAc,YAChB,OAAQ,WAAmB,SAAS;EAItC,MAAM,YAAY,WAAW,SAAS;EAYtC,OAAO;GAVL;GACA;GACA;GACA;GACA;GACA;GACA;GACA;EAGc,CAAC,CAAC,SAAS,UAAU,UAAU,EAAE,IAAI,QAAQ;CAC/D,QAAQ;EACN,OAAO;CACT;AACF"}
+{"version":3,"file":"getHTMLTextDir.mjs","names":[],"sources":["../../../src/localization/getHTMLTextDir.ts"],"sourcesContent":["import type { LocalesValues } from '@intlayer/types/module_augmentation';\n\ntype Dir = 'ltr' | 'rtl' | 'auto';\n\nconst rtlScripts = [\n  'Arab',\n  'Hebr',\n  'Thaa',\n  'Syrc',\n  'Mand',\n  'Adlm',\n  'Rohg',\n  'Nkoo',\n];\n\n/**\n * Returns the text direction of the given locale.\n *\n * Example:\n *\n * getHTMLTextDir('en-US') // 'ltr'\n * getHTMLTextDir('en') // 'ltr'\n * getHTMLTextDir('fr-CA') // 'ltr'\n * getHTMLTextDir('fr') // 'ltr'\n *\n * @param locale The locale to get the text direction for.\n * @returns The text direction of the given locale.\n */\nexport const getHTMLTextDir = (locale?: LocalesValues): Dir => {\n  if (!locale) return 'ltr';\n\n  try {\n    const localeInfo = new Intl.Locale(locale);\n\n    // Check for the 'textInfo' property (part of the Intl Enumeration API)\n    // Most modern browsers support 'direction' via 'getTextInfo()' or 'textInfo'\n    if ('getTextInfo' in localeInfo) {\n      return (localeInfo as any).getTextInfo().direction as Dir;\n    }\n\n    // Fallback for environments supporting 'textInfo' property\n    if ('textInfo' in localeInfo) {\n      return (localeInfo as any).textInfo.direction as Dir;\n    }\n\n    // Manual fallback for older environments using script detection\n    const maximized = (localeInfo as Intl.Locale).maximize();\n\n    return rtlScripts.includes(maximized.script ?? '') ? 'rtl' : 'ltr';\n  } catch {\n    return 'ltr';\n  }\n};\n"],"mappings":";AAIA,MAAM,aAAa;CACjB;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;;;;;;;;;;;;;;AAeA,MAAa,kBAAkB,WAAgC;CAC7D,IAAI,CAAC,QAAQ,OAAO;CAEpB,IAAI;EACF,MAAM,aAAa,IAAI,KAAK,OAAO,MAAM;EAIzC,IAAI,iBAAiB,YACnB,OAAQ,WAAmB,YAAY,CAAC,CAAC;EAI3C,IAAI,cAAc,YAChB,OAAQ,WAAmB,SAAS;EAItC,MAAM,YAAa,WAA2B,SAAS;EAEvD,OAAO,WAAW,SAAS,UAAU,UAAU,EAAE,IAAI,QAAQ;CAC/D,QAAQ;EACN,OAAO;CACT;AACF"}

package/dist/esm/localization/getLocale.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getLocale.mjs","names":[],"sources":["../../../src/localization/getLocale.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { DEFAULT_LOCALE, LOCALES } from '@intlayer/config/defaultValues';\nimport type { Locale } from '@intlayer/types/allLocales';\nimport { getLocaleFromStorageServer } from '../utils/localeStorage';\nimport { getPreferredLanguages } from './localeDetector';\nimport { localeResolver } from './localeResolver';\n\nexport type RequestContext = {\n  getHeader?: (name: string) => string | null | undefined;\n  getCookie?: (name: string) => string | null | undefined;\n};\n\nexport const getLocale = async (ctx: RequestContext = {}): Promise<Locale> => {\n  const defaultLocale = internationalization?.defaultLocale ?? DEFAULT_LOCALE;\n  const availableLocales = internationalization?.locales ?? LOCALES;\n\n  // Try locale from storage (cookie or header)\n  const storedLocale = getLocaleFromStorageServer({\n    getCookie: ctx.getCookie,\n    getHeader: ctx.getHeader,\n  });\n\n  if (storedLocale) {\n    return storedLocale;\n  }\n\n  // Fallback to Accept-Language negotiation\n  const acceptLanguageHeader = ctx.getHeader?.('accept-language');\n\n  if (!acceptLanguageHeader) {\n    return defaultLocale;\n  }\n\n  const preferredLocaleStrings = getPreferredLanguages(\n    acceptLanguageHeader,\n    availableLocales\n  );\n\n  const userFallbackLocale = localeResolver(\n    preferredLocaleStrings,\n    availableLocales,\n    defaultLocale\n  );\n\n  if (userFallbackLocale) {\n    return userFallbackLocale;\n  }\n\n  // Default locale\n  return defaultLocale;\n};\n"],"mappings":";;;;;;;AAYA,MAAa,YAAY,OAAO,MAAsB,CAAC,MAAuB;CAC5E,MAAM,gBAAgB,sBAAsB,iBAAiB;CAC7D,MAAM,mBAAmB,sBAAsB,WAAW;CAG1D,MAAM,eAAe,2BAA2B;EAC9C,WAAW,IAAI;EACf,WAAW,IAAI;CACjB,CAAC;CAED,IAAI,cACF,OAAO;CAIT,MAAM,uBAAuB,IAAI,YAAY,iBAAiB;CAE9D,IAAI,CAAC,sBACH,OAAO;CAGT,MAAM,yBAAyB,sBAC7B,sBACA,gBACF;CAEA,MAAM,qBAAqB,eACzB,wBACA,kBACA,aACF;CAEA,IAAI,oBACF,OAAO;CAIT,OAAO;AACT"}
+{"version":3,"file":"getLocale.mjs","names":[],"sources":["../../../src/localization/getLocale.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport { DEFAULT_LOCALE, LOCALES } from '@intlayer/config/defaultValues';\nimport type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport { getLocaleFromStorageServer } from '../utils/localeStorage';\nimport { getPreferredLanguages } from './localeDetector';\nimport { localeResolver } from './localeResolver';\n\nexport type RequestContext = {\n  getHeader?: (name: string) => string | null | undefined;\n  getCookie?: (name: string) => string | null | undefined;\n};\n\nexport const getLocale = async (\n  ctx: RequestContext = {}\n): Promise<DeclaredLocales> => {\n  const defaultLocale = internationalization?.defaultLocale ?? DEFAULT_LOCALE;\n  const availableLocales = internationalization?.locales ?? LOCALES;\n\n  // Try locale from storage (cookie or header)\n  const storedLocale = getLocaleFromStorageServer({\n    getCookie: ctx.getCookie,\n    getHeader: ctx.getHeader,\n  });\n\n  if (storedLocale) {\n    return storedLocale;\n  }\n\n  // Fallback to Accept-Language negotiation\n  const acceptLanguageHeader = ctx.getHeader?.('accept-language');\n\n  if (!acceptLanguageHeader) {\n    return defaultLocale;\n  }\n\n  const preferredLocaleStrings = getPreferredLanguages(\n    acceptLanguageHeader,\n    availableLocales\n  );\n\n  const userFallbackLocale = localeResolver(\n    preferredLocaleStrings,\n    availableLocales,\n    defaultLocale\n  );\n\n  if (userFallbackLocale) {\n    return userFallbackLocale;\n  }\n\n  // Default locale\n  return defaultLocale;\n};\n"],"mappings":";;;;;;;AAYA,MAAa,YAAY,OACvB,MAAsB,CAAC,MACM;CAC7B,MAAM,gBAAgB,sBAAsB,iBAAiB;CAC7D,MAAM,mBAAmB,sBAAsB,WAAW;CAG1D,MAAM,eAAe,2BAA2B;EAC9C,WAAW,IAAI;EACf,WAAW,IAAI;CACjB,CAAC;CAED,IAAI,cACF,OAAO;CAIT,MAAM,uBAAuB,IAAI,YAAY,iBAAiB;CAE9D,IAAI,CAAC,sBACH,OAAO;CAGT,MAAM,yBAAyB,sBAC7B,sBACA,gBACF;CAEA,MAAM,qBAAqB,eACzB,wBACA,kBACA,aACF;CAEA,IAAI,oBACF,OAAO;CAIT,OAAO;AACT"}

package/dist/esm/localization/getLocaleFromPath.mjs

@@ -1,5 +1,5 @@
 import { checkIsURLAbsolute } from "../utils/checkIsURLAbsolute.mjs";
-import { resolveRoutingConfig } from "./getPrefix.mjs";
+import { isDeclaredLocale, resolveRoutingConfig } from "./getPrefix.mjs";
 
 //#region src/localization/getLocaleFromPath.ts
 /**
@@ -19,15 +19,15 @@ const getLocaleFromPath = (inputUrl = "/", options) => {
 	if (!defaultLocale || !locales) return defaultLocale;
 	const isAbsoluteUrl = checkIsURLAbsolute(inputUrl);
 	const fixedInputUrl = inputUrl?.endsWith("/") && inputUrl.length > 1 ? inputUrl.slice(0, -1) : inputUrl;
-	const url = isAbsoluteUrl ? new URL(fixedInputUrl) : new URL(fixedInputUrl, "http://example.com");
+	const url = isAbsoluteUrl ? new URL(fixedInputUrl) : new URL(fixedInputUrl, "http://e.com");
 	if (mode === "search-params") {
 		const localeParam = url.searchParams.get("locale");
-		if (localeParam && locales.includes(localeParam)) return localeParam;
+		if (isDeclaredLocale(localeParam, locales)) return localeParam;
 		return defaultLocale;
 	}
 	if (mode === "no-prefix") return defaultLocale;
 	const firstSegment = url.pathname.split("/")[1];
-	if (firstSegment && locales.includes(firstSegment)) return firstSegment;
+	if (isDeclaredLocale(firstSegment, locales)) return firstSegment;
 	if (mode === "prefix-no-default") return defaultLocale;
 };
 

package/dist/esm/localization/getLocaleFromPath.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"getLocaleFromPath.mjs","names":[],"sources":["../../../src/localization/getLocaleFromPath.ts"],"sourcesContent":["import type { Locale } from '@intlayer/types/allLocales';\nimport { checkIsURLAbsolute } from '../utils/checkIsURLAbsolute';\nimport { type RoutingOptions, resolveRoutingConfig } from './getPrefix';\n\n/**\n * Extracts the locale segment from the given URL or pathname based on the routing mode.\n *\n * Mode Behaviors:\n * - 'prefix-no-default': Checks path prefix. If no prefix found, assumes default locale.\n * - 'prefix-all': Checks path prefix.\n * - 'search-params': Checks for 'locale' query parameter.\n * - 'no-prefix': Returns the default locale.\n *\n * @param inputUrl - The complete URL string or pathname to process.\n * @returns The detected locale, default locale (if fallback/implicit), or undefined.\n */\nexport const getLocaleFromPath = (\n  inputUrl: string = '/',\n  options?: RoutingOptions\n): Locale | undefined => {\n  const { defaultLocale, locales, mode } = resolveRoutingConfig(options);\n\n  if (!defaultLocale || !locales) {\n    return defaultLocale as Locale | undefined;\n  }\n\n  const isAbsoluteUrl = checkIsURLAbsolute(inputUrl);\n  const fixedInputUrl =\n    inputUrl?.endsWith('/') && inputUrl.length > 1\n      ? inputUrl.slice(0, -1)\n      : inputUrl;\n\n  const url = isAbsoluteUrl\n    ? new URL(fixedInputUrl)\n    : new URL(fixedInputUrl, 'http://example.com');\n\n  // Handle 'search-params' mode — locale is in query string\n  if (mode === 'search-params') {\n    const localeParam = url.searchParams.get('locale');\n    if (localeParam && locales.includes(localeParam)) {\n      return localeParam as Locale;\n    }\n    return defaultLocale as Locale;\n  }\n\n  // Handle 'no-prefix' mode — locale is not in the URL\n  if (mode === 'no-prefix') {\n    return defaultLocale as Locale;\n  }\n\n  // Handle prefix modes ('prefix-all' | 'prefix-no-default')\n  const firstSegment = url.pathname.split('/')[1];\n  if (firstSegment && locales.includes(firstSegment)) {\n    return firstSegment as Locale;\n  }\n\n  // In 'prefix-no-default', no prefix implies the default locale\n  if (mode === 'prefix-no-default') {\n    return defaultLocale as Locale;\n  }\n\n  return undefined;\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAgBA,MAAa,qBACX,WAAmB,KACnB,YACuB;CACvB,MAAM,EAAE,eAAe,SAAS,SAAS,qBAAqB,OAAO;CAErE,IAAI,CAAC,iBAAiB,CAAC,SACrB,OAAO;CAGT,MAAM,gBAAgB,mBAAmB,QAAQ;CACjD,MAAM,gBACJ,UAAU,SAAS,GAAG,KAAK,SAAS,SAAS,IACzC,SAAS,MAAM,GAAG,EAAE,IACpB;CAEN,MAAM,MAAM,gBACR,IAAI,IAAI,aAAa,IACrB,IAAI,IAAI,eAAe,oBAAoB;CAG/C,IAAI,SAAS,iBAAiB;EAC5B,MAAM,cAAc,IAAI,aAAa,IAAI,QAAQ;EACjD,IAAI,eAAe,QAAQ,SAAS,WAAW,GAC7C,OAAO;EAET,OAAO;CACT;CAGA,IAAI,SAAS,aACX,OAAO;CAIT,MAAM,eAAe,IAAI,SAAS,MAAM,GAAG,CAAC,CAAC;CAC7C,IAAI,gBAAgB,QAAQ,SAAS,YAAY,GAC/C,OAAO;CAIT,IAAI,SAAS,qBACX,OAAO;AAIX"}
+{"version":3,"file":"getLocaleFromPath.mjs","names":[],"sources":["../../../src/localization/getLocaleFromPath.ts"],"sourcesContent":["import type { DeclaredLocales } from '@intlayer/types/module_augmentation';\nimport { checkIsURLAbsolute } from '../utils/checkIsURLAbsolute';\nimport {\n  isDeclaredLocale,\n  type RoutingOptions,\n  resolveRoutingConfig,\n} from './getPrefix';\n\n/**\n * Extracts the locale segment from the given URL or pathname based on the routing mode.\n *\n * Mode Behaviors:\n * - 'prefix-no-default': Checks path prefix. If no prefix found, assumes default locale.\n * - 'prefix-all': Checks path prefix.\n * - 'search-params': Checks for 'locale' query parameter.\n * - 'no-prefix': Returns the default locale.\n *\n * @param inputUrl - The complete URL string or pathname to process.\n * @returns The detected locale, default locale (if fallback/implicit), or undefined.\n */\nexport const getLocaleFromPath = (\n  inputUrl: string = '/',\n  options?: RoutingOptions\n): DeclaredLocales | undefined => {\n  const { defaultLocale, locales, mode } = resolveRoutingConfig(options);\n\n  if (!defaultLocale || !locales) {\n    return defaultLocale as DeclaredLocales | undefined;\n  }\n\n  const isAbsoluteUrl = checkIsURLAbsolute(inputUrl);\n  const fixedInputUrl =\n    inputUrl?.endsWith('/') && inputUrl.length > 1\n      ? inputUrl.slice(0, -1)\n      : inputUrl;\n\n  const url = isAbsoluteUrl\n    ? new URL(fixedInputUrl)\n    : new URL(fixedInputUrl, 'http://e.com');\n\n  // Handle 'search-params' mode — locale is in query string\n  if (mode === 'search-params') {\n    const localeParam = url.searchParams.get('locale');\n    if (isDeclaredLocale(localeParam, locales)) {\n      return localeParam;\n    }\n    return defaultLocale as DeclaredLocales;\n  }\n\n  // Handle 'no-prefix' mode — locale is not in the URL\n  if (mode === 'no-prefix') {\n    return defaultLocale as DeclaredLocales;\n  }\n\n  // Handle prefix modes ('prefix-all' | 'prefix-no-default')\n  const firstSegment = url.pathname.split('/')[1];\n  if (isDeclaredLocale(firstSegment, locales)) {\n    return firstSegment;\n  }\n\n  // In 'prefix-no-default', no prefix implies the default locale\n  if (mode === 'prefix-no-default') {\n    return defaultLocale as DeclaredLocales;\n  }\n\n  return undefined;\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAoBA,MAAa,qBACX,WAAmB,KACnB,YACgC;CAChC,MAAM,EAAE,eAAe,SAAS,SAAS,qBAAqB,OAAO;CAErE,IAAI,CAAC,iBAAiB,CAAC,SACrB,OAAO;CAGT,MAAM,gBAAgB,mBAAmB,QAAQ;CACjD,MAAM,gBACJ,UAAU,SAAS,GAAG,KAAK,SAAS,SAAS,IACzC,SAAS,MAAM,GAAG,EAAE,IACpB;CAEN,MAAM,MAAM,gBACR,IAAI,IAAI,aAAa,IACrB,IAAI,IAAI,eAAe,cAAc;CAGzC,IAAI,SAAS,iBAAiB;EAC5B,MAAM,cAAc,IAAI,aAAa,IAAI,QAAQ;EACjD,IAAI,iBAAiB,aAAa,OAAO,GACvC,OAAO;EAET,OAAO;CACT;CAGA,IAAI,SAAS,aACX,OAAO;CAIT,MAAM,eAAe,IAAI,SAAS,MAAM,GAAG,CAAC,CAAC;CAC7C,IAAI,iBAAiB,cAAc,OAAO,GACxC,OAAO;CAIT,IAAI,SAAS,qBACX,OAAO;AAIX"}

package/dist/esm/localization/getLocalizedPath.mjs

@@ -0,0 +1,73 @@
+import { getPathWithoutLocale } from "./getPathWithoutLocale.mjs";
+import { getPrefix, resolveRoutingConfig } from "./getPrefix.mjs";
+import { getCanonicalPath, getRewriteRules, resolveLocalizedPath } from "./rewriteUtils.mjs";
+import { internationalization } from "@intlayer/config/built";
+
+//#region src/localization/getLocalizedPath.ts
+/**
+* Localizes an application path for a locale: resolves the `routing.rewrite`
+* rules, then applies the locale representation of the routing mode — a path
+* prefix, a `locale` search parameter, or nothing at all.
+*
+* Any query string and hash of the input are preserved.
+*
+* This is the relative half of {@link getLocalizedUrl}, which builds on it to
+* add an origin and cross-domain routing. For a relative input both return the
+* same value; this one never returns an absolute URL — the origin of an
+* absolute input is dropped and only its path is localized.
+*
+* Use `resolveLocalizedPath` instead to apply the rewrite rules alone, without
+* any locale representation.
+*
+* @example
+* ```ts
+* // routing: { mode: 'prefix-no-default', rewrite: { '/about': { fr: '/a-propos' } } }
+* getLocalizedPath('/about', 'fr');       // '/fr/a-propos'
+* getLocalizedPath('/about', 'en');       // '/about'  (default locale, no prefix)
+* getLocalizedPath('/', 'fr');            // '/fr'
+* getLocalizedPath('/contact', 'fr');     // '/fr/contact' (no rewrite rule matches)
+* getLocalizedPath('https://intlayer.org/about', 'fr'); // '/fr/a-propos' (origin dropped)
+*
+* // Manual rules, bypassing the configuration
+* getLocalizedPath('/contact', 'fr', {
+*   rewrite: { '/contact': { fr: '/contactez-nous' } },
+* });
+* // '/fr/contactez-nous'
+* ```
+*
+* @param canonicalPath - The internal application path (e.g. `/about`, `/product/123`).
+*   An absolute URL is accepted; only its path, query and hash are kept.
+* @param locale - The target locale. Defaults to the configured default locale.
+* @param options - Routing overrides (`locales`, `defaultLocale`, `mode`, `rewrite`,
+*   `domains`). Each one defaults to the project configuration. `domains` only
+*   suppresses the prefix of a locale served from its own domain — the origin
+*   itself is never emitted.
+* @returns The localized path for the target locale.
+*/
+const getLocalizedPath = (canonicalPath, locale = internationalization?.defaultLocale, options = {}) => {
+	const { defaultLocale, mode, locales, rewrite, domains } = resolveRoutingConfig(options);
+	const pathWithoutLocale = getPathWithoutLocale(canonicalPath, locales);
+	const rewriteRules = getRewriteRules(rewrite, "url");
+	const parsedPath = new URL(pathWithoutLocale, "http://e.com");
+	const translatedPathname = resolveLocalizedPath(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);
+		searchParams.set("locale", locale.toString());
+		const queryParams = searchParams.toString();
+		return `${translatedPathname}${queryParams ? `?${queryParams}` : ""}${parsedPath.hash}`;
+	}
+	const { prefix } = getPrefix(locale, {
+		defaultLocale,
+		mode,
+		locales,
+		domains
+	});
+	let localizedPath = `/${prefix}${translatedPathname}`.replace(/\/+/g, "/");
+	if (localizedPath.length > 1 && localizedPath.endsWith("/")) localizedPath = localizedPath.slice(0, -1);
+	return `${localizedPath}${parsedPath.search}${parsedPath.hash}`;
+};
+
+//#endregion
+export { getLocalizedPath };
+//# sourceMappingURL=getLocalizedPath.mjs.map

package/dist/esm/localization/getLocalizedPath.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getLocalizedPath.mjs","names":[],"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 * // 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2DA,MAAa,oBAIX,eACA,SAAwB,sBAAsB,eAC9C,UAA0B,CAAC,MACyB;CACpD,MAAM,EAAE,eAAe,MAAM,SAAS,SAAS,YAC7C,qBAAqB,OAAO;CAE9B,MAAM,oBAAoB,qBAAqB,eAAe,OAAO;CACrE,MAAM,eAAe,gBAAgB,SAAS,KAAK;CAInD,MAAM,aAAa,IAAI,IAAI,mBAAmB,cAAc;CAE5D,MAAM,qBAAqB,qBACzB,iBAAiB,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,WAAW,UAAU,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/esm/localization/getLocalizedPath.test-d.mjs

@@ -0,0 +1,83 @@
+import { getLocalizedPath } from "./getLocalizedPath.mjs";
+import { getLocalizedUrl } from "./getLocalizedUrl.mjs";
+import { describe, expectTypeOf, it } from "vitest";
+
+//#region src/localization/getLocalizedPath.test-d.ts
+/**
+* `getLocalizedPath` prefixes the rewritten path, so it reports the very type
+* its sibling reports for a relative URL. This package declares neither rewrite
+* rules nor a default locale, so the registry leaves both steps as no-ops.
+*/
+describe("getLocalizedPath", () => {
+	it("should report the same type as getLocalizedUrl", () => {
+		expectTypeOf(getLocalizedPath("/about", "fr")).toEqualTypeOf();
+		expectTypeOf(getLocalizedPath("/about", "fr")).toEqualTypeOf(getLocalizedUrl("/about", "fr"));
+	});
+	it("should keep the literal path when nothing rewrites or prefixes it", () => {
+		expectTypeOf(getLocalizedPath("/about", "fr")).toEqualTypeOf();
+	});
+	it("should drop the origin of an absolute URL", () => {
+		expectTypeOf(getLocalizedPath("https://intlayer.org/about", "fr")).toEqualTypeOf();
+	});
+	it("should widen to string when the path is not a literal", () => {
+		expectTypeOf(getLocalizedPath("/about", "fr")).toEqualTypeOf();
+	});
+});
+/**
+* The resolution itself, exercised against explicit rules — the same shape the
+* generated module augmentation feeds it as `__RoutingRegistry['rewrite']`.
+*/
+describe("LocalizedPath", () => {
+	it("should rewrite a static path", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should keep a path no rule matches", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should substitute a route parameter", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should substitute several route parameters", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should not match a parameter across a segment boundary", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should keep the path when the locale declares no pattern", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should distribute over a union of locales", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should widen a variadic rule to string, but only for the paths it could match", () => {
+		expectTypeOf().toEqualTypeOf();
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should keep every path when the project declares no rule", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+});
+/**
+* The return type of `getLocalizedPath`, exercised against an explicit routing
+* mode, default locale and locale set — this package declares none of them.
+*/
+describe("LocalizedPathname", () => {
+	it("should report the same type as LocalizedUrl for a relative path", () => {
+		expectTypeOf().toEqualTypeOf();
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should drop the origin of an absolute URL", () => {
+		expectTypeOf().toEqualTypeOf();
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should collapse an origin without a path to the root", () => {
+		expectTypeOf().toEqualTypeOf();
+		expectTypeOf().toEqualTypeOf();
+	});
+	it("should replace a locale segment carried by an absolute URL", () => {
+		expectTypeOf().toEqualTypeOf();
+	});
+});
+
+//#endregion
+//# sourceMappingURL=getLocalizedPath.test-d.mjs.map