@intlayer/core 9.3.2 → 9.3.3

package/dist/types/localization/getLocalizedPath.d.ts

@@ -0,0 +1,47 @@
+import { RoutingOptions } from "./getPrefix.js";
+import { LocalesValues, LocalizedPathname, ResolvedDefaultLocale } from "@intlayer/types/module_augmentation";
+//#region src/localization/getLocalizedPath.d.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.
+ */
+declare const getLocalizedPath: <const CanonicalPath extends string, const CurrentLocale extends LocalesValues = ResolvedDefaultLocale>(canonicalPath: CanonicalPath, locale?: CurrentLocale, options?: RoutingOptions) => LocalizedPathname<CanonicalPath, CurrentLocale>;
+//#endregion
+export { getLocalizedPath };
+//# sourceMappingURL=getLocalizedPath.d.ts.map

package/dist/types/localization/getLocalizedPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getLocalizedPath.d.ts","names":[],"sources":["../../../src/localization/getLocalizedPath.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2Da,yBACL,oCACA,sBAAsB,gBAAgB,uBAAqB,eAElD,eAAa,SACpB,eAAa,UACZ,mBACR,kBAAkB,eAAe"}

package/dist/types/localization/getLocalizedPath.test-d.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/types/localization/getLocalizedUrl.d.ts

@@ -7,6 +7,10 @@ import { LocalesValues, LocalizedUrl, ResolvedDefaultLocale } from "@intlayer/ty
  *
  * This function gets the locales, default locale, and routing mode from the configuration if not provided.
  *
