@intlayer/core 9.0.0-canary.2 → 9.0.0-canary.20

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

@@ -0,0 +1,65 @@
+import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
+//#region src/localization/comparePaths.d.ts
+/**
+ * Normalizes a URL or pathname into a canonical, locale-agnostic pathname so
+ * that two paths pointing to the same page compare equal — useful for
+ * highlighting the active navigation link.
+ *
+ * The normalization:
+ * - strips the locale segment (reusing {@link getPathWithoutLocale})
+ * - strips the protocol/host so absolute and relative inputs compare equally
+ * - drops the query string and hash
+ * - ensures a single leading slash
+ * - removes any trailing slash (except for the root path)
+ * - falls back to `'/'` for empty values
+ *
+ * Example:
+ *
+ * ```ts
+ * normalizePath('/ru/path')                    // '/path'
+ * normalizePath('/ru/path/')                   // '/path'
+ * normalizePath('ru/path')                     // '/path'
+ * normalizePath('/ru/')                        // '/'
+ * normalizePath('/ru')                         // '/'
+ * normalizePath('')                            // '/'
+ * normalizePath('https://example.com/ru/path') // '/path'
+ * ```
+ *
+ * @param inputUrl - The URL string or pathname to normalize.
+ * @param locales - Optional array of supported locales. Defaults to the
+ *   configured locales.
+ * @returns The normalized, locale-agnostic pathname.
+ */
+declare const normalizePath: <const L extends LocalesValues = DeclaredLocales>(inputUrl: string, locales?: L[]) => string;
+/**
+ * Compares two URLs or pathnames for equality, ignoring locale segment,
+ * protocol/host, query string, hash and trailing slashes.
+ *
+ * Both inputs are normalized through {@link normalizePath} before comparison,
+ * making this ideal for matching the current pathname against a navigation
+ * link's `href`.
+ *
+ * Example:
+ *
+ * ```ts
+ * comparePaths('/ru/path', '/path')   // true
+ * comparePaths('/ru/path/', '/path')  // true
+ * comparePaths('/ru/path', '/path/')  // true
+ * comparePaths('/ru/', '/')           // true
+ * comparePaths('/ru', '/')            // true
+ * comparePaths('ru/path', '/path')    // true
+ * comparePaths('', '/')               // true
+ * comparePaths('/ru', '')             // true
+ * comparePaths('/ru/path', '/other')  // false
+ * ```
+ *
+ * @param pathname - The first URL string or pathname to compare.
+ * @param href - The second URL string or pathname to compare.
+ * @param locales - Optional array of supported locales. Defaults to the
+ *   configured locales.
+ * @returns `true` when both inputs resolve to the same locale-agnostic path.
+ */
+declare const comparePaths: <const L extends LocalesValues = DeclaredLocales>(pathname: string, href: string, locales?: L[]) => boolean;
+//#endregion
+export { comparePaths, normalizePath };
+//# sourceMappingURL=comparePaths.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"comparePaths.d.ts","names":[],"sources":["../../../src/localization/comparePaths.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqCa,sBAAuB,UAAU,gBAAgB,iBAAe,kBAC3D,UACN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+CC,qBAAsB,UAAU,gBAAgB,iBAAe,kBAC1D,cACJ,UACF"}

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

