@intlayer/core 9.6.0 → 9.7.1

package/dist/types/interpreter/getContent/plugins.d.ts

@@ -1,12 +1,12 @@
 import { Gender } from "../../transpiler/gender/gender.js";
 import "../../transpiler/index.js";
+import { DEFAULT_PLURAL_VARIABLE } from "../../transpiler/plural/plural.js";
 import { GetNestingResult } from "../getNesting.js";
 import { DeclaredLocales, DictionaryKeys, LocalesValues } from "@intlayer/types/module_augmentation";
 import { Locale } from "@intlayer/types/allLocales";
 import { KeyPath } from "@intlayer/types/keyPath";
 import * as NodeTypes from "@intlayer/types/nodeType";
 import { NodeType } from "@intlayer/types/nodeType";
-//#region src/interpreter/getContent/plugins.d.ts
 /** ---------------------------------------------
  * PLUGIN DEFINITION
  * --------------------------------------------- */
@@ -60,13 +60,16 @@ type PluralBranch<Branch> = Branch extends {
   [NodeTypes.INSERTION]: infer InsertionContent;
   fields: readonly string[];
 } ? InsertionContent : Branch;
+/** Value name a plural node selects on (`variable`, defaulting to `count`). */
+type PluralVariable<T> = T extends {
+  variable: infer Variable extends string;
+} ? Variable : typeof DEFAULT_PLURAL_VARIABLE;
 export type PluralCond<T, S, _L> = T extends {
   nodeType: NodeType | string;
   [NodeTypes.PLURAL]: object;
-} ? (arg: number | {
-  count: number;
+} ? (arg: number | ({ [Key in PluralVariable<T>]: number; } & {
   [key: string]: unknown;
-}) => DeepTransformContent<PluralBranch<T[typeof NodeTypes.PLURAL][keyof T[typeof NodeTypes.PLURAL]]>, S> : never;
+})) => DeepTransformContent<PluralBranch<T[typeof NodeTypes.PLURAL][keyof T[typeof NodeTypes.PLURAL]]>, S> : never;
 /**
  * Plural plugin. Replaces node with a function that takes a count (or
  * `{ count, ...values }`) => string, picking the matching CLDR plural form
@@ -235,5 +238,5 @@ export type IsAny<T> = 0 extends 1 & T ? true : false;
  * Traverse recursively through an object or array, applying each plugin as needed.
  */
 export type DeepTransformContent<T, S = IInterpreterPluginState, L extends LocalesValues = DeclaredLocales> = IsAny<T> extends true ? T : CheckApplyPlugin<T, keyof IInterpreterPlugin<T, S, L>, S, L> extends never ? Traverse<T, S, L> : CheckApplyPlugin<T, keyof IInterpreterPlugin<T, S, L>, S, L>;
-//#endregion
+export {};
 //# sourceMappingURL=plugins.d.ts.map

package/dist/types/interpreter/getContent/plugins.d.ts.map

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

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