+ * The path itself is localized by {@link getLocalizedPath}; this function only
+ * resolves the origin to put in front of it — the one of an absolute input, or
+ * the domain mapped to the target locale.
+ *
  * Example:
  *
  * ```ts
@@ -47,5 +51,5 @@ import { LocalesValues, LocalizedUrl, ResolvedDefaultLocale } from "@intlayer/ty
  */
 declare const getLocalizedUrl: <const T extends string, const L extends LocalesValues = ResolvedDefaultLocale>(url: T, currentLocale?: L, options?: RoutingOptions) => LocalizedUrl<T, L>;
 //#endregion
-export { type RoutingOptions, getLocalizedUrl };
+export { getLocalizedUrl };
 //# sourceMappingURL=getLocalizedUrl.d.ts.map

package/dist/types/localization/getLocalizedUrl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getLocalizedUrl.d.ts","names":[],"sources":["../../../src/localization/getLocalizedUrl.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwEa,wBACL,wBACA,UAAU,gBAAgB,uBAAqB,KAEhD,GAAC,gBACS,GAAC,UACP,mBACR,aAAa,GAAG"}
+{"version":3,"file":"getLocalizedUrl.d.ts","names":[],"sources":["../../../src/localization/getLocalizedUrl.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2Da,wBACL,wBACA,UAAU,gBAAgB,uBAAqB,KAEhD,GAAC,gBACS,GAAC,UACP,mBACR,aAAa,GAAG"}

package/dist/types/localization/getLocalizedUrl.test-d.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/types/localization/getPrefix.d.ts

@@ -1,6 +1,5 @@
 import { DeclaredLocales, LocalesValues, ResolvedDefaultLocale, ResolvedRoutingMode } from "@intlayer/types/module_augmentation";
-import { Locale } from "@intlayer/types/allLocales";
-import { RoutingConfig } from "@intlayer/types/config";
+import { RewriteRules, RoutingConfig } from "@intlayer/types/config";
 //#region src/localization/getPrefix.d.ts
 /**
  * Shared routing options used across all URL localization functions.
@@ -9,7 +8,7 @@ type RoutingOptions = {
   locales?: LocalesValues[];
   defaultLocale?: LocalesValues;
   mode?: RoutingConfig['mode'];
-  rewrite?: RoutingConfig['rewrite'];
+  rewrite?: RoutingConfig['rewrite'] | RewriteRules;
   domains?: RoutingConfig['domains'];
   /**
    * The hostname of the page currently being rendered (e.g. `'intlayer.org'`).
@@ -29,12 +28,25 @@ type RoutingOptions = {
  * Single source of truth for default routing config resolution across all localization functions.
  */
 declare const resolveRoutingConfig: (options?: RoutingOptions) => Omit<RoutingOptions, 'defaultLocale' | 'mode' | 'locales'> & {
-  defaultLocale: LocalesValues;
+  defaultLocale: DeclaredLocales;
   mode: RoutingConfig['mode'];
-  locales: LocalesValues[];
+  locales: DeclaredLocales[];
 };
+/**
+ * Narrows an arbitrary string to a declared locale by membership test.
+ *
+ * `locales` is typed as `DeclaredLocales[]`, so a plain `includes` rejects the
+ * `string` values that actually need testing (a URL segment, a query param, a
+ * stored value). This keeps the check honest and hands back a narrowed type
+ * instead of forcing a cast at every call site.
+ *
+ * @param value - The candidate locale, from a URL segment / storage / header.
+ * @param locales - The locales declared by the configuration.
+ * @returns Whether `value` is one of the declared locales.
+ */
+declare const isDeclaredLocale: (value: LocalesValues | undefined | null, locales?: readonly LocalesValues[]) => value is DeclaredLocales;
 type GetPrefixOptions = {
-  defaultLocale?: LocalesValues;
+  defaultLocale?: ResolvedDefaultLocale;
   mode?: RoutingConfig['mode'];
 };
 type GetPrefixResult = {
@@ -46,7 +58,7 @@ type GetPrefixResult = {
   /**
    * The bare locale identifier (e.g. `'fr'`), or `undefined` when no prefix is applied.
    */
-  localePrefix: Locale | undefined;
+  localePrefix: DeclaredLocales | undefined;
 };
 /**
  * Narrowed return type for {@link getPrefix} that carries the locale literal through.
@@ -108,5 +120,5 @@ type GetPrefixResultNarrowed<L extends LocalesValues | undefined, Mode extends s
  */
 declare const getPrefix: <const L extends LocalesValues | undefined>(locale: L, options?: RoutingOptions) => GetPrefixResultNarrowed<L>;
 //#endregion
-export { GetPrefixOptions, GetPrefixResult, GetPrefixResultNarrowed, RoutingOptions, getPrefix, resolveRoutingConfig };
+export { GetPrefixOptions, GetPrefixResult, GetPrefixResultNarrowed, RoutingOptions, getPrefix, isDeclaredLocale, resolveRoutingConfig };
 //# sourceMappingURL=getPrefix.d.ts.map

package/dist/types/localization/getPrefix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getPrefix.d.ts","names":[],"sources":["../../../src/localization/getPrefix.ts"],"mappings":";;;;;;;KAwBY;EACV,UAAU;EACV,gBAAgB;EAChB,OAAO;EACP,UAAU;EACV,UAAU;;;;;;;;;;;;EAYV;;;;;;cAOW,uBAAoB,UACtB,mBACR,KAAK;EACN,eAAe;EACf,MAAM;EACN,SAAS;;KAUC;EACV,gBAAgB;EAChB,OAAO;;KAGG;;;;;EAKV;;;;EAIA,cAAc;;;;;;;;;;;KAYJ,wBACV,UAAU,2BACV,sBAAsB,qBACtB,gBAAgB,gBAAgB,yBAC9B,qCACkB,KAChB,wBAAwB,iBAAiB,MAAM,6BAC7B,QAChB,kBACA;EACI,WAAW;EAAM,cAAc;IACjC,mCACE,UAAU;EACN;EAAY;;EACZ,WAAW;EAAM,cAAc;;EACjC;EAAY;;EACpB;EAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCL,kBAAmB,UAAU,2BAAyB,QACzD,GAAC,UACA,mBACR,wBAAwB"}
+{"version":3,"file":"getPrefix.d.ts","names":[],"sources":["../../../src/localization/getPrefix.ts"],"mappings":";;;;;;KAkBY;EACV,UAAU;EACV,gBAAgB;EAChB,OAAO;EACP,UAAU,2BAA2B;EACrC,UAAU;;;;;;;;;;;;EAYV;;;;;;cAOW,uBAAoB,UACtB,mBACR,KAAK;EACN,eAAe;EACf,MAAM;EACN,SAAS;;;;;;;;;;;;;;cAsBE,mBAAgB,OACpB,kCAAgC,mBACpB,oBAClB,SAAS;KAGA;EACV,gBAAgB;EAChB,OAAO;;KAGG;;;;;EAKV;;;;EAIA,cAAc;;;;;;;;;;;KAYJ,wBACV,UAAU,2BACV,sBAAsB,qBACtB,gBAAgB,gBAAgB,yBAC9B,qCACkB,KAChB,wBAAwB,iBAAiB,MAAM,6BAC7B,QAChB,kBACA;EACI,WAAW;EAAM,cAAc;IACjC,mCACE,UAAU;EACN;EAAY;;EACZ,WAAW;EAAM,cAAc;;EACjC;EAAY;;EACpB;EAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCL,kBAAmB,UAAU,2BAAyB,QACzD,GAAC,UACA,mBACR,wBAAwB"}

package/dist/types/localization/index.d.ts

@@ -4,10 +4,11 @@ import { GenerateSitemapOptions, SitemapUrlEntry, generateSitemap, generateSitem
 import { getBrowserLocale } from "./getBrowserLocale.js";
 import { getHTMLTextDir } from "./getHTMLTextDir.js";
 import { getLocale } from "./getLocale.js";
-import { GetPrefixOptions, GetPrefixResult, getPrefix } from "./getPrefix.js";
+import { GetPrefixOptions, GetPrefixResult, getPrefix, isDeclaredLocale } from "./getPrefix.js";
 import { getLocaleFromPath } from "./getLocaleFromPath.js";
 import { getLocaleLang } from "./getLocaleLang.js";
 import { getLocaleName } from "./getLocaleName.js";
+import { getLocalizedPath } from "./getLocalizedPath.js";
 import { getLocalizedUrl } from "./getLocalizedUrl.js";
 import { getMultilingualUrls } from "./getMultilingualUrls.js";
 import { getPathWithoutLocale } from "./getPathWithoutLocale.js";
@@ -15,6 +16,7 @@ import { localeDetector } from "./localeDetector.js";
 import { localeFlatMap, localeMap, localeRecord } from "./localeMapper.js";
 import { localeResolver } from "./localeResolver.js";
 import { ProxyMode, formatProxyEnabledMessage, isProxyStorageLocaleEnabled, resolveProxyMode } from "./proxyMode.js";
-import { LocalizedPathResult, getCanonicalPath, getInternalPath, getLocalizedPath, getRewritePath, getRewriteRules } from "./rewriteUtils.js";
+import { getPreloadLocale, resolveBrowserLocale } from "./resolveBrowserLocale.js";
+import { LocalizedPathResult, getCanonicalPath, getInternalPath, getRewritePath, getRewriteRules, resolveLocalizedPath } from "./rewriteUtils.js";
 import { validatePrefix } from "./validatePrefix.js";
-export { type GenerateSitemapOptions, type GetPrefixOptions, type GetPrefixResult, type LocaleDomainMap, type LocalizedPathResult, type ProxyMode, type SitemapUrlEntry, comparePaths, formatProxyEnabledMessage, generateSitemap, generateSitemapUrl, getBrowserLocale, getCanonicalPath, getDomainHostname, getDomainOrigin, getHTMLTextDir, getInternalPath, getLocale, getLocaleFromDomain, getLocaleFromPath, getLocaleLang, getLocaleName, getLocalizedPath, getLocalizedUrl, getMultilingualUrls, getPathWithoutLocale, getPrefix, getRewritePath, getRewriteRules, isLocaleExclusiveOnDomain, isProxyStorageLocaleEnabled, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, normalizePath, resolveProxyMode, validatePrefix };
+export { type GenerateSitemapOptions, type GetPrefixOptions, type GetPrefixResult, type LocaleDomainMap, type LocalizedPathResult, type ProxyMode, type SitemapUrlEntry, comparePaths, formatProxyEnabledMessage, generateSitemap, generateSitemapUrl, getBrowserLocale, getCanonicalPath, getDomainHostname, getDomainOrigin, getHTMLTextDir, getInternalPath, getLocale, getLocaleFromDomain, getLocaleFromPath, getLocaleLang, getLocaleName, getLocalizedPath, getLocalizedUrl, getMultilingualUrls, getPathWithoutLocale, getPrefix, getPreloadLocale, getRewritePath, getRewriteRules, isDeclaredLocale, isLocaleExclusiveOnDomain, isProxyStorageLocaleEnabled, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, normalizePath, resolveBrowserLocale, resolveLocalizedPath, resolveProxyMode, validatePrefix };

package/dist/types/localization/localeDetector.d.ts

@@ -1,3 +1,4 @@
+import { DeclaredLocales } from "@intlayer/types/module_augmentation";
 import { Locale } from "@intlayer/types/allLocales";
 //#region src/localization/localeDetector.d.ts
 /**
@@ -11,7 +12,7 @@ declare const getPreferredLanguages: (acceptHeader: string | undefined, availabl
  * Headers are provided by the browser/client and can be used to determine the user's preferred language.
  * This function intersects the user's `Accept-Language` header with the application's available locales.
  */
-declare const localeDetector: (headers: Record<string, string | undefined>, availableLocales?: Locale[], defaultLocale?: Locale) => Locale;
+declare const localeDetector: (headers: Record<string, string | undefined>, availableLocales?: Locale[], defaultLocale?: Locale) => DeclaredLocales;
 //#endregion
 export { getPreferredLanguages, localeDetector };
 //# sourceMappingURL=localeDetector.d.ts.map

package/dist/types/localization/localeDetector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localeDetector.d.ts","names":[],"sources":["../../../src/localization/localeDetector.ts"],"mappings":";;;;;;cA+Ma,wBAAqB,kCACA;;;;;;;cAgCrB,iBAAc,SAChB,oCAAkC,mBACxB,UAAQ,gBACX,WACf"}
+{"version":3,"file":"localeDetector.d.ts","names":[],"sources":["../../../src/localization/localeDetector.ts"],"mappings":";;;;;;;cAqNa,wBAAqB,kCACA;;;;;;;cAgCrB,iBAAc,SAChB,oCAAkC,mBACxB,UAAQ,gBACX,WACf"}

package/dist/types/localization/localeMapper.d.ts

@@ -1,11 +1,10 @@
-import { LocalesValues } from "@intlayer/types/module_augmentation";
-import { Locale } from "@intlayer/types/allLocales";
+import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/localization/localeMapper.d.ts
 type LocaleData = {
-  locale: Locale;
-  defaultLocale: Locale;
+  locale: DeclaredLocales;
+  defaultLocale: DeclaredLocales;
   isDefault: boolean;
-  locales: Locale[];
+  locales: DeclaredLocales[];
   urlPrefix: string;
 };
 /**

package/dist/types/localization/localeMapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localeMapper.d.ts","names":[],"sources":["../../../src/localization/localeMapper.ts"],"mappings":";;;KAMY;EACV,QAAQ;EACR,eAAe;EACf;EACA,SAAS;EACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6BW,YAAa,GAAC,SAChB,QAAQ,eAAe,GAAC,UACxB,iBAAe,gBACT,eAAa,8EAO3B;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCU,gBAAiB,GAAC,SACpB,QAAQ,eAAe,KAAG,UAC1B,iBAAe,gBACT,eAAa,8EAO3B;;;;;;;;;;;;;;;;;;;;;;;;cAqCU,eAAgB,GAAC,SACnB,QAAQ,eAAe,GAAC,UACxB,iBAAe,gBACT,eAAa,8EAO3B,OAAO,eAAe"}
+{"version":3,"file":"localeMapper.d.ts","names":[],"sources":["../../../src/localization/localeMapper.ts"],"mappings":";;KAQY;EACV,QAAQ;EACR,eAAe;EACf;EACA,SAAS;EACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6BW,YAAa,GAAC,SAChB,QAAQ,eAAe,GAAC,UACxB,iBAAe,gBACT,eAAa,8EAO3B;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCU,gBAAiB,GAAC,SACpB,QAAQ,eAAe,KAAG,UAC1B,iBAAe,gBACT,eAAa,8EAO3B;;;;;;;;;;;;;;;;;;;;;;;;cAqCU,eAAgB,GAAC,SACnB,QAAQ,eAAe,GAAC,UACxB,iBAAe,gBACT,eAAa,8EAO3B,OAAO,eAAe"}

package/dist/types/localization/localeResolver.d.ts

@@ -1,11 +1,10 @@
-import { LocalesValues } from "@intlayer/types/module_augmentation";
-import { Locale } from "@intlayer/types/allLocales";
+import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/localization/localeResolver.d.ts
 /**
  * Resolves the most specific locale from a user-provided list,
  * or falls back to the default locale if no match is found.
  */
-declare const localeResolver: (selectedLocale: LocalesValues | LocalesValues[], locales?: LocalesValues[], defaultLocale?: LocalesValues) => Locale;
+declare const localeResolver: (selectedLocale: LocalesValues | LocalesValues[], locales?: LocalesValues[], defaultLocale?: LocalesValues) => DeclaredLocales;
 //#endregion
 export { localeResolver };
 //# sourceMappingURL=localeResolver.d.ts.map

package/dist/types/localization/localeResolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localeResolver.d.ts","names":[],"sources":["../../../src/localization/localeResolver.ts"],"mappings":";;;;;;;cAQa,iBAAc,gBACT,gBAAgB,iBAAe,UACtC,iBAAe,gBACT,kBACd"}
+{"version":3,"file":"localeResolver.d.ts","names":[],"sources":["../../../src/localization/localeResolver.ts"],"mappings":";;;;;;cAUa,iBAAc,gBACT,gBAAgB,iBAAe,UACtC,iBAAe,gBACT,kBACd"}

package/dist/types/localization/resolveBrowserLocale.d.ts

@@ -0,0 +1,35 @@
+import { RoutingOptions } from "./getPrefix.js";
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+//#region src/localization/resolveBrowserLocale.d.ts
+/**
+ * Resolves the locale of the current document outside of React.
+ *
+ * Generated dynamic entry points need the locale while they are still
+ * evaluating, long before a provider exists, so this reproduces the precedence
+ * a provider applies — URL first (which is what a router hands the provider as
+ * `locale`), then browser storage, then the configured default. Agreeing with
+ * the provider is what makes the preloaded read hit; disagreeing is safe but
+ * costs a load, since the consumer compares locales before using a preloaded
+ * dictionary.
+ *
+ * @param options - Routing overrides, defaulting to the built configuration.
+ * @returns The resolved locale, falling back to the default locale off-browser.
+ */
+declare const resolveBrowserLocale: (options?: RoutingOptions) => LocalesValues;
+/**
+ * {@link resolveBrowserLocale}, memoized for the current URL.
+ *
+ * Every generated dynamic entry point calls this as it evaluates, and an
+ * application has hundreds of them — repeating the cookie and storage reads
+ * that many times on startup is pure cost, since they cannot change while a
+ * page is being assembled.
+ *
+ * Keying the cache on the URL rather than caching forever keeps a client-side
+ * locale change honest: navigating to another locale's URL loads further
+ * chunks with that locale, instead of preloading the old one and silently
+ * falling back to an asynchronous read.
+ */
+declare const getPreloadLocale: () => LocalesValues;
+//#endregion
+export { getPreloadLocale, resolveBrowserLocale };
+//# sourceMappingURL=resolveBrowserLocale.d.ts.map

package/dist/types/localization/resolveBrowserLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveBrowserLocale.d.ts","names":[],"sources":["../../../src/localization/resolveBrowserLocale.ts"],"mappings":";;;;;;;;;;;;;;;;;cAoBa,uBAAoB,UACrB,mBACT;;;;;;;;;;;;;;cAqDU,wBAAuB"}

package/dist/types/localization/rewriteUtils.d.ts

@@ -1,33 +1,73 @@
-import { LocalesValues } from "@intlayer/types/module_augmentation";
-import { Locale } from "@intlayer/types/allLocales";
+import { LocalesValues, ResolvedDefaultLocale } from "@intlayer/types/module_augmentation";
 import { RewriteObject, RewriteRules, RoutingConfig } from "@intlayer/types/config";
 //#region src/localization/rewriteUtils.d.ts
-type LocalizedPathResult = {
+/**
+ * Outcome of resolving a canonical path against the rewrite rules.
+ *
+ * Discriminated on `isRewritten`: when no rule matched, `path` is the very
+ * input that was passed in, so a literal input keeps its literal type. Only a
+ * rewritten path is computed at runtime and therefore widens to `string`.
+ */
+type LocalizedPathResult<CanonicalPath extends string = string> = {
+  path: CanonicalPath;
+  isRewritten: false;
+} | {
   path: string;
-  isRewritten: boolean;
+  isRewritten: true;
 };
+/** Adds the leading slash a path may be missing. */
+type WithLeadingSlash<Path extends string> = Path extends `/${string}` ? Path : `/${Path}`;
+/**
+ * Computes the locale-prefixed internal path for a path and a locale, mirroring
+ * `getInternalPath`'s runtime behaviour: an already-prefixed path is returned
+ * untouched, the root collapses to `/${Locale}` (never a trailing slash), and
+ * anything else gets the prefix prepended.
+ *
+ * Falls back to `string` for a non-literal path, where the prefixed and
+ * already-prefixed cases cannot be told apart.
+ *
+ * @example
+ * type A = InternalPath<'/about', 'fr'>;    // '/fr/about'
+ * type B = InternalPath<'/', 'fr'>;         // '/fr'
+ * type C = InternalPath<'/fr/about', 'fr'>; // '/fr/about' (already prefixed)
+ */
+type InternalPath<Path extends string, Locale extends string> = string extends Path ? string : WithLeadingSlash<Path> extends (infer Prefixed extends string) ? Prefixed extends `/${Locale}` | `/${Locale}/${string}` ? Prefixed : Prefixed extends '/' ? `/${Locale}` : `/${Locale}${Prefixed}` : never;
 /**
  * Normalizes legacy Record format or extracts specialized rules from RewriteObject.
+ *
+ * Idempotent: already-normalized rules are handed back untouched, so a caller
+ * holding resolved rules can pass them on without re-normalizing.
  */
-declare const getRewriteRules: (rewrite: RoutingConfig['rewrite'], context?: keyof RewriteObject) => RewriteRules | undefined;
+declare const getRewriteRules: <const Context extends keyof RewriteObject = 'url'>(rewrite: RoutingConfig['rewrite'] | RewriteRules, context?: Context) => RewriteRules | undefined;
 /**
  * Given a localized URL (e.g., "/produits/123"), finds the canonical internal path (e.g., "/products/123").
  * If locale is provided, only check for that locale. Otherwise, check for all locales.
  */
-declare const getCanonicalPath: (localizedPath: string, locale?: Locale, rewriteRules?: RewriteRules) => string;
+declare const getCanonicalPath: <const Path extends string, const Locale extends LocalesValues = LocalesValues>(localizedPath: Path, locale?: Locale, rewriteRules?: RewriteRules) => string;
 /**
- * Given a canonical path (e.g., "/products/123"), finds the localized URL pattern (e.g., "/produits/123").
+ * Given a canonical path (e.g., "/products/123"), finds the localized URL pattern
+ * (e.g., "/produits/123") and reports whether a rule actually matched.
+ *
+ * Takes already-normalized rules, so callers that resolve the rules once (proxies,
+ * static emitters) can reuse them. {@link getLocalizedPath} is the user-facing
+ * counterpart: it accepts the raw `routing.rewrite` configuration, defaults to the
+ * project configuration, and returns the path alone.
+ *
+ * @param canonicalPath - The internal application path (e.g. `/product/:id`, `/about`).
+ * @param locale - The target locale. Defaults to the configured default locale.
+ * @param rewriteRules - Normalized rules, as returned by {@link getRewriteRules}.
+ * @returns The localized path, discriminated on whether a rewrite rule matched.
  */
-declare const getLocalizedPath: (canonicalPath: string, locale: LocalesValues, rewriteRules?: RewriteRules) => LocalizedPathResult;
+declare const resolveLocalizedPath: <const CanonicalPath extends string, const Locale extends LocalesValues = ResolvedDefaultLocale>(canonicalPath: CanonicalPath, locale?: Locale, rewriteRules?: RewriteRules) => LocalizedPathResult<CanonicalPath>;
 /**
  * Returns the internal path for a given canonical path and locale.
  * Ensures the locale prefix is present exactly once.
  */
-declare const getInternalPath: (canonicalPath: string, locale: Locale) => string;
+declare const getInternalPath: <const Path extends string, const Locale extends LocalesValues>(canonicalPath: Path, locale: Locale) => InternalPath<Path, Locale>;
 /**
  * Given a current pathname and locale, returns the pretty localized path if a rewrite rule exists and the path is not already localized.
  */
-declare const getRewritePath: (pathname: string, locale: Locale, rewrite?: RoutingConfig['rewrite']) => string | undefined;
+declare const getRewritePath: <const Path extends string, const Locale extends LocalesValues = ResolvedDefaultLocale>(pathname: Path, locale: Locale, rewrite?: RoutingConfig['rewrite']) => string | undefined;
 //#endregion
-export { LocalizedPathResult, getCanonicalPath, getInternalPath, getLocalizedPath, getRewritePath, getRewriteRules };
+export { InternalPath, LocalizedPathResult, getCanonicalPath, getInternalPath, getRewritePath, getRewriteRules, resolveLocalizedPath };
 //# sourceMappingURL=rewriteUtils.d.ts.map

package/dist/types/localization/rewriteUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rewriteUtils.d.ts","names":[],"sources":["../../../src/localization/rewriteUtils.ts"],"mappings":";;;;KAmBY;EACV;EACA;;;;;cAMW,kBAAe,SACjB,0BAAwB,gBAClB,kBACd;;;;;cA2EU,mBAAgB,uBACN,SACZ,QAAM,eACA;;;;cA2BJ,mBAAgB,uBACN,QACb,eAAa,eACN,iBACd;;;;;cA6BU,kBAAe,uBACL,QACb;;;;cAmBG,iBAAc,kBACT,QACR,QAAM,UACJ"}
+{"version":3,"file":"rewriteUtils.d.ts","names":[],"sources":["../../../src/localization/rewriteUtils.ts"],"mappings":";;;;;;;;;;KAkBY,oBAAoB;EAC1B,MAAM;EAAe;;EACrB;EAAc;;;KAGf,iBAAiB,uBAAuB,4BACzC,WACI;;;;;;;;;;;;;;;KAgBI,aACV,qBACA,wCACiB,gBAEf,iBAAiB,qBAAoB,2BACnC,qBAAqB,eAAe,qBAClC,WACA,2BACM,eACA,SAAS;;;;;;;cASV,wBACL,sBAAsB,uBAAqB,SAExC,2BAA2B,cAAY,UACvC,YACR;;;;;cAsFU,yBACL,2BACA,eAAe,gBAAgB,eAAa,eAEnC,MAAI,SACV,QAAM,eACA;;;;;;;;;;;;;;;cA2CJ,6BACL,oCACA,eAAe,gBAAgB,uBAAqB,eAE3C,eAAa,SACnB,QAAM,eACA,iBACd,oBAAoB;;;;;cAkCV,wBACL,2BACA,eAAe,eAAa,eAEnB,MAAI,QACX,WACP,aAAa,MAAM;;;;cAoBT,uBACL,2BACA,eAAe,gBAAgB,uBAAqB,UAEhD,MAAI,QACN,QAAM,UACJ"}

package/dist/types/localization/rewriteUtils.test-d.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/types/markdown/constants.d.ts

@@ -90,6 +90,8 @@ declare const BREAK_THEMATIC_R: RegExp;
 /** Code block patterns */
 declare const CODE_BLOCK_FENCED_R: RegExp;
 declare const CODE_BLOCK_R: RegExp;
+/** A single line opening or closing a fenced code block, with its indentation. */
+declare const FENCE_DELIMITER_R: RegExp;
 declare const CODE_INLINE_R: RegExp;
 /** Newline patterns */
 declare const CONSECUTIVE_NEWLINE_R: RegExp;
@@ -183,5 +185,5 @@ declare const generateListRegex: (type: ListType) => RegExp;
 declare const ORDERED_LIST_R: RegExp;
 declare const UNORDERED_LIST_R: RegExp;
 //#endregion
-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, 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, ListType, 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, PriorityValue, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleType, RuleTypeValue, 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 };
+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, 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, ListType, 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, PriorityValue, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleType, RuleTypeValue, 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 };
 //# sourceMappingURL=constants.d.ts.map

package/dist/types/markdown/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","names":[],"sources":["../../../src/markdown/constants.ts"],"mappings":";;;;;cAQa;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;WAEA;WACA;;WAEA;;WAEA;WACA;WACA;;WAEA;;WAEA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;KAUU,wBAAwB,uBAAuB;;;;cAS9C;;WAEX;;WAEA;;WAEA;;WAEA;;WAEA;;KAGU,wBAAwB,uBAAuB;;cAO9C;;;;;cAUA,4BAA4B;;;;cAuD5B,wBAAwB;;cAcxB;;cAGA;;cAcA,kBAAgB;;cAIhB,aAAW;;cAGX,cAAY;cACZ,kCAAgC;cAChC,oBAAkB;;cAGlB,cAAY;cACZ,kBAAgB;;cAGhB,qBAAmB;cAEnB,cAAY;cACZ,eAAa;;cAGb,uBAAqB;cACrB,cAAY;;cAGZ,YAAU;cACV,sBAAoB;;cAGpB,YAAU;;cAGV,gBAAc;;cAGd,YAAU;;cAGV,WAAS;cACT,yBAAuB;cAEvB,kBAAgB;;cAGhB,sBAAoB;cAEpB,kBAAgB;cAEhB,gBAAc;cACd,oBAAkB;cAClB,6BAA2B;;cAI3B,oBAAkB;;cAIlB,iBAAe;;cAGf,0BAAwB;cACxB,iBAAe;cACf,6BAA2B;;cAG3B,YAAU;cAEV,kBAAgB;cAChB,oBAAkB;cAClB,kBAAgB;cAChB,mBAAiB;;cAGjB,aAAW;;cAGX,yBAAuB;cAEvB,mBAAiB;cACjB,kBAAgB;;cAGhB,0BAAwB;;cAGxB,OAAK;cACL,wBAAsB;cACtB,yBAAuB;;cAGvB,mBAAiB;cACjB;cACA;;cAGA,gBAAc;cACd,YAAU;cACV,cAAY;;cAIZ,aAAW;KAMZ;cACC,SAAS;cACT,WAAW;;;;;cAUX,YAAS;;;;;cAOT;;cAIA,aAAW;;cAKX,mBAAiB;;cAKjB,eAAa;;cAKb,wBAAsB;cAQtB,yBAAsB,MAAU;cAQhC;cACA;cAEA,8BAA2B,MAAU,aAAW;cAOhD,4BAA0B;cAC1B,8BAA4B;cAG5B,wBAAqB,MAAU,aAAW;cAc1C,qBAAmB;cACnB,uBAAqB;cAErB,oBAAiB,MAAU,aAAW;cAiBtC,gBAAc;cACd,kBAAgB"}
+{"version":3,"file":"constants.d.ts","names":[],"sources":["../../../src/markdown/constants.ts"],"mappings":";;;;;cAQa;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;WAEA;WACA;;WAEA;;WAEA;WACA;WACA;;WAEA;;WAEA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;KAUU,wBAAwB,uBAAuB;;;;cAS9C;;WAEX;;WAEA;;WAEA;;WAEA;;WAEA;;KAGU,wBAAwB,uBAAuB;;cAO9C;;;;;cAUA,4BAA4B;;;;cAuD5B,wBAAwB;;cAcxB;;cAGA;;cAcA,kBAAgB;;cAIhB,aAAW;;cAGX,cAAY;cACZ,kCAAgC;cAChC,oBAAkB;;cAGlB,cAAY;cACZ,kBAAgB;;cAGhB,qBAAmB;cAEnB,cAAY;;cAEZ,mBAAiB;cACjB,eAAa;;cAGb,uBAAqB;cACrB,cAAY;;cAGZ,YAAU;cACV,sBAAoB;;cAGpB,YAAU;;cAGV,gBAAc;;cAGd,YAAU;;cAGV,WAAS;cACT,yBAAuB;cAEvB,kBAAgB;;cAGhB,sBAAoB;cAEpB,kBAAgB;cAEhB,gBAAc;cACd,oBAAkB;cAClB,6BAA2B;;cAI3B,oBAAkB;;cAIlB,iBAAe;;cAGf,0BAAwB;cACxB,iBAAe;cACf,6BAA2B;;cAG3B,YAAU;cAEV,kBAAgB;cAChB,oBAAkB;cAClB,kBAAgB;cAChB,mBAAiB;;cAGjB,aAAW;;cAGX,yBAAuB;cAEvB,mBAAiB;cACjB,kBAAgB;;cAGhB,0BAAwB;;cAGxB,OAAK;cACL,wBAAsB;cACtB,yBAAuB;;cAGvB,mBAAiB;cACjB;cACA;;cAGA,gBAAc;cACd,YAAU;cACV,cAAY;;cAIZ,aAAW;KAMZ;cACC,SAAS;cACT,WAAW;;;;;cAUX,YAAS;;;;;cAOT;;cAIA,aAAW;;cAKX,mBAAiB;;cAKjB,eAAa;;cAKb,wBAAsB;cAQtB,yBAAsB,MAAU;cAQhC;cACA;cAEA,8BAA2B,MAAU,aAAW;cAOhD,4BAA0B;cAC1B,8BAA4B;cAG5B,wBAAqB,MAAU,aAAW;cAc1C,qBAAmB;cACnB,uBAAqB;cAErB,oBAAiB,MAAU,aAAW;cAiBtC,gBAAc;cACd,kBAAgB"}

package/dist/types/markdown/index.d.ts

@@ -5,8 +5,8 @@ import { MarkdownValidationResult, validateMarkdown } from "../transpiler/markdo
 import "../transpiler/markdown/index.js";
 import { BlockQuoteNode, BoldTextNode, BreakLineNode, BreakThematicNode, CodeBlockNode, CodeFencedNode, CodeInlineNode, CompileOptions, ComponentOverrides, CustomComponentNode, ElementType, EscapedTextNode, FootnoteNode, FootnoteReferenceNode, GFMTaskNode, HTMLCommentNode, HTMLNode, HTMLSelfClosingNode, HTMLTag, HeadingNode, HeadingSetextNode, ImageNode, ItalicTextNode, LinkAngleBraceNode, LinkBareURLNode, LinkNode, MarkdownContext, MarkdownOptions, MarkdownRuntime, MarkedTextNode, NestedParser, NewlineNode, OrderedListNode, ParagraphNode, ParseState, Parser, ParserResult, ReferenceImageNode, ReferenceLinkNode, ReferenceNode, RenderRuleHook, Rule, RuleOutput, Rules, StrikethroughTextNode, TableNode, TableSeparatorNode, TextNode, UnorderedListNode } from "./types.js";
 import { MarkdownReferences, ParsedMarkdown, compile, compileWithOptions, createCompiler, parseMarkdown, renderMarkdownAst } from "./compiler.js";
-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, ListType, 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, PriorityValue, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleType, RuleTypeValue, 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 "./constants.js";
+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, ListType, 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, PriorityValue, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleType, RuleTypeValue, 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 "./constants.js";
 import { parserFor } from "./parser.js";
 import { createRenderer, renderFor } from "./renderer.js";
 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 "./utils.js";
-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, type BlockQuoteNode, type BoldTextNode, type BreakLineNode, type BreakThematicNode, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_R, type CodeBlockNode, type CodeFencedNode, type CodeInlineNode, type CompileOptions, type ComponentOverrides, type CustomComponentNode, DO_NOT_PROCESS_HTML_ELEMENTS, DURATION_DELAY_TRIGGER, type ElementType, type EscapedTextNode, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, type FootnoteNode, type FootnoteReferenceNode, type GFMTaskNode, GFM_TASK_R, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, type HTMLCommentNode, type HTMLNode, type HTMLSelfClosingNode, type HTMLTag, 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, type HeadingNode, type HeadingSetextNode, INLINE_SKIP_R, INTERPOLATION_R, type ImageNode, type ItalicTextNode, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, LOOKAHEAD, type LinkAngleBraceNode, type LinkBareURLNode, type LinkNode, ListType, MarkdownContent, MarkdownContentConstructor, type MarkdownContext, type MarkdownOptions, MarkdownReferences, type MarkdownRuntime, type HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, type MarkedTextNode, NAMED_CODES_TO_UNICODE, NP_TABLE_R, type NestedParser, type NewlineNode, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, type OrderedListNode, PARAGRAPH_R, type ParagraphNode, type ParseState, ParsedMarkdown, type Parser, type ParserResult, Priority, PriorityValue, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, type ReferenceImageNode, type ReferenceLinkNode, type ReferenceNode, type RenderRuleHook, type Rule, type RuleOutput, RuleType, RuleTypeValue, type Rules, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, type StrikethroughTextNode, 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, type TableNode, type TableSeparatorNode, type TextNode, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, type UnorderedListNode, allowInline, anyScopeRegex, attributeValueToNodePropValue, blockRegex, captureNothing, compile, compileWithOptions, createCompiler, createRenderer, cx, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex, get, getMarkdownMetadata, inlineRegex, markdown as md, normalizeAttributeKey, normalizeWhitespace, parseBlock, parseCaptureInline, parseInline, parseMarkdown, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, parserFor, qualifies, renderFor, renderMarkdownAst, renderNothing, sanitizer, simpleInlineRegex, slugify, some, startsWith, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, unquote, validateMarkdown };
+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, type BlockQuoteNode, type BoldTextNode, type BreakLineNode, type BreakThematicNode, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_R, type CodeBlockNode, type CodeFencedNode, type CodeInlineNode, type CompileOptions, type ComponentOverrides, type CustomComponentNode, DO_NOT_PROCESS_HTML_ELEMENTS, DURATION_DELAY_TRIGGER, type ElementType, type EscapedTextNode, FENCE_DELIMITER_R, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, type FootnoteNode, type FootnoteReferenceNode, type GFMTaskNode, GFM_TASK_R, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, type HTMLCommentNode, type HTMLNode, type HTMLSelfClosingNode, type HTMLTag, 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, type HeadingNode, type HeadingSetextNode, INLINE_SKIP_R, INTERPOLATION_R, type ImageNode, type ItalicTextNode, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, LOOKAHEAD, type LinkAngleBraceNode, type LinkBareURLNode, type LinkNode, ListType, MarkdownContent, MarkdownContentConstructor, type MarkdownContext, type MarkdownOptions, MarkdownReferences, type MarkdownRuntime, type HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, type MarkedTextNode, NAMED_CODES_TO_UNICODE, NP_TABLE_R, type NestedParser, type NewlineNode, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, type OrderedListNode, PARAGRAPH_R, type ParagraphNode, type ParseState, ParsedMarkdown, type Parser, type ParserResult, Priority, PriorityValue, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, type ReferenceImageNode, type ReferenceLinkNode, type ReferenceNode, type RenderRuleHook, type Rule, type RuleOutput, RuleType, RuleTypeValue, type Rules, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, type StrikethroughTextNode, 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, type TableNode, type TableSeparatorNode, type TextNode, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, type UnorderedListNode, allowInline, anyScopeRegex, attributeValueToNodePropValue, blockRegex, captureNothing, compile, compileWithOptions, createCompiler, createRenderer, cx, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex, get, getMarkdownMetadata, inlineRegex, markdown as md, normalizeAttributeKey, normalizeWhitespace, parseBlock, parseCaptureInline, parseInline, parseMarkdown, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, parserFor, qualifies, renderFor, renderMarkdownAst, renderNothing, sanitizer, simpleInlineRegex, slugify, some, startsWith, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, unquote, validateMarkdown };

package/dist/types/markdown/utils.d.ts

@@ -41,6 +41,12 @@ declare const normalizeWhitespace: (source: string) => string;
 /**
  * Safely remove a uniform leading indentation from lines, but do NOT touch
  * the content inside fenced code blocks (``` or ~~~).