@@ -0,0 +1,69 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+import { Locale } from "@intlayer/types/allLocales";
+import { RoutingConfig } from "@intlayer/types/config";
+//#region src/localization/domainUtils.d.ts
+/**
+ * The locale → domain map configured under `routing.domains`
+ * (e.g. `{ en: 'intlayer.org', zh: 'intlayer.cn' }`).
+ */
+type LocaleDomainMap = RoutingConfig['domains'];
+/**
+ * Strips the protocol from a domain string and returns only the hostname.
+ *
+ * Example:
+ *
+ * ```ts
+ * getDomainHostname('https://intlayer.cn') // 'intlayer.cn'
+ * getDomainHostname('intlayer.cn')         // 'intlayer.cn'
+ * ```
+ *
+ * @param domain - A domain value from `routing.domains`, with or without protocol.
+ * @returns The bare hostname.
+ */
+declare const getDomainHostname: (domain: string) => string;
+/**
+ * Returns the absolute origin for a domain value, prepending `https://`
+ * when no protocol is present.
+ *
+ * Example:
+ *
+ * ```ts
+ * getDomainOrigin('intlayer.cn')        // 'https://intlayer.cn'
+ * getDomainOrigin('http://intlayer.cn') // 'http://intlayer.cn'
+ * ```
+ *
+ * @param domain - A domain value from `routing.domains`, with or without protocol.
+ * @returns The origin usable as a URL base.
+ */
+declare const getDomainOrigin: (domain: string) => string;
+/**
+ * Returns the locale exclusively mapped to a given hostname via `routing.domains`,
+ * or `undefined` when zero or more than one locale share that hostname.
+ *
+ * Example: with `domains = { zh: 'intlayer.cn', en: 'intlayer.org', fr: 'intlayer.org' }`
+ *
+ * ```ts
+ * getLocaleFromDomain('intlayer.cn', domains)  // 'zh'
+ * getLocaleFromDomain('intlayer.org', domains) // undefined (en and fr share it)
+ * getLocaleFromDomain('example.com', domains)  // undefined (not mapped)
+ * ```
+ *
+ * @param hostname - The bare hostname of the incoming request.
+ * @param domains - The configured locale → domain map.
+ * @returns The exclusively mapped locale, or `undefined`.
+ */
+declare const getLocaleFromDomain: (hostname: string, domains: LocaleDomainMap) => Locale | undefined;
+/**
+ * Checks whether a locale is the only locale mapped to its configured domain.
+ * When true, the domain alone identifies the locale and no URL prefix is needed.
+ * Hostnames are compared after protocol stripping, so
+ * `{ en: 'https://intlayer.org', fr: 'intlayer.org' }` counts as a shared domain.
+ *
+ * @param locale - The locale to check.
+ * @param domains - The configured locale → domain map.
+ * @returns `true` when the locale has a domain shared with no other locale.
+ */
+declare const isLocaleExclusiveOnDomain: (locale: LocalesValues, domains: LocaleDomainMap) => boolean;
+//#endregion
+export { LocaleDomainMap, getDomainHostname, getDomainOrigin, getLocaleFromDomain, isLocaleExclusiveOnDomain };
+//# sourceMappingURL=domainUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"domainUtils.d.ts","names":[],"sources":["../../../src/localization/domainUtils.ts"],"mappings":";;;;;;;;KAQY,kBAAkB;;;;;;;;;;;;;;cAejB,oBAAiB;;;;;;;;;;;;;;;cAsBjB,kBAAe;;;;;;;;;;;;;;;;;cAmBf,sBAAmB,kBACd,SACP,oBACR;;;;;;;;;;;cAuBU,4BAAyB,QAC5B,eAAa,SACZ"}

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

