@intlayer/core 9.0.0-canary.9 → 9.0.1

package/dist/types/interpreter/interpolableNode.d.ts

@@ -0,0 +1,66 @@
+import { NodeProps, Plugins } from "./getContent/plugins.js";
+import * as NodeTypes from "@intlayer/types/nodeType";
+//#region src/interpreter/interpolableNode.d.ts
+/**
+ * A node whose textual content can carry `{{ … }}` interpolation placeholders.
+ *
+ * Besides plain strings, this covers `html()` and `markdown()` nodes: their
+ * inner content is a raw string that may itself hold placeholders (e.g.
+ * `html('<b>{{count}}</b> days')`). Enumeration/plural/insertion wrappers must
+ * be able to interpolate into that inner string before the html/markdown
+ * renderer turns it into a component tree.
+ */
+type InterpolableNode = string | {
+  nodeType: typeof NodeTypes.HTML;
+  [NodeTypes.HTML]: string;
+} | {
+  nodeType: typeof NodeTypes.MARKDOWN;
+  [NodeTypes.MARKDOWN]: string;
+};
+/**
+ * Returns `true` when the node is an `html()` or `markdown()` node whose inner
+ * content is a raw string eligible for `{{ … }}` interpolation.
+ *
+ * Each check is guarded by the corresponding `INTLAYER_NODE_TYPE_*` env flag
+ * so bundlers can eliminate the branch (and downstream handling code) when the
+ * html/markdown node types are tree-shaken out of the user bundle.
+ */
+declare const isInterpolableWrapperNode: (node: unknown) => node is Exclude<InterpolableNode, string>;
+/**
+ * Extracts the raw interpolable string from a string, `html()` or `markdown()`
+ * node. Returns `undefined` for any other node so callers can fall back to
+ * their default handling.
+ *
+ * @example
+ * ```ts
+ * getInterpolableContent('{{count}} days'); // '{{count}} days'
+ * getInterpolableContent(html('<b>{{count}}</b>')); // '<b>{{count}}</b>'
+ * getInterpolableContent({ nodeType: 'translation' }); // undefined
+ * ```
+ */
+declare const getInterpolableContent: (node: unknown) => string | undefined;
+/**
+ * Rebuilds an interpolable node from its interpolated raw string, preserving
+ * the original node shape (plain string stays a string, `html()`/`markdown()`
+ * nodes keep their `nodeType` and sibling fields so the renderer still applies).
+ *
+ * @example
+ * ```ts
+ * rebuildInterpolableContent(html('<b>{{count}}</b>'), '<b>1</b>');
+ * // { nodeType: 'html', html: '<b>1</b>', … }
+ * ```
+ */
+declare const rebuildInterpolableContent: <T>(node: T, interpolated: string) => T;
+/**
+ * Interpolates `{{ … }}` values into an `html()`/`markdown()` wrapper node,
+ * then re-runs the transform with the parent plugin list so the html/markdown
+ * renderer applies to the interpolated content.
+ *
+ * Shared by the plural/insertion string plugins of `@intlayer/core` and every
+ * framework package — framework nodes (React elements, VNodes…) cannot be
+ * injected into a raw markup string, so plain string interpolation is used.
+ */
+declare const transformInterpolableNode: (node: Exclude<InterpolableNode, string>, values: Record<string, string | number>, subProps: NodeProps, parentPlugins: Plugins[] | undefined, deepTransformNode: (node: unknown, props: NodeProps) => unknown) => unknown;
+//#endregion
+export { InterpolableNode, getInterpolableContent, isInterpolableWrapperNode, rebuildInterpolableContent, transformInterpolableNode };
+//# sourceMappingURL=interpolableNode.d.ts.map

package/dist/types/interpreter/interpolableNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpolableNode.d.ts","names":[],"sources":["../../../src/interpreter/interpolableNode.ts"],"mappings":";;;;;;;;;;;;KAaY;EAEN,iBAAiB,UAAU;GAAO,UAAU;;EAC5C,iBAAiB,UAAU;GAAW,UAAU;;;;;;;;;;cAUzC,4BAAyB,kBAEnC,QAAQ,QAAQ;;;;;;;;;;;;;cA2BN,yBAAsB;;;;;;;;;;;;cAyBtB,6BAA8B,GAAC,MACpC,GAAC,yBAEN;;;;;;;;;;cAwBU,4BAAyB,MAC9B,QAAQ,2BAAyB,QAC/B,iCAA+B,UAC7B,WAAS,eACJ,uBAAqB,oBAChB,eAAe,OAAO"}

package/dist/types/interpreter/splitAndJoinInsertion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"splitAndJoinInsertion.d.ts","names":[],"sources":["../../../src/interpreter/splitAndJoinInsertion.ts"],"mappings":";cAaa,sBAAA,YACX,QAAA,UACA,MAAA,GAAQ,MAAA,SAAe,CAAA;EACpB,QAAA;EAAmB,KAAA,WAAgB,CAAA;AAAA"}
+{"version":3,"file":"splitAndJoinInsertion.d.ts","names":[],"sources":["../../../src/interpreter/splitAndJoinInsertion.ts"],"mappings":";cAaa,yBAA0B,SAAO,kBAC5B,SACR,eAAe;EACpB;EAAmB,gBAAgB"}

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

@@ -1,5 +1,4 @@
 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

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

@@ -1 +1 @@
-{"version":3,"file":"comparePaths.d.ts","names":[],"sources":["../../../src/localization/comparePaths.ts"],"mappings":";;;;;AAqCA;;;;;;;;;;;;;;;;AAiDA;;;;;;;;;;;;cAjDa,aAAA,mBAAiC,aAAA,GAAgB,eAAA,EAC5D,QAAA,UACA,OAAA,GAAU,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+CC,YAAA,mBAAgC,aAAA,GAAgB,eAAA,EAC3D,QAAA,UACA,IAAA,UACA,OAAA,GAAU,CAAA"}
+{"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,4 +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";
@@ -15,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, comparePaths, generateSitemap, generateSitemapUrl, getBrowserLocale, getCanonicalPath, getHTMLTextDir, getInternalPath, getLocale, getLocaleFromPath, getLocaleLang, getLocaleName, getLocalizedPath, getLocalizedUrl, getMultilingualUrls, getPathWithoutLocale, getPrefix, getRewritePath, getRewriteRules, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, normalizePath, 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"}