@@ -2,7 +2,6 @@ import { DeepTransformContent, IInterpreterPluginState, Plugins } from "./getCon
 import "./getContent/index.js";
 import { Dictionary, DictionarySelector, QualifiedDictionaryGroup, ResolveQualifiedDictionaryContent } from "@intlayer/types/dictionary";
 import { DeclaredLocales, ExtractSelectorLocale, LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/interpreter/getDictionary.d.ts
 /**
  * Transforms a dictionary in a single pass, applying each plugin as needed.
  *
@@ -13,5 +12,4 @@ import { DeclaredLocales, ExtractSelectorLocale, LocalesValues } from "@intlayer
  *                If omitted, we’ll use a default set of plugins.
  */
 export declare const getDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(dictionary: T, localeOrSelector?: A, plugins?: Plugins[]) => DeepTransformContent<ResolveQualifiedDictionaryContent<T, A>, IInterpreterPluginState, ExtractSelectorLocale<A>>;
-//#endregion
 //# sourceMappingURL=getDictionary.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getDictionary.d.ts","names":[],"sources":["../../../src/interpreter/getDictionary.ts"],"mappings":";;;;;;;;;;;;;;qBA8Ca,sBACL,UAAU,aAAa,gCACvB,UAAU,gBAAgB,qBAAqB,iBAAe,YAExD,GAAC,mBACM,GAAC,UACV,cACT,qBACD,kCAAkC,GAAG,IACrC,yBACA,sBAAsB"}
+{"version":3,"file":"getDictionary.d.ts","names":[],"sources":["../../../src/interpreter/getDictionary.ts"],"mappings":";;;;;;;;;;;;;qBA8Ca,sBACL,UAAU,aAAa,gCACvB,UAAU,gBAAgB,qBAAqB,iBAAe,YAExD,GAAC,mBACM,GAAC,UACV,cACT,qBACD,kCAAkC,GAAG,IACrC,yBACA,sBAAsB"}

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

@@ -1,10 +1,9 @@
 import { DeepTransformContent, IInterpreterPluginState, Plugins } from "./getContent/plugins.js";
-import "./getContent/index.js";
 import { PlainDynamicLoaderMap } from "../dictionaryManipulator/plainDynamicLoader.js";
 import { QualifiedDynamicLoaderMap } from "../dictionaryManipulator/qualifiedDynamicLoader.js";
+import "./getContent/index.js";
 import { Dictionary, DictionarySelector } from "@intlayer/types/dictionary";
 import { DeclaredLocales, ExtractSelectorLocale, LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/interpreter/getDictionaryAsync.d.ts
 /**
  * Loads a single locale chunk of a dictionary and returns its transformed
  * content.
@@ -29,5 +28,4 @@ import { DeclaredLocales, ExtractSelectorLocale, LocalesValues } from "@intlayer
  * @param plugins - Node transformers. Defaults to the base interpreter set.
  */
 export declare const getDictionaryAsync: <const T extends Dictionary, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(dictionaryLoaders: PlainDynamicLoaderMap<T> | QualifiedDynamicLoaderMap, key: string, localeOrSelector?: A, plugins?: Plugins[]) => Promise<DeepTransformContent<T['content'], IInterpreterPluginState, ExtractSelectorLocale<A>>>;
-//#endregion
 //# sourceMappingURL=getDictionaryAsync.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getDictionaryAsync.d.ts","names":[],"sources":["../../../src/interpreter/getDictionaryAsync.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAiFa,2BACL,UAAU,kBACV,UAAU,gBAAgB,qBAAqB,iBAAe,mBAEjD,sBAAsB,KAAK,2BAAyB,aAC5D,mBACQ,GAAC,UACV,cACT,QACD,qBACE,cACA,yBACA,sBAAsB"}
+{"version":3,"file":"getDictionaryAsync.d.ts","names":[],"sources":["../../../src/interpreter/getDictionaryAsync.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAiFa,2BACL,UAAU,kBACV,UAAU,gBAAgB,qBAAqB,iBAAe,mBAEjD,sBAAsB,KAAK,2BAAyB,aAC5D,mBACQ,GAAC,UACV,cACT,QACD,qBACE,cACA,yBACA,sBAAsB"}

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

@@ -1,6 +1,5 @@
 import { EnterFormat, EnumerationContentState } from "../transpiler/enumeration/enumeration.js";
 import "../transpiler/index.js";
-//#region src/interpreter/getEnumeration.d.ts
 /**
  * Find the matching condition for a quantity.
  *
@@ -54,5 +53,4 @@ export declare const findMatchingCondition: <const Content>(enumerationContent:
  * ```
  */
 export declare const getEnumeration: <const Content>(enumerationContent: EnumerationContentState<Content>, quantity: number) => Content;
-//#endregion
 //# sourceMappingURL=getEnumeration.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getEnumeration.d.ts","names":[],"sources":["../../../src/interpreter/getEnumeration.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6Ba,8BAA+B,SAAO,oBAC7B,wBAAwB,UAAQ,qBAEnD;;;;;;;;;;;;;;;;;;;;;;;;;qBAuDU,uBAAwB,SAAO,oBACtB,wBAAwB,UAAQ,qBAEnD"}
+{"version":3,"file":"getEnumeration.d.ts","names":[],"sources":["../../../src/interpreter/getEnumeration.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6Ba,8BAA+B,SAAO,oBAC7B,wBAAwB,UAAQ,qBAEnD;;;;;;;;;;;;;;;;;;;;;;;;;qBAuDU,uBAAwB,SAAO,oBACtB,wBAAwB,UAAQ,qBAEnD"}

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

@@ -1,6 +1,5 @@
 import { Gender, GenderContentStates } from "../transpiler/gender/gender.js";
 import "../transpiler/index.js";
-//#region src/interpreter/getGender.d.ts
 type GenderEntry = Gender | 'm' | 'f';
 /**
  * Allow to pick a content based on a gender.
@@ -25,5 +24,5 @@ type GenderEntry = Gender | 'm' | 'f';
  * // 'The gender is validated'
  */
 export declare const getGender: <const Content>(genderContent: GenderContentStates<Content>, gender: GenderEntry) => Content;
-//#endregion
+export {};
 //# sourceMappingURL=getGender.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getGender.d.ts","names":[],"sources":["../../../src/interpreter/getGender.ts"],"mappings":";;;KAEK,cAAc;;;;;;;;;;;;;;;;;;;;;;;qBA8BN,kBAAmB,SAAO,eACtB,oBAAoB,UAAQ,QACnC,gBACP"}
+{"version":3,"file":"getGender.d.ts","names":[],"sources":["../../../src/interpreter/getGender.ts"],"mappings":";;KAEK,cAAc;;;;;;;;;;;;;;;;;;;;;;;qBA8BN,kBAAmB,SAAO,eACtB,oBAAoB,UAAQ,QACnC,gBACP"}

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

@@ -1,4 +1,3 @@
-//#region src/interpreter/getHTML.d.ts
 /**
  * Component function that receives properly typed props
  * Props include:
@@ -27,5 +26,5 @@ type Components = Record<string, Component | string | ComponentObject>;
  * Interprets a string containing HTML-like tags and replaces them with provided components or strings.
  */
 export declare const getHTML: (content: string, values: Components) => any;
-//#endregion
+export {};
 //# sourceMappingURL=getHTML.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getHTML.d.ts","names":[],"sources":["../../../src/interpreter/getHTML.ts"],"mappings":";;;;;;;KAMK,aAAa;EAAS;GAAmB;;;;;KAKzC;EACH;EACA,QAAQ;;;;;;;;KASL,aAAa,eAAe,qBAAqB;;;;qBA4HzC,UAAO,iBAAmB,QAAU"}
+{"version":3,"file":"getHTML.d.ts","names":[],"sources":["../../../src/interpreter/getHTML.ts"],"mappings":";;;;;;KAMK,aAAa;EAAS;GAAmB;;;;;KAKzC;EACH;EACA,QAAQ;;;;;;;;KASL,aAAa,eAAe,qBAAqB;;;;qBA4HzC,UAAO,iBAAmB,QAAU"}

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

@@ -1,6 +1,5 @@
 import { InsertionContent } from "../transpiler/insertion/insertion.js";
 import "../transpiler/index.js";
-//#region src/interpreter/getInsertion.d.ts
 /**
  * Allow to insert values in a string.
  *
@@ -15,5 +14,4 @@ import "../transpiler/index.js";
  *
  */
 export declare const getInsertion: (content: string, values: { [K in InsertionContent['fields'][number]]: string | number; }) => string;
-//#endregion
 //# sourceMappingURL=getInsertion.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getInsertion.d.ts","names":[],"sources":["../../../src/interpreter/getInsertion.ts"],"mappings":";;;;;;;;;;;;;;;;qBAea,eAAY,iBACR,WACJ,KAAK"}
+{"version":3,"file":"getInsertion.d.ts","names":[],"sources":["../../../src/interpreter/getInsertion.ts"],"mappings":";;;;;;;;;;;;;;;qBAea,eAAY,iBACR,WACJ,KAAK"}

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

@@ -2,7 +2,6 @@ import { DeepTransformContent, IInterpreterPluginState, Plugins } from "./getCon
 import "./getContent/index.js";
 import { DictionarySelector } from "@intlayer/types/dictionary";
 import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, ExtractSelectorLocale, LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/interpreter/getIntlayer.d.ts
 /**
  * Picks one dictionary by its key and returns its content for the given
  * locale or selector.
@@ -14,5 +13,4 @@ import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, ExtractSelec
  * - `locale` can be combined with any selector: `{ item: 2, locale: 'fr' }`
  */
 export declare const getIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(key: T, localeOrSelector?: A, plugins?: Plugins[]) => DeepTransformContent<DictionaryRegistryResult<T, A>, IInterpreterPluginState, ExtractSelectorLocale<A>>;
-//#endregion
 //# sourceMappingURL=getIntlayer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getIntlayer.d.ts","names":[],"sources":["../../../src/interpreter/getIntlayer.ts"],"mappings":";;;;;;;;;;;;;;;qBAsFa,oBACL,UAAU,sBACV,UAAU,gBAAgB,qBAAqB,iBAAe,KAE/D,GAAC,mBACa,GAAC,UACV,cACT,qBACD,yBAAyB,GAAG,IAC5B,yBACA,sBAAsB"}
+{"version":3,"file":"getIntlayer.d.ts","names":[],"sources":["../../../src/interpreter/getIntlayer.ts"],"mappings":";;;;;;;;;;;;;;qBAsFa,oBACL,UAAU,sBACV,UAAU,gBAAgB,qBAAqB,iBAAe,KAE/D,GAAC,mBACa,GAAC,UACV,cACT,qBACD,yBAAyB,GAAG,IAC5B,yBACA,sBAAsB"}

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

@@ -2,7 +2,6 @@ import { DeepTransformContent, IInterpreterPluginState, Plugins } from "./getCon
 import "./getContent/index.js";
 import { DictionarySelector } from "@intlayer/types/dictionary";
 import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, ExtractSelectorLocale, LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/interpreter/getIntlayerAsync.d.ts
 /**
  * Picks one dictionary by its key and resolves its content for the given
  * locale or selector, loading that locale alone.
@@ -31,5 +30,4 @@ import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, ExtractSelec
  * ```
  */
 export declare const getIntlayerAsync: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(key: T, localeOrSelector?: A, plugins?: Plugins[]) => Promise<DeepTransformContent<DictionaryRegistryResult<T, A>, IInterpreterPluginState, ExtractSelectorLocale<A>>>;
-//#endregion
 //# sourceMappingURL=getIntlayerAsync.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getIntlayerAsync.d.ts","names":[],"sources":["../../../src/interpreter/getIntlayerAsync.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2Ca,yBACL,UAAU,sBACV,UAAU,gBAAgB,qBAAqB,iBAAe,KAE/D,GAAC,mBACa,GAAC,UACV,cACT,QACD,qBACE,yBAAyB,GAAG,IAC5B,yBACA,sBAAsB"}
+{"version":3,"file":"getIntlayerAsync.d.ts","names":[],"sources":["../../../src/interpreter/getIntlayerAsync.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2Ca,yBACL,UAAU,sBACV,UAAU,gBAAgB,qBAAqB,iBAAe,KAE/D,GAAC,mBACa,GAAC,UACV,cACT,QACD,qBACE,yBAAyB,GAAG,IAC5B,yBACA,sBAAsB"}

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

@@ -4,7 +4,6 @@ import { DeepTransformContent, IInterpreterPluginState, NodeProps } from "./getC
 import "./getContent/index.js";
 import { GetSubPath } from "@intlayer/types/dictionary";
 import { DictionaryKeys, DictionaryRegistryContent } from "@intlayer/types/module_augmentation";
-//#region src/interpreter/getNesting.d.ts
 export type GetNestingResult<K extends DictionaryKeys, P = undefined, S = IInterpreterPluginState> = GetSubPath<DeepTransformContent<DictionaryRegistryContent<K>, S>, P>;
 /**
  * Extracts content from another dictionary by its key and an optional path.
@@ -23,5 +22,4 @@ export type GetNestingResult<K extends DictionaryKeys, P = undefined, S = IInter
  * ```
  */
 export declare const getNesting: <const K extends DictionaryKeys, const P>(dictionaryKey: K, path?: P extends ValidDotPathsFor<K> ? P : never, props?: NodeProps) => GetNestingResult<K, P>;
-//#endregion
 //# sourceMappingURL=getNesting.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getNesting.d.ts","names":[],"sources":["../../../src/interpreter/getNesting.ts"],"mappings":";;;;;;;YAaY,iBACV,UAAU,gBACV,eACA,IAAI,2BACF,WAAW,qBAAqB,0BAA0B,IAAI,IAAI;;;;;;;;;;;;;;;;;qBAkBzD,mBAAoB,UAAU,sBAAsB,GAAC,eACjD,GAAC,OACT,UAAU,iBAAiB,KAAK,WAAS,QACxC,cACP,iBAAiB,GAAG"}
+{"version":3,"file":"getNesting.d.ts","names":[],"sources":["../../../src/interpreter/getNesting.ts"],"mappings":";;;;;;YAaY,iBACV,UAAU,gBACV,eACA,IAAI,2BACF,WAAW,qBAAqB,0BAA0B,IAAI,IAAI;;;;;;;;;;;;;;;;;qBAkBzD,mBAAoB,UAAU,sBAAsB,GAAC,eACjD,GAAC,OACT,UAAU,iBAAiB,KAAK,WAAS,QACxC,cACP,iBAAiB,GAAG"}

package/dist/types/interpreter/getNesting.optimized.d.ts

@@ -1,10 +1,9 @@
 import { ValidDotPathsFor } from "../transpiler/nesting/nesting.js";
 import "../transpiler/index.js";
-import { GetNestingResult } from "./getNesting.js";
-import { NodeProps } from "./getContent/plugins.js";
 import "./getContent/index.js";
+import { NodeProps } from "./getContent/plugins.js";
+import { GetNestingResult } from "./getNesting.js";
 import { DictionaryKeys } from "@intlayer/types/module_augmentation";
-//#region src/interpreter/getNesting.optimized.d.ts
 /**
  * Optimized-build replacement for `getNesting`.
  *
@@ -28,5 +27,4 @@ import { DictionaryKeys } from "@intlayer/types/module_augmentation";
  * @returns The nested content.
  */
 export declare const getNesting: <const K extends DictionaryKeys, const P>(dictionaryKey: K, path?: P extends ValidDotPathsFor<K> ? P : never, props?: NodeProps) => GetNestingResult<K, P>;
-//#endregion
 //# sourceMappingURL=getNesting.optimized.d.ts.map

package/dist/types/interpreter/getNesting.optimized.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getNesting.optimized.d.ts","names":[],"sources":["../../../src/interpreter/getNesting.optimized.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmDa,mBAAoB,UAAU,sBAAsB,GAAC,eACjD,GAAC,OACT,UAAU,iBAAiB,KAAK,WAAS,QACxC,cACP,iBAAiB,GAAG"}
+{"version":3,"file":"getNesting.optimized.d.ts","names":[],"sources":["../../../src/interpreter/getNesting.optimized.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmDa,mBAAoB,UAAU,sBAAsB,GAAC,eACjD,GAAC,OACT,UAAU,iBAAiB,KAAK,WAAS,QACxC,cACP,iBAAiB,GAAG"}

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

@@ -1,7 +1,6 @@
 import { PluralContentState } from "../transpiler/plural/plural.js";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { DeclaredLocales as DeclaredLocales$1 } from "@intlayer/types";
-//#region src/interpreter/getPlural.d.ts
 /**
  * Picks content from a plural map based on a count and locale, using CLDR
  * pluralization rules (`Intl.PluralRules`).
@@ -18,5 +17,4 @@ import { DeclaredLocales as DeclaredLocales$1 } from "@intlayer/types";
  * ```
  */
 export declare const getPlural: <const L extends LocalesValues = DeclaredLocales$1>(pluralContent: PluralContentState<string>, count: number, locale: L) => string;
-//#endregion
 //# sourceMappingURL=getPlural.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getPlural.d.ts","names":[],"sources":["../../../src/interpreter/getPlural.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAuBa,kBAAmB,UAAU,gBAAgB,mBAAe,eACxD,4BAA0B,eAC5B,QACL"}
+{"version":3,"file":"getPlural.d.ts","names":["DeclaredLocales"],"sources":["../../../src/interpreter/getPlural.ts"],"mappings":";;;;;;;;;;;;;;;;;;qBAuBa,kBAAmB,UAAU,gBAAgBA,mBAAe,eACxD,4BAA0B,eAC5B,QACL"}

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

@@ -1,6 +1,5 @@
 import { SelectContentStates } from "../transpiler/select/select.js";
 import "../transpiler/index.js";
-//#region src/interpreter/getSelect.d.ts
 /**
  * Picks content from a select map based on an arbitrary string value.
  *
@@ -26,5 +25,4 @@ import "../transpiler/index.js";
  * ```
  */
 export declare const getSelect: <const Content>(selectContent: SelectContentStates<Content>, value?: string) => Content;
-//#endregion
 //# sourceMappingURL=getSelect.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getSelect.d.ts","names":[],"sources":["../../../src/interpreter/getSelect.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;qBA0Ba,kBAAmB,SAAO,eACtB,oBAAoB,UAAQ,mBAE1C"}
+{"version":3,"file":"getSelect.d.ts","names":[],"sources":["../../../src/interpreter/getSelect.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;qBA0Ba,kBAAmB,SAAO,eACtB,oBAAoB,UAAQ,mBAE1C"}

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

@@ -1,5 +1,4 @@
 import { LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
-//#region src/interpreter/getTranslation.d.ts
 /**
  * Picks the appropriate content from a locale map based on the provided locale.
  *
@@ -24,5 +23,4 @@ import { LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augme
  * ```
  */
 export declare const getTranslation: <const Content = string>(languageContent: StrictModeLocaleMap<Content>, locale: LocalesValues, fallback?: LocalesValues) => Content;
-//#endregion
 //# sourceMappingURL=getTranslation.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getTranslation.d.ts","names":[],"sources":["../../../src/interpreter/getTranslation.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;qBA2Fa,uBAAwB,kBAAgB,iBAClC,oBAAoB,UAAQ,QACrC,eAAa,WACV,kBACV"}
+{"version":3,"file":"getTranslation.d.ts","names":[],"sources":["../../../src/interpreter/getTranslation.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;qBA2Fa,uBAAwB,kBAAgB,iBAClC,oBAAoB,UAAQ,QACrC,eAAa,WACV,kBACV"}

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

@@ -1,10 +1,9 @@
-import { GetNestingResult, getNesting } from "./getNesting.js";
+import { getDictionaryTransformCacheKey, getPluginsCacheKey, readTransformCache, writeTransformCache } from "./dictionaryTransformCache.js";
 import { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, IsAny, NestedCond, NodeProps, Plugins, PluralCond, SelectCond, SelectSelector, TranslationCond, UnionKeys, ValueAtKey, bindInsertedValues, conditionPlugin, enumerationPlugin, fallbackPlugin, filePlugin, genderPlugin, insertionPlugin, nestedPlugin, pluralPlugin, resolveInsertedSelector, selectPlugin, translationPlugin } from "./getContent/plugins.js";
 import { deepTransformNode } from "./getContent/deepTransform.js";
 import { getBasePlugins, getContent } from "./getContent/getContent.js";
-import "./getContent/index.js";
-import { getDictionaryTransformCacheKey, getPluginsCacheKey, readTransformCache, writeTransformCache } from "./dictionaryTransformCache.js";
 import { getCondition } from "./getCondition.js";
+import "./getContent/index.js";
 import { getDictionary } from "./getDictionary.js";
 import { getDictionaryAsync } from "./getDictionaryAsync.js";
 import { findMatchingCondition, getEnumeration } from "./getEnumeration.js";
@@ -13,6 +12,7 @@ import { getHTML } from "./getHTML.js";
 import { getInsertion } from "./getInsertion.js";
 import { getIntlayer } from "./getIntlayer.js";
 import { getIntlayerAsync } from "./getIntlayerAsync.js";
+import { GetNestingResult, getNesting } from "./getNesting.js";
 import { getPlural } from "./getPlural.js";
 import { getSelect } from "./getSelect.js";
 import { getTranslation } from "./getTranslation.js";

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

@@ -1,6 +1,5 @@
 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.
  *
@@ -61,5 +60,4 @@ export declare const rebuildInterpolableContent: <T>(node: T, interpolated: stri
  * injected into a raw markup string, so plain string interpolation is used.
  */
 export 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
 //# sourceMappingURL=interpolableNode.d.ts.map

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

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

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

@@ -1,5 +1,4 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-//#region src/interpreter/resolveInterpreterLocale.d.ts
 /**
  * Returns the locale of the context the code runs in (typically the request
  * being handled on the server), or `undefined` outside of such a context.
@@ -59,5 +58,4 @@ export declare const resolveInterpreterLocale: (locale?: LocalesValues) => Local
  * @returns The resolved locale.
  */
 export declare const resolveInterpreterLocaleAsync: (locale?: LocalesValues) => Promise<LocalesValues>;
-//#endregion
 //# sourceMappingURL=resolveInterpreterLocale.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"resolveInterpreterLocale.d.ts","names":[],"sources":["../../../src/interpreter/resolveInterpreterLocale.ts"],"mappings":";;;;;;YAQY,8BAA8B;;;;;YAM9B,mCAAmC,QAC7C;;;;;;;;;;;;qBAkCW,gCAA6B,UAC9B;;;;;;;;;;;;;qBAuBC,qCAAkC,UACnC;;;;;;;;;;;;;;;;qBAsCC,2BAAwB,SAC1B,kBACR;;;;;;;;qBAeU,gCAA6B,SAC/B,kBACR,QAAQ"}
+{"version":3,"file":"resolveInterpreterLocale.d.ts","names":[],"sources":["../../../src/interpreter/resolveInterpreterLocale.ts"],"mappings":";;;;;YAQY,8BAA8B;;;;;YAM9B,mCAAmC,QAC7C;;;;;;;;;;;;qBAkCW,gCAA6B,UAC9B;;;;;;;;;;;;;qBAuBC,qCAAkC,UACnC;;;;;;;;;;;;;;;;qBAsCC,2BAAwB,SAC1B,kBACR;;;;;;;;qBAeU,gCAA6B,SAC/B,kBACR,QAAQ"}

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

@@ -1,7 +1,5 @@
-//#region src/interpreter/splitAndJoinInsertion.d.ts
 export declare const splitInsertionTemplate: <T = any>(template: string, values?: Record<string, T>) => {
   isSimple: boolean;
   parts: string | T[];
 };
-//#endregion
 //# sourceMappingURL=splitAndJoinInsertion.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"splitAndJoinInsertion.d.ts","names":[],"sources":["../../../src/interpreter/splitAndJoinInsertion.ts"],"mappings":";qBAaa,yBAA0B,SAAO,kBAC5B,SACR,eAAe;EACpB;EAAmB,gBAAgB"}
+{"version":3,"file":"splitAndJoinInsertion.d.ts","names":[],"sources":["../../../src/interpreter/splitAndJoinInsertion.ts"],"mappings":"A,qBAaa,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
  * that two paths pointing to the same page compare equal — useful for
@@ -60,5 +59,4 @@ export declare const normalizePath: <const L extends LocalesValues = DeclaredLoc
  * @returns `true` when both inputs resolve to the same locale-agnostic path.
  */
 export declare const comparePaths: <const L extends LocalesValues = DeclaredLocales>(pathname: string, href: string, locales?: L[]) => boolean;
-//#endregion
 //# sourceMappingURL=comparePaths.d.ts.map

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

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

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

@@ -1,6 +1,5 @@
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 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' }`).
@@ -63,5 +62,4 @@ export declare const getLocaleFromDomain: (hostname: string, domains: LocaleDoma
  * @returns `true` when the locale has a domain shared with no other locale.
  */
 export declare const isLocaleExclusiveOnDomain: (locale: LocalesValues, domains: LocaleDomainMap) => boolean;
-//#endregion
 //# sourceMappingURL=domainUtils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"domainUtils.d.ts","names":[],"sources":["../../../src/localization/domainUtils.ts"],"mappings":";;;;;;;YAUY,kBAAkB;;;;;;;;;;;;;;qBAejB,oBAAiB;;;;;;;;;;;;;;;qBAsBjB,kBAAe;;;;;;;;;;;;;;;;;qBAmBf,sBAAmB,kBACd,SACP,oBACR;;;;;;;;;;;qBAuBU,4BAAyB,QAC5B,eAAa,SACZ"}
+{"version":3,"file":"domainUtils.d.ts","names":[],"sources":["../../../src/localization/domainUtils.ts"],"mappings":";;;;;;YAUY,kBAAkB;;;;;;;;;;;;;;qBAejB,oBAAiB;;;;;;;;;;;;;;;qBAsBjB,kBAAe;;;;;;;;;;;;;;;;;qBAmBf,sBAAmB,kBACd,SACP,oBACR;;;;;;;;;;;qBAuBU,4BAAyB,QAC5B,eAAa,SACZ"}

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

@@ -1,6 +1,5 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { RoutingConfig } from "@intlayer/types/config";
-//#region src/localization/generateSitemap.d.ts
 export type SitemapUrlEntry = {
   /** The canonical path, e.g. '/dashboard' */
   path: string;
@@ -115,5 +114,4 @@ export declare const generateSitemapUrl: (path: string, options: SitemapUrlEntry
  * @returns A full XML sitemap string.
  */
 export declare const generateSitemap: (entries: SitemapUrlEntry[], options: GenerateSitemapOptions) => string;
-//#endregion
 //# sourceMappingURL=generateSitemap.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"generateSitemap.d.ts","names":[],"sources":["../../../src/localization/generateSitemap.ts"],"mappings":";;;YAMY;;EAEV;EACA;EACA;;EAEA;;YAGU;;EAEV;;;;;;;;;;;;;EAaA;;;;;;;;;;;;;;;;;;;;;EAqBA;EACA,UAAU;EACV,gBAAgB;EAChB,OAAO;EACP,UAAU;EACV,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsFC,qBAAkB,cACjB,SACH,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAuFhB,kBAAe,SACjB,mBAAiB,SACjB"}
+{"version":3,"file":"generateSitemap.d.ts","names":[],"sources":["../../../src/localization/generateSitemap.ts"],"mappings":";;YAMY;;EAEV;EACA;EACA;;EAEA;;YAGU;;EAEV;;;;;;;;;;;;;EAaA;;;;;;;;;;;;;;;;;;;;;EAqBA;EACA,UAAU;EACV,gBAAgB;EAChB,OAAO;EACP,UAAU;EACV,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsFC,qBAAkB,cACjB,SACH,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAuFhB,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
 export declare enum LanguageDetector {
   Querystring = "querystring",
   Storage = "storage",
@@ -27,5 +26,5 @@ type LanguageDetectorOptions = {
  * const locale = getBrowserLocale({ order: [LanguageDetector.Storage, LanguageDetector.Navigator] });
  */
 export declare const getBrowserLocale: (userOptions?: LanguageDetectorOptions | undefined) => Locale;
-//#endregion
+export {};
 //# sourceMappingURL=getBrowserLocale.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getBrowserLocale.d.ts","names":[],"sources":["../../../src/localization/getBrowserLocale.tsx"],"mappings":";;oBAMY;EACV;EACA;EACA;EACA;;KAIG;EACH,QAAQ;EACR;EACA,UAAU;;;;;;;;;;;;;;;;;qBA4JC,mBAAgB,cACd,wCACZ"}
+{"version":3,"file":"getBrowserLocale.d.ts","names":[],"sources":["../../../src/localization/getBrowserLocale.tsx"],"mappings":";oBAMY;EACV;EACA;EACA;EACA;;KAIG;EACH,QAAQ;EACR;EACA,UAAU;;;;;;;;;;;;;;;;;qBA4JC,mBAAgB,cACd,wCACZ"}

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

@@ -1,6 +1,5 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { RewriteRules, RoutingConfig } from "@intlayer/types/config";
-//#region src/localization/getCanonicalPath.d.ts
 /**
  * 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.
@@ -14,5 +13,4 @@ import { RewriteRules, RoutingConfig } from "@intlayer/types/config";
  *   rules. Defaults to the project configuration's `routing.rewrite`.
  */
 export declare const getCanonicalPath: <const Path extends string, const Locale extends LocalesValues = LocalesValues>(localizedPath: Path, locale?: Locale, rewriteRules?: RoutingConfig['rewrite'] | RewriteRules) => string;
-//#endregion
 //# sourceMappingURL=getCanonicalPath.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getCanonicalPath.d.ts","names":[],"sources":["../../../src/localization/getCanonicalPath.ts"],"mappings":";;;;;;;;;;;;;;;qBAkCa,yBACL,2BACA,eAAe,gBAAgB,eAAa,eAEnC,MAAI,SACV,QAAM,eACA,2BAA2B"}
+{"version":3,"file":"getCanonicalPath.d.ts","names":[],"sources":["../../../src/localization/getCanonicalPath.ts"],"mappings":";;;;;;;;;;;;;;qBAkCa,yBACL,2BACA,eAAe,gBAAgB,eAAa,eAEnC,MAAI,SACV,QAAM,eACA,2BAA2B"}

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';
 /**
  * Returns the text direction of the given locale.
@@ -15,5 +14,5 @@ type Dir = 'ltr' | 'rtl' | 'auto';
  * @returns The text direction of the given locale.
  */
 export declare const getHTMLTextDir: (locale?: LocalesValues) => Dir;
-//#endregion
+export {};
 //# sourceMappingURL=getHTMLTextDir.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getHTMLTextDir.d.ts","names":[],"sources":["../../../src/localization/getHTMLTextDir.ts"],"mappings":";;KAEK;;;;;;;;;;;;;;qBA0BQ,iBAAc,SAAa,kBAAgB"}
+{"version":3,"file":"getHTMLTextDir.d.ts","names":[],"sources":["../../../src/localization/getHTMLTextDir.ts"],"mappings":";KAEK;;;;;;;;;;;;;;qBA0BQ,iBAAc,SAAa,kBAAgB"}

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

@@ -1,9 +1,7 @@
 import { DeclaredLocales } from "@intlayer/types/module_augmentation";
-//#region src/localization/getLocale.d.ts
 export type RequestContext = {
   getHeader?: (name: string) => string | null | undefined;
   getCookie?: (name: string) => string | null | undefined;
 };
 export declare const getLocale: (ctx?: RequestContext) => Promise<DeclaredLocales>;
-//#endregion
 //# sourceMappingURL=getLocale.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getLocale.d.ts","names":[],"sources":["../../../src/localization/getLocale.ts"],"mappings":";;YAOY;EACV,aAAa;EACb,aAAa;;qBAGF,YAAS,MACf,mBACJ,QAAQ"}
+{"version":3,"file":"getLocale.d.ts","names":[],"sources":["../../../src/localization/getLocale.ts"],"mappings":";YAOY;EACV,aAAa;EACb,aAAa;;qBAGF,YAAS,MACf,mBACJ,QAAQ"}

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

@@ -1,6 +1,5 @@
 import { RoutingOptions } from "./getPrefix.js";
 import { DeclaredLocales } from "@intlayer/types/module_augmentation";
-//#region src/localization/getLocaleFromPath.d.ts
 /**
  * Extracts the locale segment from the given URL or pathname based on the routing mode.
  *
@@ -14,5 +13,4 @@ import { DeclaredLocales } from "@intlayer/types/module_augmentation";
  * @returns The detected locale, default locale (if fallback/implicit), or undefined.
  */
 export declare const getLocaleFromPath: (inputUrl?: string, options?: RoutingOptions) => DeclaredLocales | undefined;
-//#endregion
 //# sourceMappingURL=getLocaleFromPath.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getLocaleFromPath.d.ts","names":[],"sources":["../../../src/localization/getLocaleFromPath.ts"],"mappings":";;;;;;;;;;;;;;;qBAoBa,oBAAiB,mBACZ,UACN,mBACT"}
+{"version":3,"file":"getLocaleFromPath.d.ts","names":[],"sources":["../../../src/localization/getLocaleFromPath.ts"],"mappings":";;;;;;;;;;;;;;qBAoBa,oBAAiB,mBACZ,UACN,mBACT"}

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

@@ -1,5 +1,4 @@
 import { DeclaredLocales } from "@intlayer/types/module_augmentation";
-//#region src/localization/getLocaleFromRequest.d.ts
 /**
  * The part of a Web `Request` (or of a framework request context such as a
  * Remix `RequestContext`) the locale is resolved from.
@@ -22,5 +21,4 @@ export type LocaleRequest = {
  * ```
  */
 export declare const getLocaleFromRequest: ({ url, headers }: LocaleRequest) => Promise<DeclaredLocales>;
-//#endregion
 //# sourceMappingURL=getLocaleFromRequest.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getLocaleFromRequest.d.ts","names":[],"sources":["../../../src/localization/getLocaleFromRequest.ts"],"mappings":";;;;;;YAyCY;EACV,cAAc;EACd,SAAS;;;;;;;;;;;;;;;qBA2CE,yBAAoB,KAAA,WAG9B,kBAAgB,QAAQ"}
+{"version":3,"file":"getLocaleFromRequest.d.ts","names":[],"sources":["../../../src/localization/getLocaleFromRequest.ts"],"mappings":";;;;;YAyCY;EACV,cAAc;EACd,SAAS;;;;;;;;;;;;;;;qBA2CE,yBAAoB,KAAA,WAG9B,kBAAgB,QAAQ"}

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.
  *
@@ -14,5 +13,4 @@ import { GetLocaleLang, LocalesValues } from "@intlayer/types/module_augmentatio
  * @returns The language code of the given locale.
  */
 export declare const getLocaleLang: <const L extends LocalesValues>(locale?: L) => GetLocaleLang<L & string>;
-//#endregion
 //# sourceMappingURL=getLocaleLang.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getLocaleLang.d.ts","names":[],"sources":["../../../src/localization/getLocaleLang.ts"],"mappings":";;;;;;;;;;;;;;;qBAkBa,sBAAuB,UAAU,eAAa,SAChD,MACR,cAAc"}
+{"version":3,"file":"getLocaleLang.d.ts","names":[],"sources":["../../../src/localization/getLocaleLang.ts"],"mappings":";;;;;;;;;;;;;;qBAkBa,sBAAuB,UAAU,eAAa,SAChD,MACR,cAAc"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"getLocaleName.d.ts","names":[],"sources":["../../../src/localization/getLocaleName.ts"],"mappings":";;qBAGa,gBAAa,eACT,eAAa,eACd"}
+{"version":3,"file":"getLocaleName.d.ts","names":[],"sources":["../../../src/localization/getLocaleName.ts"],"mappings":";qBAGa,gBAAa,eACT,eAAa,eACd"}