+ *
+ * Inside a fenced block the structural indentation is irrelevant: what matters
+ * is the indentation of the opening fence itself, which is the only amount
+ * CommonMark strips from the code lines. A block nested in an indented HTML
+ * element but written with its fence at column 0 therefore keeps its code
+ * verbatim, instead of losing the first level of indentation.
  */
 declare const trimLeadingWhitespaceOutsideFences: (text: string, whitespace: string) => string;
 /**

package/dist/types/markdown/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../src/markdown/utils.ts"],"mappings":";;;;;cAwBa,UAAO;;;;cAWP,aAAU,aAAe;;;;cAOzB,UAAO;;;;cAiBP,iBAAc;;;;cAMd,QAAE;;;;cAKF,MAAG,UAAY,cAAc;;;;;cAsB7B,UAAO;;;;;cAyBP,YAAS;;;;cAgCT,sBAAmB;;;;;cAsBnB,qCAAkC,cACjC;;;;cA8BD,wBAAqB;KAY7B,cAAc,aAAa;;;;cAKnB,sBAAmB,wBAA0B;;;;cAwE7C,gCAA6B,aAC7B,aACA,eACE,gBAEX,eACA,aACA;;;;cA0CS,yBAAsB;;;;cAiBtB,kBAAe;;;;cAUf,gBAAa,gBACV,OACP,cAAY,OACZ,YAAU,yBAEhB;;;;cAsDU,kBAAe,gBACZ,OACP,cAAY,OACZ,eACN;;;;cAyBU,YAAS,gBACN,OACP,YAAU,SACR,YAAY;;;;cAmBV,cAAe,cAAc,qBAAmB,IACvD,MACH;EAAM;;;;;cAQI,cAAW,OAAW,aAAM,gBACZ,OAAS,eAAa;EATlC;;;;;cAoBJ,oBAAiB,OAAW,aAAM,gBAClB,OAAS,eAAa;EArBlC;;;;;cAgCJ,aAAU,OACb,YAAM,gBACC,OAAS,eAAa;;;;cAW1B,gBAAa,IACpB,WAAW,gBAAgB,OAAO,eAAe,+BAAwB,gBAElD,OAAS,eAAa;EAhDlC;;;;;cA0DJ,cAAW,OACf,cAAY,kBACH,OACT,eACN;;;;cAuBU,oBAAiB,OACrB,cAAY,kBACH,OACT,eACN;;;;cAwBU,aAAU,OACd,cAAY,kBACH,QACT,eACN;;;;cA4BU,qBAAkB,SACpB,kBAAgB,OAClB,cAAY,OACZ;EACJ,UAAU;;;;;cASF,sBAAqB;;;;cAKrB;;;;cAKA,OAAI,SAAa,UAAQ"}
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../src/markdown/utils.ts"],"mappings":";;;;;cAyBa,UAAO;;;;cAWP,aAAU,aAAe;;;;cAOzB,UAAO;;;;cAiBP,iBAAc;;;;cAMd,QAAE;;;;cAKF,MAAG,UAAY,cAAc;;;;;cAsB7B,UAAO;;;;;cAyBP,YAAS;;;;cAgCT,sBAAmB;;;;;;;;;;;cA4BnB,qCAAkC,cACjC;;;;cAgDD,wBAAqB;KAY7B,cAAc,aAAa;;;;cAKnB,sBAAmB,wBAA0B;;;;cAwE7C,gCAA6B,aAC7B,aACA,eACE,gBAEX,eACA,aACA;;;;cA0CS,yBAAsB;;;;cAiBtB,kBAAe;;;;cAUf,gBAAa,gBACV,OACP,cAAY,OACZ,YAAU,yBAEhB;;;;cAsDU,kBAAe,gBACZ,OACP,cAAY,OACZ,eACN;;;;cAyBU,YAAS,gBACN,OACP,YAAU,SACR,YAAY;;;;cAmBV,cAAe,cAAc,qBAAmB,IACvD,MACH;EAAM;;;;;cAQI,cAAW,OAAW,aAAM,gBACZ,OAAS,eAAa;EATlC;;;;;cAoBJ,oBAAiB,OAAW,aAAM,gBAClB,OAAS,eAAa;EArBlC;;;;;cAgCJ,aAAU,OACb,YAAM,gBACC,OAAS,eAAa;;;;cAW1B,gBAAa,IACpB,WAAW,gBAAgB,OAAO,eAAe,+BAAwB,gBAElD,OAAS,eAAa;EAhDlC;;;;;cA0DJ,cAAW,OACf,cAAY,kBACH,OACT,eACN;;;;cAuBU,oBAAiB,OACrB,cAAY,kBACH,OACT,eACN;;;;cAwBU,aAAU,OACd,cAAY,kBACH,QACT,eACN;;;;cA4BU,qBAAkB,SACpB,kBAAgB,OAClB,cAAY,OACZ;EACJ,UAAU;;;;;cASF,sBAAqB;;;;cAKrB;;;;cAKA,OAAI,SAAa,UAAQ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/core",
-  "version": "9.3.2",
+  "version": "9.3.3",
   "private": false,
   "description": "Includes core Intlayer functions like translation, dictionary, and utility functions shared across multiple packages.",
   "keywords": [
@@ -173,10 +173,10 @@
   },
   "dependencies": {
     "@intlayer/api": "9.3.2",
-    "@intlayer/config": "9.3.2",
-    "@intlayer/dictionaries-entry": "9.3.2",
-    "@intlayer/types": "9.3.2",
-    "@intlayer/unmerged-dictionaries-entry": "9.3.2",
+    "@intlayer/config": "9.3.3",
+    "@intlayer/dictionaries-entry": "9.3.3",
+    "@intlayer/types": "9.3.3",
+    "@intlayer/unmerged-dictionaries-entry": "9.3.3",
     "defu": "6.1.7"
   },
   "devDependencies": {
@@ -187,7 +187,7 @@
     "rimraf": "6.1.3",
     "tsdown": "0.22.14",
     "typescript": "7.0.2",
-    "vitest": "4.1.10"
+    "vitest": "4.1.11"
   },
   "engines": {
     "node": ">=14.18"