@@ -1,15 +1,17 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { RoutingConfig } from "@intlayer/types/config";
-
 //#region src/localization/generateSitemap.d.ts
 type SitemapUrlEntry = {
-  /** The canonical path, e.g. '/dashboard' */path: string;
+  /** The canonical path, e.g. '/dashboard' */
+  path: string;
   changefreq?: string;
-  priority?: number; /** ISO date string, e.g. '2024-01-15' */
+  priority?: number;
+  /** ISO date string, e.g. '2024-01-15' */
   lastmod?: string;
 };
 type GenerateSitemapOptions = {
-  /** Base site URL without trailing slash, e.g. 'https://example.com' */siteUrl: string;
+  /** Base site URL without trailing slash, e.g. 'https://example.com' */
+  siteUrl: string;
   /**
    * Whether to include xhtml:link alternate tags for multilingual support.
    *

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

@@ -1 +1 @@
-{"version":3,"file":"generateSitemap.d.ts","names":[],"sources":["../../../src/localization/generateSitemap.ts"],"mappings":";;;;KAKY,eAAA;8CAEV,IAAA;EACA,UAAA;EACA,QAAA,WAJyB;EAMzB,OAAA;AAAA;AAAA,KAGU,sBAAA;EAHV,uEAKA,OAAA;EALO;AAGT;;;;;;;;;;;EAeE,UAAA;EACA,OAAA,GAAU,aAAA;EACV,aAAA,GAAgB,aAAA;EAChB,IAAA,GAAO,aAAA;EACP,OAAA,GAAU,aAAA;AAAA;;;;;AA6CZ;;;;;;;;;;AA2EA;;;;;;;;;;;;;;;;cA3Ea,kBAAA,GACX,IAAA,UACA,OAAA,EAAS,eAAA,GAAkB,sBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyEhB,eAAA,GACX,OAAA,EAAS,eAAA,IACT,OAAA,EAAS,sBAAA"}
+{"version":3,"file":"generateSitemap.d.ts","names":[],"sources":["../../../src/localization/generateSitemap.ts"],"mappings":";;;KAKY;;EAEV;EACA;EACA;;EAEA;;KAGU;;EAEV;;;;;;;;;;;;;EAaA;EACA,UAAU;EACV,gBAAgB;EAChB,OAAO;EACP,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6CC,qBAAkB,cACjB,SACH,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAyEhB,kBAAe,SACjB,mBAAiB,SACjB"}

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

@@ -1,5 +1,4 @@
 import { Locale } from "@intlayer/types/allLocales";
-
 //#region src/localization/getBrowserLocale.d.ts
 declare enum LanguageDetector {
   Querystring = "querystring",

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

@@ -1 +1 @@
-{"version":3,"file":"getBrowserLocale.d.ts","names":[],"sources":["../../../src/localization/getBrowserLocale.tsx"],"mappings":";;;aAMY,gBAAA;EACV,WAAA;EACA,OAAA;EACA,SAAA;EACA,OAAA;AAAA;AAAA,KAIG,uBAAA;EACH,KAAA,GAAQ,gBAAA;EACR,iBAAA;EACA,OAAA,GAAU,WAAA;AAAA;;AANX;;;;;;;;;;;AAgKD;;;cAAa,gBAAA,GACX,WAAA,GAAa,uBAAA,iBACZ,MAAA"}
+{"version":3,"file":"getBrowserLocale.d.ts","names":[],"sources":["../../../src/localization/getBrowserLocale.tsx"],"mappings":";;aAMY;EACV;EACA;EACA;EACA;;KAIG;EACH,QAAQ;EACR;EACA,UAAU;;;;;;;;;;;;;;;;;cA4JC,mBAAgB,cACd,wCACZ"}

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

@@ -1,5 +1,4 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-
 //#region src/localization/getHTMLTextDir.d.ts
 type Dir = 'ltr' | 'rtl' | 'auto';
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"getHTMLTextDir.d.ts","names":[],"sources":["../../../src/localization/getHTMLTextDir.ts"],"mappings":";;;KAEK,GAAA;;AAFoE;;;;;AAiBzE;;;;;;;cAAa,cAAA,GAAkB,MAAA,GAAS,aAAA,KAAgB,GAAA"}
+{"version":3,"file":"getHTMLTextDir.d.ts","names":[],"sources":["../../../src/localization/getHTMLTextDir.ts"],"mappings":";;KAEK;;;;;;;;;;;;;;cAeQ,iBAAc,SAAa,kBAAgB"}

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

@@ -1,5 +1,4 @@
 import { Locale } from "@intlayer/types/allLocales";
-
 //#region src/localization/getLocale.d.ts
 type RequestContext = {
   getHeader?: (name: string) => string | null | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"getLocale.d.ts","names":[],"sources":["../../../src/localization/getLocale.ts"],"mappings":";;;KAOY,cAAA;EACV,SAAA,IAAa,IAAA;EACb,SAAA,IAAa,IAAA;AAAA;AAAA,cAGF,SAAA,GAAmB,GAAA,GAAK,cAAA,KAAsB,OAAA,CAAQ,MAAA"}
+{"version":3,"file":"getLocale.d.ts","names":[],"sources":["../../../src/localization/getLocale.ts"],"mappings":";;KAOY;EACV,aAAa;EACb,aAAa;;cAGF,YAAS,MAAe,mBAAsB,QAAQ"}

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

@@ -1,6 +1,5 @@
 import { RoutingOptions } from "./getPrefix.js";
 import { Locale } from "@intlayer/types/allLocales";
-
 //#region src/localization/getLocaleFromPath.d.ts
 /**
  * Extracts the locale segment from the given URL or pathname based on the routing mode.

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

@@ -1 +1 @@
-{"version":3,"file":"getLocaleFromPath.d.ts","names":[],"sources":["../../../src/localization/getLocaleFromPath.ts"],"mappings":";;;;;;AAgBA;;;;;;;;;;cAAa,iBAAA,GACX,QAAA,WACA,OAAA,GAAU,cAAA,KACT,MAAA"}
+{"version":3,"file":"getLocaleFromPath.d.ts","names":[],"sources":["../../../src/localization/getLocaleFromPath.ts"],"mappings":";;;;;;;;;;;;;;;cAgBa,oBAAiB,mBACZ,UACN,mBACT"}

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

@@ -1,5 +1,4 @@
 import { GetLocaleLang, LocalesValues } from "@intlayer/types/module_augmentation";
-
 //#region src/localization/getLocaleLang.d.ts
 /**
  * Returns the language code of the given locale for locales including the country code.

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

@@ -1 +1 @@
-{"version":3,"file":"getLocaleLang.d.ts","names":[],"sources":["../../../src/localization/getLocaleLang.ts"],"mappings":";;;;;AAkBA;;;;;;;;;;;cAAa,aAAA,mBAAiC,aAAA,EAC5C,MAAA,GAAS,CAAA,KACR,aAAA,CAAc,CAAA"}
+{"version":3,"file":"getLocaleLang.d.ts","names":[],"sources":["../../../src/localization/getLocaleLang.ts"],"mappings":";;;;;;;;;;;;;;;cAkBa,sBAAuB,UAAU,eAAa,SAChD,MACR,cAAc"}

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

@@ -1,5 +1,4 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-
 //#region src/localization/getLocaleName.d.ts
 declare const getLocaleName: (displayLocale: LocalesValues, targetLocale?: LocalesValues) => string;
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"getLocaleName.d.ts","names":[],"sources":["../../../src/localization/getLocaleName.ts"],"mappings":";;;cAGa,aAAA,GACX,aAAA,EAAe,aAAA,EACf,YAAA,GAAc,aAAA"}
+{"version":3,"file":"getLocaleName.d.ts","names":[],"sources":["../../../src/localization/getLocaleName.ts"],"mappings":";;cAGa,gBAAa,eACT,eAAa,eACd"}

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

@@ -1,6 +1,5 @@
 import { RoutingOptions } from "./getPrefix.js";
 import { LocalesValues, LocalizedUrl, ResolvedDefaultLocale } from "@intlayer/types/module_augmentation";
-
 //#region src/localization/getLocalizedUrl.d.ts
 /**
  * Generate URL by prefixing the given URL with the referenced locale or adding search parameters

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

@@ -1 +1 @@
-{"version":3,"file":"getLocalizedUrl.d.ts","names":[],"sources":["../../../src/localization/getLocalizedUrl.ts"],"mappings":";;;;;AAgFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,eAAA,2CAEK,aAAA,GAAgB,qBAAA,EAEhC,GAAA,EAAK,CAAA,EACL,aAAA,GAAe,CAAA,EACf,OAAA,GAAS,cAAA,KACR,YAAA,CAAa,CAAA,EAAG,CAAA"}
+{"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"}

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

@@ -1,6 +1,5 @@
 import { RoutingOptions } from "./getPrefix.js";
 import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
-
 //#region src/localization/getMultilingualUrls.d.ts
 /**
  * Generates multilingual URLs by prefixing the given URL with each supported locale

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

@@ -1 +1 @@
-{"version":3,"file":"getMultilingualUrls.d.ts","names":[],"sources":["../../../src/localization/getMultilingualUrls.ts"],"mappings":";;;;;;AAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,mBAAA,GACX,GAAA,UACA,OAAA,GAAS,cAAA,KACR,mBAAA"}
+{"version":3,"file":"getMultilingualUrls.d.ts","names":[],"sources":["../../../src/localization/getMultilingualUrls.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsCa,sBAAmB,aACnB,UACF,mBACR"}

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

@@ -1,5 +1,4 @@
 import { DeclaredLocales, LocalesValues, PathWithoutLocale } from "@intlayer/types/module_augmentation";
-
 //#region src/localization/getPathWithoutLocale.d.ts
 /**
  * Removes the locale segment from the given URL or pathname if present.

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

@@ -1 +1 @@
-{"version":3,"file":"getPathWithoutLocale.d.ts","names":[],"sources":["../../../src/localization/getPathWithoutLocale.ts"],"mappings":";;;;;AA0DA;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,oBAAA,2CAEK,aAAA,GAAgB,eAAA,EAEhC,QAAA,EAAU,CAAA,EACV,OAAA,GAAS,CAAA,OACR,iBAAA,CAAkB,CAAA,EAAG,CAAA"}
+{"version":3,"file":"getPathWithoutLocale.d.ts","names":[],"sources":["../../../src/localization/getPathWithoutLocale.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0Da,6BACL,wBACA,UAAU,gBAAgB,iBAAe,UAErC,GAAC,UACF,QACR,kBAAkB,GAAG"}

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

@@ -1,7 +1,6 @@
 import { DeclaredLocales, LocalesValues, ResolvedDefaultLocale, ResolvedRoutingMode } from "@intlayer/types/module_augmentation";
 import { Locale } from "@intlayer/types/allLocales";
 import { RoutingConfig } from "@intlayer/types/config";
-
 //#region src/localization/getPrefix.d.ts
 /**
  * Shared routing options used across all URL localization functions.
@@ -29,9 +28,9 @@ type RoutingOptions = {
  * Resolves routing configuration by merging provided options with configuration defaults.
  * Single source of truth for default routing config resolution across all localization functions.
  */
-declare const resolveRoutingConfig: (options?: RoutingOptions) => Omit<RoutingOptions, "defaultLocale" | "mode" | "locales"> & {
+declare const resolveRoutingConfig: (options?: RoutingOptions) => Omit<RoutingOptions, 'defaultLocale' | 'mode' | 'locales'> & {
   defaultLocale: LocalesValues;
-  mode: RoutingConfig["mode"];
+  mode: RoutingConfig['mode'];
   locales: LocalesValues[];
 };
 type GetPrefixOptions = {

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

@@ -1 +1 @@
-{"version":3,"file":"getPrefix.d.ts","names":[],"sources":["../../../src/localization/getPrefix.ts"],"mappings":";;;;;;;AAuBA;KAAY,cAAA;EACV,OAAA,GAAU,aAAA;EACV,aAAA,GAAgB,aAAA;EAChB,IAAA,GAAO,aAAA;EACP,OAAA,GAAU,aAAA;EACV,OAAA,GAAU,aAAA;EAAA;;;;;;;;;;;EAYV,aAAA;AAAA;;;;AAOF;cAAa,oBAAA,GACX,OAAA,GAAS,cAAA,KACR,IAAA,CAAK,cAAA;EACN,aAAA,EAAe,aAAA;EACf,IAAA,EAAM,aAAA;EACN,OAAA,EAAS,aAAA;AAAA;AAAA,KAUC,gBAAA;EACV,aAAA,GAAgB,aAAA;EAChB,IAAA,GAAO,aAAA;AAAA;AAAA,KAGG,eAAA;EAnBD;;;;EAwBT,MAAA;EAtBe;;;EA0Bf,YAAA,EAAc,MAAA;AAAA;;;AAdhB;;;;;;;KA0BY,uBAAA,WACA,aAAA,oCACY,mBAAA,kBACN,aAAA,GAAgB,qBAAA,IAC9B,CAAA,oCACkB,CAAA,IAChB,uBAAA,CAAwB,eAAA,EAAiB,IAAA,EAAM,OAAA,sBAC7B,IAAA,IAChB,eAAA,GACA,IAAA;EACI,MAAA,KAAW,CAAA;EAAM,YAAA,EAAc,CAAA;AAAA,IACjC,IAAA,+BACE,CAAA,SAAU,OAAA;EACN,MAAA;EAAY,YAAA;AAAA;EACZ,MAAA,KAAW,CAAA;EAAM,YAAA,EAAc,CAAA;AAAA;EACjC,MAAA;EAAY,YAAA;AAAA;EACpB,MAAA;EAAY,YAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCL,SAAA,mBAA6B,aAAA,cACxC,MAAA,EAAQ,CAAA,EACR,OAAA,GAAS,cAAA,KACR,uBAAA,CAAwB,CAAA"}
+{"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"}

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

@@ -1,3 +1,5 @@
+import { comparePaths, normalizePath } from "./comparePaths.js";
+import { LocaleDomainMap, getDomainHostname, getDomainOrigin, getLocaleFromDomain, isLocaleExclusiveOnDomain } from "./domainUtils.js";
 import { GenerateSitemapOptions, SitemapUrlEntry, generateSitemap, generateSitemapUrl } from "./generateSitemap.js";
 import { getBrowserLocale } from "./getBrowserLocale.js";
 import { getHTMLTextDir } from "./getHTMLTextDir.js";
@@ -14,4 +16,4 @@ import { localeFlatMap, localeMap, localeRecord } from "./localeMapper.js";
 import { localeResolver } from "./localeResolver.js";
 import { LocalizedPathResult, getCanonicalPath, getInternalPath, getLocalizedPath, getRewritePath, getRewriteRules } from "./rewriteUtils.js";
 import { validatePrefix } from "./validatePrefix.js";
-export { type GenerateSitemapOptions, type GetPrefixOptions, type GetPrefixResult, type LocalizedPathResult, type SitemapUrlEntry, generateSitemap, generateSitemapUrl, getBrowserLocale, getCanonicalPath, getHTMLTextDir, getInternalPath, getLocale, getLocaleFromPath, getLocaleLang, getLocaleName, getLocalizedPath, getLocalizedUrl, getMultilingualUrls, getPathWithoutLocale, getPrefix, getRewritePath, getRewriteRules, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, validatePrefix };
+export { type GenerateSitemapOptions, type GetPrefixOptions, type GetPrefixResult, type LocaleDomainMap, type LocalizedPathResult, type SitemapUrlEntry, comparePaths, generateSitemap, generateSitemapUrl, getBrowserLocale, getCanonicalPath, getDomainHostname, getDomainOrigin, getHTMLTextDir, getInternalPath, getLocale, getLocaleFromDomain, getLocaleFromPath, getLocaleLang, getLocaleName, getLocalizedPath, getLocalizedUrl, getMultilingualUrls, getPathWithoutLocale, getPrefix, getRewritePath, getRewriteRules, isLocaleExclusiveOnDomain, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, normalizePath, validatePrefix };

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

@@ -1,5 +1,4 @@
 import { Locale } from "@intlayer/types/allLocales";
-
 //#region src/localization/localeDetector.d.ts
 /**
  * Derives the list of preferred languages based on the Accept-Language header

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

@@ -1 +1 @@
-{"version":3,"file":"localeDetector.d.ts","names":[],"sources":["../../../src/localization/localeDetector.ts"],"mappings":";;;;;AA+MA;;cAAa,qBAAA,GACX,YAAA,sBACA,kBAAA;;;AA+BF;;;;cAAa,cAAA,GACX,OAAA,EAAS,MAAA,8BACT,gBAAA,GAAmB,MAAA,IACnB,aAAA,GAAgB,MAAA,KACf,MAAA"}
+{"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"}

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

@@ -1,6 +1,5 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { Locale } from "@intlayer/types/allLocales";
-
 //#region src/localization/localeMapper.d.ts
 type LocaleData = {
   locale: Locale;
@@ -35,7 +34,7 @@ type LocaleData = {
  * @param mapper - The mapper function that returns an object
  * @returns An array of objects
  */
-declare const localeMap: <T>(mapper: (locale: LocaleData) => T, locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: "prefix-no-default" | "prefix-all" | "no-prefix" | "search-params") => T[];
+declare const localeMap: <T>(mapper: (locale: LocaleData) => T, locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: 'prefix-no-default' | 'prefix-all' | 'no-prefix' | 'search-params') => T[];
 /**
  * Flatten the locale map into a single array of objects
  *
@@ -62,7 +61,7 @@ declare const localeMap: <T>(mapper: (locale: LocaleData) => T, locales?: Locale
  * @param mapper - The mapper function that returns an array of objects
  * @returns An array of objects
  */
-declare const localeFlatMap: <T>(mapper: (locale: LocaleData) => T[], locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: "prefix-no-default" | "prefix-all" | "no-prefix" | "search-params") => T[];
+declare const localeFlatMap: <T>(mapper: (locale: LocaleData) => T[], locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: 'prefix-no-default' | 'prefix-all' | 'no-prefix' | 'search-params') => T[];
 /**
  * Creates a record object mapping locales to values transformed by the mapper function
  *
@@ -86,7 +85,7 @@ declare const localeFlatMap: <T>(mapper: (locale: LocaleData) => T[], locales?:
  * @param mode - URL routing mode for locale handling (defaults to configured value)
  * @returns Record mapping locale codes to mapped values
  */
-declare const localeRecord: <T>(mapper: (locale: LocaleData) => T, locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: "prefix-no-default" | "prefix-all" | "no-prefix" | "search-params") => Record<LocalesValues, T>;
+declare const localeRecord: <T>(mapper: (locale: LocaleData) => T, locales?: LocalesValues[], defaultLocale?: LocalesValues, mode?: 'prefix-no-default' | 'prefix-all' | 'no-prefix' | 'search-params') => Record<LocalesValues, T>;
 //#endregion
 export { LocaleData, localeFlatMap, localeMap, localeRecord };
 //# sourceMappingURL=localeMapper.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"localeMapper.d.ts","names":[],"sources":["../../../src/localization/localeMapper.ts"],"mappings":";;;;KAMY,UAAA;EACV,MAAA,EAAQ,MAAA;EACR,aAAA,EAAe,MAAA;EACf,SAAA;EACA,OAAA,EAAS,MAAA;EACT,SAAA;AAAA;;;;;;;;;;;;;;AA6BF;;;;;;;;;;;;;cAAa,SAAA,MACX,MAAA,GAAS,MAAA,EAAQ,UAAA,KAAe,CAAA,EAChC,OAAA,GAAS,aAAA,IACT,aAAA,GAAe,aAAA,EAEf,IAAA,0EAKC,CAAA;;;;;;;;;;AAwCH;;;;;;;;;;;;;;;;;cAAa,aAAA,MACX,MAAA,GAAS,MAAA,EAAQ,UAAA,KAAe,CAAA,IAChC,OAAA,GAAS,aAAA,IACT,aAAA,GAAe,aAAA,EAEf,IAAA,0EAKC,CAAA;;;;;;AAqCH;;;;;;;;;;;;;;;;;;cAAa,YAAA,MACX,MAAA,GAAS,MAAA,EAAQ,UAAA,KAAe,CAAA,EAChC,OAAA,GAAS,aAAA,IACT,aAAA,GAAe,aAAA,EAEf,IAAA,0EAKC,MAAA,CAAO,aAAA,EAAe,CAAA"}
+{"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"}

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

@@ -1,6 +1,5 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { Locale } from "@intlayer/types/allLocales";
-
 //#region src/localization/localeResolver.d.ts
 /**
  * Resolves the most specific locale from a user-provided list,

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

@@ -1 +1 @@
-{"version":3,"file":"localeResolver.d.ts","names":[],"sources":["../../../src/localization/localeResolver.ts"],"mappings":";;;;;;AAQA;;cAAa,cAAA,GACX,cAAA,EAAgB,aAAA,GAAgB,aAAA,IAChC,OAAA,GAAS,aAAA,IACT,aAAA,GAAe,aAAA,KACd,MAAA"}
+{"version":3,"file":"localeResolver.d.ts","names":[],"sources":["../../../src/localization/localeResolver.ts"],"mappings":";;;;;;;cAQa,iBAAc,gBACT,gBAAgB,iBAAe,UACtC,iBAAe,gBACT,kBACd"}

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

@@ -1,7 +1,6 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { Locale } from "@intlayer/types/allLocales";
 import { RewriteObject, RewriteRules, RoutingConfig } from "@intlayer/types/config";
-
 //#region src/localization/rewriteUtils.d.ts
 type LocalizedPathResult = {
   path: string;
@@ -10,7 +9,7 @@ type LocalizedPathResult = {
 /**
  * Normalizes legacy Record format or extracts specialized rules from RewriteObject.
  */
-declare const getRewriteRules: (rewrite: RoutingConfig["rewrite"], context?: keyof RewriteObject) => RewriteRules | undefined;
+declare const getRewriteRules: (rewrite: RoutingConfig['rewrite'], context?: keyof RewriteObject) => 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.
@@ -28,7 +27,7 @@ declare const getInternalPath: (canonicalPath: string, locale: Locale) => string
 /**
  * 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: (pathname: string, locale: Locale, rewrite?: RoutingConfig['rewrite']) => string | undefined;
 //#endregion
 export { LocalizedPathResult, getCanonicalPath, getInternalPath, getLocalizedPath, getRewritePath, getRewriteRules };
 //# 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,mBAAA;EACV,IAAA;EACA,WAAA;AAAA;;;;cAMW,eAAA,GACX,OAAA,EAAS,aAAA,aACT,OAAA,SAAe,aAAA,KACd,YAAA;;;;;cA2EU,gBAAA,GACX,aAAA,UACA,MAAA,GAAS,MAAA,EACT,YAAA,GAAe,YAAA;;;;cA2BJ,gBAAA,GACX,aAAA,UACA,MAAA,EAAQ,aAAA,EACR,YAAA,GAAe,YAAA,KACd,mBAAA;;;;;cA6BU,eAAA,GACX,aAAA,UACA,MAAA,EAAQ,MAAA;AAjEV;;;AAAA,cAoFa,cAAA,GACX,QAAA,UACA,MAAA,EAAQ,MAAA,EACR,OAAA,GAAU,aAAA"}
+{"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"}

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

@@ -1,6 +1,5 @@
 import { RoutingOptions } from "./getPrefix.js";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-
 //#region src/localization/validatePrefix.d.ts
 type ValidatePrefixResult = {
   isValid: boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"validatePrefix.d.ts","names":[],"sources":["../../../src/localization/validatePrefix.ts"],"mappings":";;;;KAyBY,oBAAA;EACV,OAAA;EACA,YAAA;AAAA;;;;AAyBF;;;;;;;;;;;;;;;;;;;cAAa,cAAA,GACX,MAAA,EAAQ,aAAA,qBACR,OAAA,GAAU,cAAA,KACT,oBAAA"}
+{"version":3,"file":"validatePrefix.d.ts","names":[],"sources":["../../../src/localization/validatePrefix.ts"],"mappings":";;;KAyBY;EACV;EACA;;;;;;;;;;;;;;;;;;;;;;;;cAyBW,iBAAc,QACjB,kCAAgC,UAC9B,mBACT"}

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

@@ -1,5 +1,4 @@
 import { CompileOptions, MarkdownContext, MarkdownOptions, MarkdownRuntime } from "./types.js";
-
 //#region src/markdown/compiler.d.ts
 type FootnoteDef = {
   footnote: string;

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

@@ -1 +1 @@
-{"version":3,"file":"compiler.d.ts","names":[],"sources":["../../../src/markdown/compiler.ts"],"mappings":";;;KA6GK,WAAA;EAAgB,QAAA;EAAkB,UAAA;AAAA;AAAA,KAg5B3B,cAAA;EACV,GAAA;EACA,SAAA,EAAW,WAAA;EACX,MAAA;AAAA;AAAA,cAGW,aAAA,GACX,QAAA,UACA,GAAA,EAAK,eAAA,OACL,OAAA,GAAS,eAAA,KACR,cAAA;AAAA,cAoIU,iBAAA,GACX,MAAA,EAAQ,cAAA,EACR,GAAA,EAAK,eAAA,OACL,OAAA,GAAS,eAAA;AAAA,cAqHE,OAAA,GACX,QAAA,UACA,GAAA,EAAK,eAAA,OACL,OAAA,GAAS,eAAA;AAAA,cAgBE,cAAA,GACV,GAAA,EAAK,eAAA,WACL,QAAA,UAAkB,OAAA,GAAU,eAAA;AAAA,cAGlB,kBAAA,GACX,QAAA,UACA,OAAA,EAAS,eAAA,EACT,OAAA,GAAS,cAAA"}
+{"version":3,"file":"compiler.d.ts","names":[],"sources":["../../../src/markdown/compiler.ts"],"mappings":";;KA6GK;EAAgB;EAAkB;;KAg5B3B;EACV;EACA,WAAW;EACX;;cAGW,gBAAa,kBACR,KACX,sBAAoB,UAChB,oBACR;cAoIU,oBAAiB,QACpB,gBAAc,KACjB,sBAAoB,UAChB;cAqHE,UAAO,kBACF,KACX,sBAAoB,UAChB;cAgBE,iBAAc,KACnB,0BAAoB,kBACT,UAAY;cAGlB,qBAAkB,kBACb,SACP,iBAAe,UACf"}

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

@@ -4,50 +4,60 @@
  * so do not hard code against the value directly.
  */
 declare const RuleType: {
-  readonly blockQuote: "0";
-  readonly breakLine: "1";
-  readonly breakThematic: "2";
-  readonly codeBlock: "3";
-  readonly codeFenced: "4";
-  readonly codeInline: "5";
-  readonly footnote: "6";
-  readonly footnoteReference: "7";
-  readonly gfmTask: "8";
-  readonly heading: "9";
-  readonly headingSetext: "10"; /** only available if not `disableHTMLParsing` */
-  readonly htmlBlock: "11";
-  readonly htmlComment: "12"; /** only available if not `disableHTMLParsing` */
-  readonly htmlSelfClosing: "13"; /** Custom components like <Tabs>, <TabItem> */
-  readonly customComponent: "34";
-  readonly image: "14";
-  readonly link: "15"; /** emits a `link` 'node', does not render directly */
-  readonly linkAngleBraceStyleDetector: "16"; /** emits a `link` 'node', does not render directly */
-  readonly linkBareUrlDetector: "17";
-  readonly newlineCoalescer: "19";
-  readonly orderedList: "20";
-  readonly paragraph: "21";
-  readonly ref: "22";
-  readonly refImage: "23";
-  readonly refLink: "24";
-  readonly table: "25";
-  readonly tableSeparator: "26";
-  readonly text: "27";
-  readonly textBolded: "28";
-  readonly textEmphasized: "29";
-  readonly textEscaped: "30";
-  readonly textMarked: "31";
-  readonly textStrikethroughed: "32";
-  readonly unorderedList: "33";
+  readonly blockQuote: '0';
+  readonly breakLine: '1';
+  readonly breakThematic: '2';
+  readonly codeBlock: '3';
+  readonly codeFenced: '4';
+  readonly codeInline: '5';
+  readonly footnote: '6';
+  readonly footnoteReference: '7';
+  readonly gfmTask: '8';
+  readonly heading: '9';
+  readonly headingSetext: '10';
+  /** only available if not `disableHTMLParsing` */
+  readonly htmlBlock: '11';
+  readonly htmlComment: '12';
+  /** only available if not `disableHTMLParsing` */
+  readonly htmlSelfClosing: '13';
+  /** Custom components like <Tabs>, <TabItem> */
+  readonly customComponent: '34';
+  readonly image: '14';
+  readonly link: '15';
+  /** emits a `link` 'node', does not render directly */
+  readonly linkAngleBraceStyleDetector: '16';
+  /** emits a `link` 'node', does not render directly */
+  readonly linkBareUrlDetector: '17';
+  readonly newlineCoalescer: '19';
+  readonly orderedList: '20';
+  readonly paragraph: '21';
+  readonly ref: '22';
+  readonly refImage: '23';
+  readonly refLink: '24';
+  readonly table: '25';
+  readonly tableSeparator: '26';
+  readonly text: '27';
+  readonly textBolded: '28';
+  readonly textEmphasized: '29';
+  readonly textEscaped: '30';
+  readonly textMarked: '31';
+  readonly textStrikethroughed: '32';
+  readonly unorderedList: '33';
 };
 type RuleTypeValue = (typeof RuleType)[keyof typeof RuleType];
 /**
  * Priority levels for rule ordering.
  */
 declare const Priority: {
-  /** anything that must scan the tree before everything else */readonly MAX: 0; /** scans for block-level constructs */
-  readonly HIGH: 1; /** inline w/ more priority than other inline */
-  readonly MED: 2; /** inline elements */
-  readonly LOW: 3; /** bare text and stuff that is considered leftovers */
+  /** anything that must scan the tree before everything else */
+  readonly MAX: 0;
+  /** scans for block-level constructs */
+  readonly HIGH: 1;
+  /** inline w/ more priority than other inline */
+  readonly MED: 2;
+  /** inline elements */
+  readonly LOW: 3;
+  /** bare text and stuff that is considered leftovers */
   readonly MIN: 4;
 };
 type PriorityValue = (typeof Priority)[keyof typeof Priority];

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

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","names":[],"sources":["../../../src/markdown/constants.ts"],"mappings":"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"}
+{"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"}