@intlayer/core 9.4.3 → 9.4.4

package/dist/types/dictionaryManipulator/qualifiedDictionary.d.ts

@@ -5,13 +5,13 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  * Separator joining per-dimension ids into a composite entry id. Also used as
  * the chunk path separator in dynamic mode.
  */
-declare const COMPOSITE_ID_SEPARATOR = "/";
+export declare const COMPOSITE_ID_SEPARATOR = "/";
 /**
  * Identity of the implicit fallback variant. A selector that pins no variant
  * resolves to it, and a variant that declares no entry of its own falls back to
  * it — so a key only has to ship the entries that actually differ.
  */
-declare const DEFAULT_VARIANT_ID = "default";
+export declare const DEFAULT_VARIANT_ID = "default";
 /**
  * Canonical serialization of a single variant value into its identity string —
  * the variant segment of a composite id, the chunk directory name in dynamic
@@ -30,7 +30,7 @@ declare const DEFAULT_VARIANT_ID = "default";
  * Two variants resolve to the same entry iff their serializations are equal, so
  * an object variant in a selector must equal the one declared on the dictionary.
  */
-declare const serializeVariant: (variant: DictionaryVariantValue | undefined) => string;
+export declare const serializeVariant: (variant: DictionaryVariantValue | undefined) => string;
 /**
  * Serializes the variant coordinate of a selector into the ordered list of
  * candidate ids to try, so a single value and a preference chain share one code
@@ -43,7 +43,7 @@ declare const serializeVariant: (variant: DictionaryVariantValue | undefined) =>
  * An empty chain is treated as "no variant pinned" (`['default']`) rather than
  * as an unsatisfiable request.
  */
-declare const serializeVariantChain: (variant: DictionaryVariantChain | undefined) => string[];
+export declare const serializeVariantChain: (variant: DictionaryVariantChain | undefined) => string[];
 /**
  * Resolves the variant id a selector actually targets among the ids a key
  * declares — the sparse-override fallback.
@@ -59,13 +59,13 @@ declare const serializeVariantChain: (variant: DictionaryVariantChain | undefine
  *                              list).
  * @param isVariantIdDeclared - Whether the key declares an entry for an id.
  */
-declare const resolveEffectiveVariantId: (requestedVariantIds: string[], isVariantIdDeclared: (variantId: string) => boolean) => string;
+export declare const resolveEffectiveVariantId: (requestedVariantIds: string[], isVariantIdDeclared: (variantId: string) => boolean) => string;
 /**
  * Type guard discriminating a `QualifiedDictionaryGroup` (merge output of a
  * qualified key) from a plain `Dictionary`. Both carry a `content` field; only
  * the group declares `qualifierTypes`, which is therefore the discriminator.
  */
-declare const isQualifiedDictionaryGroup: (value: unknown) => value is QualifiedDictionaryGroup;
+export declare const isQualifiedDictionaryGroup: (value: unknown) => value is QualifiedDictionaryGroup;
 /**
  * Reconstructs a resolvable {@link Dictionary} from a single entry of a
  * qualified group: the content node stored under its composite id, plus the
@@ -77,7 +77,7 @@ declare const isQualifiedDictionaryGroup: (value: unknown) => value is Qualified
  * its serialized (encoded) form, e.g. `'id=abc&userId=123'` — matching happens
  * on the composite id segments, never on this reconstructed field.
  */
-declare const reconstructQualifiedEntry: (group: QualifiedDictionaryGroup, compositeId: string) => Dictionary;
+export declare const reconstructQualifiedEntry: (group: QualifiedDictionaryGroup, compositeId: string) => Dictionary;
 /**
  * Resolves a dictionary (or qualified dictionary group) against a selector,
  * across every declared dimension.
@@ -93,12 +93,12 @@ declare const reconstructQualifiedEntry: (group: QualifiedDictionaryGroup, compo
  * Dimensions compose: e.g. a variant × item key with `{ variant: 'promo' }`
  * returns every promo item as an array; adding `{ item: 2 }` narrows to one.
  */
-declare const resolveQualifiedDictionary: (dictionaryOrGroup: Dictionary | QualifiedDictionaryGroup, selector?: DictionarySelector) => Dictionary | Dictionary[] | null;
+export declare const resolveQualifiedDictionary: (dictionaryOrGroup: Dictionary | QualifiedDictionaryGroup, selector?: DictionarySelector) => Dictionary | Dictionary[] | null;
 /**
  * Splits the second argument of `getIntlayer` / `getDictionary` into the
  * effective locale and the selector object (if any).
  */
-declare const parseDictionarySelector: <L extends LocalesValues>(localeOrSelector?: L | DictionarySelector) => {
+export declare const parseDictionarySelector: <L extends LocalesValues>(localeOrSelector?: L | DictionarySelector) => {
   locale?: L;
   selector?: DictionarySelector;
 };
@@ -117,7 +117,7 @@ declare const parseDictionarySelector: <L extends LocalesValues>(localeOrSelecto
  * @param providerVariant - The `variant` prop of the surrounding provider.
  * @param dictionaryKey - The key being read.
  */
-declare const resolveProviderVariant: (providerVariant: ProviderVariant | undefined, dictionaryKey: string) => DictionaryVariantChain | undefined;
+export declare const resolveProviderVariant: (providerVariant: ProviderVariant | undefined, dictionaryKey: string) => DictionaryVariantChain | undefined;
 /**
  * Builds the effective second argument of a dictionary read by layering the
  * provider defaults under the call-site one — the single place the `locale` and
@@ -132,7 +132,7 @@ declare const resolveProviderVariant: (providerVariant: ProviderVariant | undefi
  * so the existing fast path — and the cache keys built from it — are unchanged
  * for projects that never use variants.
  */
-declare const resolveDictionaryArgument: (params: {
+export declare const resolveDictionaryArgument: (params: {
   localeOrSelector?: LocalesValues | DictionarySelector;
   contextLocale?: LocalesValues;
   contextVariant?: ProviderVariant;
@@ -142,7 +142,6 @@ declare const resolveDictionaryArgument: (params: {
  * Builds a stable string identity of a selector (excluding `locale`), suitable
  * for cache keys and memoization dependencies.
  */
-declare const getDictionarySelectorCacheKey: (selector?: DictionarySelector) => string;
+export declare const getDictionarySelectorCacheKey: (selector?: DictionarySelector) => string;
 //#endregion
-export { COMPOSITE_ID_SEPARATOR, DEFAULT_VARIANT_ID, getDictionarySelectorCacheKey, isQualifiedDictionaryGroup, parseDictionarySelector, reconstructQualifiedEntry, resolveDictionaryArgument, resolveEffectiveVariantId, resolveProviderVariant, resolveQualifiedDictionary, serializeVariant, serializeVariantChain };
 //# sourceMappingURL=qualifiedDictionary.d.ts.map

package/dist/types/dictionaryManipulator/qualifiedDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qualifiedDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"mappings":";;;;;;;cAgBa;;;;;;cAOA;;;;;;;;;;;;;;;;;;;cAqDA,mBAAgB,SAClB;;;;;;;;;;;;;cA4BE,wBAAqB,SACvB;;;;;;;;;;;;;;;;cA0BE,4BAAyB,+BACP,sBACP;;;;;;cA4CX,6BAA0B,mBAEpC,SAAS;;;;;;;;;;;;cAkBC,4BAAyB,OAC7B,0BAAwB,wBAE9B;;;;;;;;;;;;;;;;cAkCU,6BAA0B,mBAClB,aAAa,0BAAwB,WAC7C,uBACV,aAAa;;;;;cAoDH,0BAA2B,UAAU,eAAa,mBAC1C,IAAI;EACpB,SAAS;EAAG,WAAW;;;;;;;;;;;;;;;;;cA0Bf,yBAAsB,iBAChB,6BAA2B,0BAE3C;;;;;;;;;;;;;;;cA0BU,4BAAyB;EACpC,mBAAmB,gBAAgB;EACnC,gBAAgB;EAChB,iBAAiB;EACjB;MACE,gBAAgB;;;;;cAqCP,gCAA6B,WAC7B"}
+{"version":3,"file":"qualifiedDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"mappings":";;;;;;;qBAgBa;;;;;;qBAOA;;;;;;;;;;;;;;;;;;;qBAqDA,mBAAgB,SAClB;;;;;;;;;;;;;qBA4BE,wBAAqB,SACvB;;;;;;;;;;;;;;;;qBA0BE,4BAAyB,+BACP,sBACP;;;;;;qBA4CX,6BAA0B,mBAEpC,SAAS;;;;;;;;;;;;qBAkBC,4BAAyB,OAC7B,0BAAwB,wBAE9B;;;;;;;;;;;;;;;;qBAkCU,6BAA0B,mBAClB,aAAa,0BAAwB,WAC7C,uBACV,aAAa;;;;;qBAoDH,0BAA2B,UAAU,eAAa,mBAC1C,IAAI;EACpB,SAAS;EAAG,WAAW;;;;;;;;;;;;;;;;;qBA0Bf,yBAAsB,iBAChB,6BAA2B,0BAE3C;;;;;;;;;;;;;;;qBA0BU,4BAAyB;EACpC,mBAAmB,gBAAgB;EACnC,gBAAgB;EAChB,iBAAiB;EACjB;MACE,gBAAgB;;;;;qBAqCP,gCAA6B,WAC7B"}

package/dist/types/dictionaryManipulator/qualifiedDictionaryDeclaration.d.ts

@@ -5,7 +5,7 @@ import { Dictionary, DictionaryQualifierType } from "@intlayer/types/dictionary"
  * always nests them in this order, with `item` innermost so it can act as the
  * collection (array) axis.
  */
-declare const QUALIFIER_ORDER: readonly ["variant", "item"];
+export declare const QUALIFIER_ORDER: readonly ["variant", "item"];
 /**
  * Normalizes the `variant` field of a dictionary into the list of variant ids
  * the declaration registers under. A single value yields one id; an **array**
@@ -13,13 +13,13 @@ declare const QUALIFIER_ORDER: readonly ["variant", "item"];
  * when the dictionary does not declare the variant dimension (no `variant`
  * field, or an empty array).
  */
-declare const getVariantIds: (variant: Dictionary['variant']) => string[] | undefined;
+export declare const getVariantIds: (variant: Dictionary['variant']) => string[] | undefined;
 /**
  * Returns the qualifier dimensions declared on a dictionary, in canonical
  * order (`variant → item`). Empty when the dictionary is unqualified
  * (plain dictionary or shared base content of a qualified group).
  */
-declare const getDictionaryQualifierTypes: (dictionary: Dictionary) => DictionaryQualifierType[];
+export declare const getDictionaryQualifierTypes: (dictionary: Dictionary) => DictionaryQualifierType[];
 /**
  * Returns the qualifier identifiers of a dictionary for the given qualifier
  * dimension — the candidate segments of the composite entry ids.
@@ -28,14 +28,13 @@ declare const getDictionaryQualifierTypes: (dictionary: Dictionary) => Dictionar
  *   per element (declaration-side fan-out)
  * - 'item' → the item index as a single-element list
  */
-declare const getDictionaryQualifierIds: (dictionary: Dictionary, qualifierType: DictionaryQualifierType) => string[] | undefined;
+export declare const getDictionaryQualifierIds: (dictionary: Dictionary, qualifierType: DictionaryQualifierType) => string[] | undefined;
 /**
  * Builds every composite entry id of a dictionary — the cartesian product of
  * its per-dimension id lists, joined in canonical order. A dictionary with a
  * plain (non-array) variant yields exactly one id; an array variant fans out
  * into one id per element. `undefined` when a dimension of the set is missing.
  */
-declare const getDictionaryCompositeIds: (dictionary: Dictionary, qualifierTypes: DictionaryQualifierType[]) => string[] | undefined;
+export declare const getDictionaryCompositeIds: (dictionary: Dictionary, qualifierTypes: DictionaryQualifierType[]) => string[] | undefined;
 //#endregion
-export { QUALIFIER_ORDER, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getVariantIds };
 //# sourceMappingURL=qualifiedDictionaryDeclaration.d.ts.map

package/dist/types/dictionaryManipulator/qualifiedDictionaryDeclaration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qualifiedDictionaryDeclaration.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionaryDeclaration.ts"],"mappings":";;;;;;;cAca;;;;;;;;cAYA,gBAAa,SACf;;;;;;cAeE,8BAA2B,YAC1B,eACX;;;;;;;;;cAmBU,4BAAyB,YACxB,YAAU,eACP;;;;;;;cAcJ,4BAAyB,YACxB,YAAU,gBACN"}
+{"version":3,"file":"qualifiedDictionaryDeclaration.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionaryDeclaration.ts"],"mappings":";;;;;;;qBAca;;;;;;;;qBAYA,gBAAa,SACf;;;;;;qBAeE,8BAA2B,YAC1B,eACX;;;;;;;;;qBAmBU,4BAAyB,YACxB,YAAU,eACP;;;;;;;qBAcJ,4BAAyB,YACxB,YAAU,gBACN"}

package/dist/types/dictionaryManipulator/qualifiedDynamicLoader.d.ts

@@ -4,12 +4,12 @@ import { QUALIFIER_DYNAMIC_TYPES_KEY } from "@intlayer/config/defaultValues";
 /**
  * A lazily-imported per-locale dictionary chunk loader.
  */
-type DynamicDictionaryLoader = () => Promise<Dictionary>;
+export type DynamicDictionaryLoader = () => Promise<Dictionary>;
 /**
  * Nested tree of chunk loaders: one nesting level per declared dimension (in
  * canonical order), leaves are loaders.
  */
-type QualifiedDynamicLoaderTree = {
+export type QualifiedDynamicLoaderTree = {
   [segment: string]: QualifiedDynamicLoaderTree | DynamicDictionaryLoader;
 };
 /**
@@ -24,7 +24,7 @@ type QualifiedDynamicLoaderTree = {
  * }
  * ```
  */
-type QualifiedDynamicLoaderMap = {
+export type QualifiedDynamicLoaderMap = {
   [QUALIFIER_DYNAMIC_TYPES_KEY]: DictionaryQualifierType[];
   [locale: string]: QualifiedDynamicLoaderTree | DictionaryQualifierType[];
 };
@@ -32,7 +32,7 @@ type QualifiedDynamicLoaderMap = {
  * Type guard discriminating a qualified dynamic loader map (collections /
  * variants, possibly combined) from a plain dynamic loader map.
  */
-declare const isQualifiedDynamicLoaderMap: (value: unknown) => value is QualifiedDynamicLoaderMap;
+export declare const isQualifiedDynamicLoaderMap: (value: unknown) => value is QualifiedDynamicLoaderMap;
 /**
  * Resolves the content of a qualified dynamic loader map against a selector,
  * loading only the chunk(s) the selector actually targets.
@@ -56,7 +56,7 @@ declare const isQualifiedDynamicLoaderMap: (value: unknown) => value is Qualifie
  * @param loadChunk - Reads a started chunk promise, suspending until it resolves.
  * @param transform - Turns a resolved chunk dictionary into final content.
  */
-declare const resolveQualifiedDynamicContent: <Content>(params: {
+export declare const resolveQualifiedDynamicContent: <Content>(params: {
   loaderMap: QualifiedDynamicLoaderMap;
   key: string;
   locale: string;
@@ -75,7 +75,7 @@ declare const resolveQualifiedDynamicContent: <Content>(params: {
  * @param selector - The selector splitting the qualifier dimensions.
  * @param transform - Turns a resolved chunk dictionary into final content.
  */
-declare const resolveQualifiedDynamicContentAsync: <Content>(params: {
+export declare const resolveQualifiedDynamicContentAsync: <Content>(params: {
   loaderMap: QualifiedDynamicLoaderMap;
   key: string;
   locale: string;
@@ -83,5 +83,5 @@ declare const resolveQualifiedDynamicContentAsync: <Content>(params: {
   transform: (dictionary: Dictionary) => Content;
 }) => Promise<Content | Content[] | null>;
 //#endregion
-export { DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, isQualifiedDynamicLoaderMap, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync };
+export { QUALIFIER_DYNAMIC_TYPES_KEY };
 //# sourceMappingURL=qualifiedDynamicLoader.d.ts.map

package/dist/types/dictionaryManipulator/qualifiedDynamicLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qualifiedDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDynamicLoader.ts"],"mappings":";;;;;;KAuBY,gCAAgC,QAAQ;;;;;KAMxC;GACT,kBAAkB,6BAA6B;;;;;;;;;;;;;;KAetC;GACT,8BAA8B;GAC9B,iBAAiB,6BAA6B;;;;;;cAOpC,8BAA2B,mBAErC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;cAiHC,iCAAkC,SAAO;EACpD,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,kBAAkB,SAAS,QAAQ,gBAAgB;EAC/D,YAAY,YAAY,eAAe;MACrC,UAAU;;;;;;;;;;;;cAkCD,sCAA6C,SAAO;EAC/D,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,YAAY,eAAe;MACrC,QAAQ,UAAU"}
+{"version":3,"file":"qualifiedDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDynamicLoader.ts"],"mappings":";;;;;;YAuBY,gCAAgC,QAAQ;;;;;YAMxC;GACT,kBAAkB,6BAA6B;;;;;;;;;;;;;;YAetC;GACT,8BAA8B;GAC9B,iBAAiB,6BAA6B;;;;;;qBAOpC,8BAA2B,mBAErC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;qBAiHC,iCAAkC,SAAO;EACpD,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,kBAAkB,SAAS,QAAQ,gBAAgB;EAC/D,YAAY,YAAY,eAAe;MACrC,UAAU;;;;;;;;;;;;qBAkCD,sCAA6C,SAAO;EAC/D,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,YAAY,eAAe;MACrC,QAAQ,UAAU"}

package/dist/types/dictionaryManipulator/removeContentNodeByKeyPath.d.ts

@@ -1,7 +1,6 @@
 import { ContentNode } from "@intlayer/types/dictionary";
 import { KeyPath } from "@intlayer/types/keyPath";
 //#region src/dictionaryManipulator/removeContentNodeByKeyPath.d.ts
-declare const removeContentNodeByKeyPath: (dictionaryContent: ContentNode, keyPath: KeyPath[]) => ContentNode;
+export declare const removeContentNodeByKeyPath: (dictionaryContent: ContentNode, keyPath: KeyPath[]) => ContentNode;
 //#endregion
-export { removeContentNodeByKeyPath };
 //# sourceMappingURL=removeContentNodeByKeyPath.d.ts.map

package/dist/types/dictionaryManipulator/removeContentNodeByKeyPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"removeContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/removeContentNodeByKeyPath.ts"],"mappings":";;;cAKa,6BAA0B,mBAClB,aAAW,SACrB,cACR"}
+{"version":3,"file":"removeContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/removeContentNodeByKeyPath.ts"],"mappings":";;;qBAKa,6BAA0B,mBAClB,aAAW,SACrB,cACR"}

package/dist/types/dictionaryManipulator/renameContentNodeByKeyPath.d.ts

@@ -1,7 +1,6 @@
 import { ContentNode } from "@intlayer/types/dictionary";
 import { KeyPath } from "@intlayer/types/keyPath";
 //#region src/dictionaryManipulator/renameContentNodeByKeyPath.d.ts
-declare const renameContentNodeByKeyPath: (dictionaryContent: ContentNode, newKey: KeyPath['key'], keyPath: KeyPath[]) => ContentNode;
+export declare const renameContentNodeByKeyPath: (dictionaryContent: ContentNode, newKey: KeyPath['key'], keyPath: KeyPath[]) => ContentNode;
 //#endregion
-export { renameContentNodeByKeyPath };
 //# sourceMappingURL=renameContentNodeByKeyPath.d.ts.map

package/dist/types/dictionaryManipulator/renameContentNodeByKeyPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renameContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/renameContentNodeByKeyPath.ts"],"mappings":";;;cAKa,6BAA0B,mBAClB,aAAW,QACtB,gBAAc,SACb,cACR"}
+{"version":3,"file":"renameContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/renameContentNodeByKeyPath.ts"],"mappings":";;;qBAKa,6BAA0B,mBAClB,aAAW,QACtB,gBAAc,SACb,cACR"}

package/dist/types/dictionaryManipulator/updateNodeChildren.d.ts

@@ -1,6 +1,5 @@
 import { ContentNode } from "@intlayer/types/dictionary";
 //#region src/dictionaryManipulator/updateNodeChildren.d.ts
-declare const updateNodeChildren: <T extends ContentNode, U extends ContentNode>(section: T, newChildren: U) => ContentNode;
+export declare const updateNodeChildren: <T extends ContentNode, U extends ContentNode>(section: T, newChildren: U) => ContentNode;
 //#endregion
-export { updateNodeChildren };
 //# sourceMappingURL=updateNodeChildren.d.ts.map

package/dist/types/dictionaryManipulator/updateNodeChildren.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"updateNodeChildren.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/updateNodeChildren.ts"],"mappings":";;cAIa,qBACX,UAAU,aACV,UAAU,aAAW,SAEZ,GAAC,aACG,MACZ"}
+{"version":3,"file":"updateNodeChildren.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/updateNodeChildren.ts"],"mappings":";;qBAIa,qBACX,UAAU,aACV,UAAU,aAAW,SAEZ,GAAC,aACG,MACZ"}

package/dist/types/formatters/compact.d.ts

@@ -11,9 +11,8 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  * compact("1000000", { locale: Locales.FRENCH, compactDisplay: "long" });
  * // "1 million"
  */
-declare const compact: (value: string | number, options?: Intl.NumberFormatOptions & {
+export declare const compact: (value: string | number, options?: Intl.NumberFormatOptions & {
   locale?: LocalesValues;
 }) => string;
 //#endregion
-export { compact };
 //# sourceMappingURL=compact.d.ts.map

package/dist/types/formatters/compact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compact.d.ts","names":[],"sources":["../../../src/formatters/compact.ts"],"mappings":";;;;;;;;;;;;;cAea,UAAO,wBACI,UACZ,KAAK;EAAwB,SAAS"}
+{"version":3,"file":"compact.d.ts","names":[],"sources":["../../../src/formatters/compact.ts"],"mappings":";;;;;;;;;;;;;qBAea,UAAO,wBACI,UACZ,KAAK;EAAwB,SAAS"}

package/dist/types/formatters/currency.d.ts

@@ -11,9 +11,8 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  * currency("5000", { locale: Locales.FRENCH, currency: "CAD", currencyDisplay: "code" });
  * // "5 000,00 CAD"
  */
-declare const currency: (value: string | number, options?: Intl.NumberFormatOptions & {
+export declare const currency: (value: string | number, options?: Intl.NumberFormatOptions & {
   locale?: LocalesValues;
 }) => string;
 //#endregion
-export { currency };
 //# sourceMappingURL=currency.d.ts.map

package/dist/types/formatters/currency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"currency.d.ts","names":[],"sources":["../../../src/formatters/currency.ts"],"mappings":";;;;;;;;;;;;;cAea,WAAQ,wBACG,UACZ,KAAK;EAAwB,SAAS"}
+{"version":3,"file":"currency.d.ts","names":[],"sources":["../../../src/formatters/currency.ts"],"mappings":";;;;;;;;;;;;;qBAea,WAAQ,wBACG,UACZ,KAAK;EAAwB,SAAS"}

package/dist/types/formatters/date.d.ts

@@ -1,7 +1,7 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/formatters/date.d.ts
-type DateTimePreset = 'short' | 'long' | 'dateOnly' | 'timeOnly' | 'full';
-declare const presets: Record<DateTimePreset, Intl.DateTimeFormatOptions>;
+export type DateTimePreset = 'short' | 'long' | 'dateOnly' | 'timeOnly' | 'full';
+export declare const presets: Record<DateTimePreset, Intl.DateTimeFormatOptions>;
 /**
  * Formats a date/time value into a localized string using Intl.DateTimeFormat.
  *
@@ -13,9 +13,8 @@ declare const presets: Record<DateTimePreset, Intl.DateTimeFormatOptions>;
  * date("2025-08-02T14:30:00Z", { locale: Locales.FRENCH, month: "long", day: "numeric" });
  * // "2 août"
  */
-declare const date: (date: Date | string | number, options?: (Intl.DateTimeFormatOptions & {
+export declare const date: (date: Date | string | number, options?: (Intl.DateTimeFormatOptions & {
   locale?: LocalesValues;
 }) | DateTimePreset) => string;
 //#endregion
-export { DateTimePreset, date, presets };
 //# sourceMappingURL=date.d.ts.map

package/dist/types/formatters/date.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"date.d.ts","names":[],"sources":["../../../src/formatters/date.ts"],"mappings":";;KAIY;cAOC,SAAS,OAAO,gBAAgB,KAAK;;;;;;;;;;;;cA8CrC,OAAI,MACT,wBAAsB,WAEvB,KAAK;EAA0B,SAAS;KACzC"}
+{"version":3,"file":"date.d.ts","names":[],"sources":["../../../src/formatters/date.ts"],"mappings":";;YAIY;qBAOC,SAAS,OAAO,gBAAgB,KAAK;;;;;;;;;;;;qBA8CrC,OAAI,MACT,wBAAsB,WAEvB,KAAK;EAA0B,SAAS;KACzC"}

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

@@ -2,9 +2,9 @@ import { compact } from "./compact.js";
 import { currency } from "./currency.js";
 import { DateTimePreset, date, presets } from "./date.js";
 import { CachedIntl, IntlConstructorName, WrappedIntl, bindIntl, getCachedIntl } from "../utils/intl.js";
-import { list } from "./list.js";
+import { ListFormatOptions, list } from "./list.js";
 import { number } from "./number.js";
 import { percentage } from "./percentage.js";
 import { relativeTime } from "./relativeTime.js";
 import { units } from "./units.js";
-export { CachedIntl, CachedIntl as Intl, DateTimePreset, IntlConstructorName, WrappedIntl, bindIntl, compact, currency, date, getCachedIntl, list, number, percentage, presets, relativeTime, units };
+export { CachedIntl, CachedIntl as Intl, DateTimePreset, IntlConstructorName, ListFormatOptions, WrappedIntl, bindIntl, compact, currency, date, getCachedIntl, list, number, percentage, presets, relativeTime, units };

package/dist/types/formatters/list.d.ts

@@ -1,7 +1,7 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/formatters/list.d.ts
 /** Locally defined subset of Intl.ListFormatOptions so consumers don't need ES2021.Intl in their lib. */
-type ListFormatOptions = {
+export type ListFormatOptions = {
   localeMatcher?: 'lookup' | 'best fit';
   type?: 'conjunction' | 'disjunction' | 'unit';
   style?: 'long' | 'short' | 'narrow';
@@ -21,9 +21,8 @@ type ListFormatOptions = {
  * list([1, 2, 3], { type: 'unit' });
  * // "1, 2, 3"
  */
-declare const list: (values: (string | number)[], options?: ListFormatOptions & {
+export declare const list: (values: (string | number)[], options?: ListFormatOptions & {
   locale?: LocalesValues;
 }) => string;
 //#endregion
-export { list };
 //# sourceMappingURL=list.d.ts.map

package/dist/types/formatters/list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list.d.ts","names":[],"sources":["../../../src/formatters/list.ts"],"mappings":";;;KAKK;EACH;EACA;EACA;;;;;;;;;;;;;;;;;cAkBW,OAAI,6BACY,UACjB;EAAsB,SAAS"}
+{"version":3,"file":"list.d.ts","names":[],"sources":["../../../src/formatters/list.ts"],"mappings":";;;YAKY;EACV;EACA;EACA;;;;;;;;;;;;;;;;;qBAkBW,OAAI,6BACY,UACjB;EAAsB,SAAS"}

package/dist/types/formatters/number.d.ts

@@ -9,9 +9,8 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  * @example
  * number("1000000", { locale: Locales.FRENCH }); // "1 000 000"
  */
-declare const number: (value: string | number, { locale, ...options }?: Intl.NumberFormatOptions & {
+export declare const number: (value: string | number, { locale, ...options }?: Intl.NumberFormatOptions & {
   locale?: LocalesValues;
 }) => string;
 //#endregion
-export { number };
 //# sourceMappingURL=number.d.ts.map

package/dist/types/formatters/number.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"number.d.ts","names":[],"sources":["../../../src/formatters/number.ts"],"mappings":";;;;;;;;;;;cAaa,SAAM,0BACK,WAAA,YAInB,KAAK;EAAwB,SAAS"}
+{"version":3,"file":"number.d.ts","names":[],"sources":["../../../src/formatters/number.ts"],"mappings":";;;;;;;;;;;qBAaa,SAAM,0BACK,WAAA,YAInB,KAAK;EAAwB,SAAS"}

package/dist/types/formatters/percentage.d.ts

@@ -9,9 +9,8 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  * @example
  * percentage(0.25, { minimumFractionDigits: 2 }); // "25.00%"
  */
-declare const percentage: (value: string | number, { locale, ...options }?: Intl.NumberFormatOptions & {
+export declare const percentage: (value: string | number, { locale, ...options }?: Intl.NumberFormatOptions & {
   locale?: LocalesValues;
 }) => string;
 //#endregion
-export { percentage };
 //# sourceMappingURL=percentage.d.ts.map

package/dist/types/formatters/percentage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"percentage.d.ts","names":[],"sources":["../../../src/formatters/percentage.ts"],"mappings":";;;;;;;;;;;cAaa,aAAU,0BACC,WAAA,YAInB,KAAK;EAAwB,SAAS"}
+{"version":3,"file":"percentage.d.ts","names":[],"sources":["../../../src/formatters/percentage.ts"],"mappings":";;;;;;;;;;;qBAaa,aAAU,0BACC,WAAA,YAInB,KAAK;EAAwB,SAAS"}

package/dist/types/formatters/relativeTime.d.ts

@@ -11,10 +11,9 @@ type RelativeTimeUnit = Intl.RelativeTimeFormatUnit;
  * relativeTime("2025-01-01", new Date(), { locale: Locales.FRENCH, unit: "day" });
  * // "il y a 443 jours"
  */
-declare const relativeTime: (from: Date | string | number, to?: Date | string | number, options?: Intl.RelativeTimeFormatOptions & {
+export declare const relativeTime: (from: Date | string | number, to?: Date | string | number, options?: Intl.RelativeTimeFormatOptions & {
   locale?: LocalesValues;
   unit?: RelativeTimeUnit;
 }) => string;
 //#endregion
-export { relativeTime };
 //# sourceMappingURL=relativeTime.d.ts.map

package/dist/types/formatters/relativeTime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"relativeTime.d.ts","names":[],"sources":["../../../src/formatters/relativeTime.ts"],"mappings":";;KAIK,mBAAmB,KAAK;;;;;;;;;;;cAuChB,eAAY,MACjB,wBAAsB,KACxB,wBAAsB,UAChB,KAAK;EACb,SAAS;EACT,OAAO"}
+{"version":3,"file":"relativeTime.d.ts","names":[],"sources":["../../../src/formatters/relativeTime.ts"],"mappings":";;KAIK,mBAAmB,KAAK;;;;;;;;;;;qBAuChB,eAAY,MACjB,wBAAsB,KACxB,wBAAsB,UAChB,KAAK;EACb,SAAS;EACT,OAAO"}

package/dist/types/formatters/units.d.ts

@@ -7,9 +7,8 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  * units(5, { unit: "kilometer", unitDisplay: "long", locale: "en-GB" });
  * // "5 kilometers"
  */
-declare const units: (value: number | string, options?: Intl.NumberFormatOptions & {
+export declare const units: (value: number | string, options?: Intl.NumberFormatOptions & {
   locale?: LocalesValues;
 }) => string;
 //#endregion
-export { units };
 //# sourceMappingURL=units.d.ts.map

package/dist/types/formatters/units.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"units.d.ts","names":[],"sources":["../../../src/formatters/units.ts"],"mappings":";;;;;;;;;cAWa,QAAK,wBACM,UACZ,KAAK;EAAwB,SAAS"}
+{"version":3,"file":"units.d.ts","names":[],"sources":["../../../src/formatters/units.ts"],"mappings":";;;;;;;;;qBAWa,QAAK,wBACM,UACZ,KAAK;EAAwB,SAAS"}

package/dist/types/index.d.ts

@@ -71,7 +71,7 @@ import { compact } from "./formatters/compact.js";
 import { currency } from "./formatters/currency.js";
 import { DateTimePreset, date, presets } from "./formatters/date.js";
 import { CachedIntl, IntlConstructorName, WrappedIntl, bindIntl, getCachedIntl } from "./utils/intl.js";
-import { list } from "./formatters/list.js";
+import { ListFormatOptions, list } from "./formatters/list.js";
 import { number } from "./formatters/number.js";
 import { percentage } from "./formatters/percentage.js";
 import { relativeTime } from "./formatters/relativeTime.js";
@@ -123,4 +123,4 @@ import { CookieBuildAttributes, LocaleStorage, LocaleStorageClient, LocaleStorag
 import { YamlRecord, YamlValue, parseYaml } from "./utils/parseYaml.js";
 import { stringifyYaml } from "./utils/stringifyYaml.js";
 import "./utils/index.js";
-export { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, type BlockQuoteNode, type BoldTextNode, type BreakLineNode, type BreakThematicNode, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, COMPOSITE_ID_SEPARATOR, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_OPENING_TAG_R, CUSTOM_COMPONENT_R, CachedIntl, CachedIntl as Intl, type CodeBlockNode, type CodeFencedNode, type CodeInlineNode, type CompileOptions, type ComponentOverrides, ConditionCond, ConditionContent, ConditionContentStates, CookieBuildAttributes, type CustomComponentNode, DEFAULT_VARIANT_ID, DO_NOT_PROCESS_HTML_ELEMENTS, DateTimePreset, DeepTransformContent, DotPath, DynamicDictionaryLoader, type ElementType, EnterFormat, EnumerationCond, EnumerationContent, EnumerationContentState, type EscapedTextNode, FENCE_DELIMITER_R, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, FileCond, type FileContent, type FileContentConstructor, type FootnoteNode, type FootnoteReferenceNode, type GFMTaskNode, GFM_TASK_R, Gender, GenderCond, GenderContent, GenderContentStates, type GenerateSitemapOptions, GetNestingResult, type GetPrefixOptions, type GetPrefixResult, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, type HTMLCommentNode, HTMLContent, HTMLContentConstructor, type HTMLNode, type HTMLSelfClosingNode, type HTMLTag, HTMLTagsType, HTMLValidationIssue, HTMLValidationResult, HTML_BLOCK_ELEMENT_R, HTML_BLOCK_OPENING_TAG_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, HTML_SELF_CLOSING_OPENING_TAG_R, HTML_TAGS, type HeadingNode, type HeadingSetextNode, IInterpreterPlugin, IInterpreterPluginState, INLINE_SKIP_R, INTERPOLATION_R, type ImageNode, InsertionCond, InsertionContent, InsertionContentConstructor, InterpolableNode, IntlConstructorName, IsAny, type ItalicTextNode, JsonValue, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LOOKAHEAD, type LinkAngleBraceNode, type LinkBareURLNode, type LinkNode, ListType, type LocaleDomainMap, LocaleStorage, LocaleStorageClient, LocaleStorageClientOptions, LocaleStorageOptions, LocaleStorageServer, LocaleStorageServerOptions, type LocalizedPathResult, MarkdownContent, MarkdownContentConstructor, type MarkdownContext, type MarkdownOptions, MarkdownReferences, type MarkdownRuntime, type HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, type MarkedTextNode, MessageFormatDialect, MessageValues, NAMED_CODES_TO_UNICODE, NORMALIZE_WHITESPACE_R, NP_TABLE_R, NestedCond, NestedContent, NestedContentState, NestedFieldReferences, type NestedParser, type NewlineNode, NodeProps, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, type OrderedListNode, PARAGRAPH_R, PRELOADED_DYNAMIC_KEY, type ParagraphNode, type ParseState, ParsedMarkdown, type Parser, type ParserResult, PlainDynamicLoaderMap, Plugins, PluralCategory, PluralCond, PluralContent, PluralContentState, PortableObject, PreloadableDynamicLoaderMap, PreloadedDynamicEntry, Priority, PriorityValue, type ProxyMode, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, type ReferenceImageNode, type ReferenceLinkNode, type ReferenceNode, type RenderRuleHook, ResolvedDynamicLoader, type Rule, type RuleOutput, RuleType, RuleTypeValue, type Rules, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, SelectCond, SelectContent, SelectContentStates, SelectSelector, type SitemapUrlEntry, type StrikethroughTextNode, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, type TableNode, type TableSeparatorNode, TaggedMessageToken, type TextNode, TranslationCond, TranslationContent, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, UnionKeys, type UnorderedListNode, VOID_HTML_ELEMENTS, ValidDotPathsFor, ValueAtKey, WrappedIntl, YamlRecord, YamlValue, allowInline, anyScopeRegex, attributeValueToNodePropValue, bindIntl, blockRegex, buildMaskPlugin, captureNothing, checkIsURLAbsolute, checkMissingLocalesPlugin, compact, comparePaths, compile, compileWithOptions, condition as cond, conditionPlugin, createCompiler, createRenderer, currency, cx, date, deepTransformNode, editDictionaryByKeyPath, enumeration as enu, enumerationPlugin, fallbackPlugin, type file, type fileContent, filePlugin, filterMissingTranslationsOnlyPlugin, filterTranslationsOnlyPlugin, findMatchingCondition, findPlainDynamicLoader, formatProxyEnabledMessage, gender, genderPlugin, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex, generateSitemap, generateSitemapUrl, get, getBasePlugins, getBrowserLocale, getCachedIntl, getCanonicalPath, getCondition, getContent, getContentNodeByKeyPath, getCookie, getDefaultNode, getDictionary, getDictionaryAsync, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getDictionaryTransformCacheKey, getDomainHostname, getDomainOrigin, getEditedContent, getEditedDictionary, getEmptyNode, getEnumeration, getFilterMissingTranslationsContent, getFilterMissingTranslationsDictionary, getFilterTranslationsOnlyContent, getFilterTranslationsOnlyDictionary, getFilteredLocalesContent, getFilteredLocalesDictionary, getGender, getHTML, getHTMLTextDir, getInsertion, getInsertionValues, getInternalPath, getInterpolableContent, getIntlayer, getIntlayerAsync, getLocale, getLocaleFromDomain, getLocaleFromPath, getLocaleFromStorage, getLocaleFromStorageClient, getLocaleFromStorageServer, getLocaleLang, getLocaleName, getLocalizedContent, getLocalizedPath, getLocalizedUrl, getMarkdownMetadata, getMaskContent, getMissingLocalesContent, getMissingLocalesContentFromDictionary, getMultilingualDictionary, getMultilingualUrls, getNestedDictionaryGraph, getNestedDictionaryKeys, getNestedDictionaryReferences, getNesting, getNodeChildren, getNodeType, getPathWithoutLocale, getPerLocaleDictionary, getPluginsCacheKey, getPlural, getPrefix, getPreloadLocale, getPreloadedDictionary, getReplacedValuesContent, getRewritePath, getRewriteRules, getSelect, getSplittedContent, getSplittedDictionaryContent, getTranslation, getVariantIds, html, i18nextToIntlayerFormatter, icuToIntlayerFormatter, inlineRegex, insertion as insert, insertContentInDictionary, insertionPlugin, interpolateMessage, intlayerToI18nextFormatter, intlayerToICUFormatter, intlayerToPortableObjectFormatter, intlayerToVueI18nFormatter, isDeclaredLocale, isInterpolableWrapperNode, isLocaleExclusiveOnDomain, isProxyStorageLocaleEnabled, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, isSameKeyPath, isValidElement, list, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, localeStorageOptions, markdown as md, mergeDictionaries, mergeQualifiedDictionaries, navigatePath, nesting as nest, nestedPlugin, normalizeAttributeKey, normalizeDictionaries, normalizeDictionary, normalizePath, normalizeWhitespace, number, orderDictionaries, parseBlock, parseCaptureInline, parseDictionarySelector, parseInline, parseMarkdown, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, parseTaggedMessage, parseYaml, parserFor, percentage, plural, pluralPlugin, portableObjectToIntlayerFormatter, presets, qualifies, readTransformCache, rebuildInterpolableContent, reconstructQualifiedEntry, relativeTime, removeContentNodeByKeyPath, renameContentNodeByKeyPath, renderFor, renderMarkdownAst, renderNothing, resolveBrowserLocale, resolveDictionaryArgument, resolveEffectiveVariantId, resolveLocalizedPath, resolveMessage, resolveMessageNode, resolvePlainDynamicLoader, resolveProviderVariant, resolveProxyMode, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, sanitizer, select, selectPlugin, serializeVariant, serializeVariantChain, setLocaleInStorage, setLocaleInStorageClient, setLocaleInStorageServer, simpleInlineRegex, slugify, some, splitInsertionTemplate, startsWith, stringifyYaml, translation as t, transformInterpolableNode, translationPlugin, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, units, unquote, updateNodeChildren, validateHTML, validateMarkdown, validatePrefix, vueI18nToIntlayerFormatter, writeTransformCache };
+export { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, type BlockQuoteNode, type BoldTextNode, type BreakLineNode, type BreakThematicNode, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, COMPOSITE_ID_SEPARATOR, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_OPENING_TAG_R, CUSTOM_COMPONENT_R, CachedIntl, CachedIntl as Intl, type CodeBlockNode, type CodeFencedNode, type CodeInlineNode, type CompileOptions, type ComponentOverrides, ConditionCond, ConditionContent, ConditionContentStates, CookieBuildAttributes, type CustomComponentNode, DEFAULT_VARIANT_ID, DO_NOT_PROCESS_HTML_ELEMENTS, DateTimePreset, DeepTransformContent, DotPath, DynamicDictionaryLoader, type ElementType, EnterFormat, EnumerationCond, EnumerationContent, EnumerationContentState, type EscapedTextNode, FENCE_DELIMITER_R, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, FileCond, type FileContent, type FileContentConstructor, type FootnoteNode, type FootnoteReferenceNode, type GFMTaskNode, GFM_TASK_R, Gender, GenderCond, GenderContent, GenderContentStates, type GenerateSitemapOptions, GetNestingResult, type GetPrefixOptions, type GetPrefixResult, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, type HTMLCommentNode, HTMLContent, HTMLContentConstructor, type HTMLNode, type HTMLSelfClosingNode, type HTMLTag, HTMLTagsType, HTMLValidationIssue, HTMLValidationResult, HTML_BLOCK_ELEMENT_R, HTML_BLOCK_OPENING_TAG_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, HTML_SELF_CLOSING_OPENING_TAG_R, HTML_TAGS, type HeadingNode, type HeadingSetextNode, IInterpreterPlugin, IInterpreterPluginState, INLINE_SKIP_R, INTERPOLATION_R, type ImageNode, InsertionCond, InsertionContent, InsertionContentConstructor, InterpolableNode, IntlConstructorName, IsAny, type ItalicTextNode, JsonValue, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LOOKAHEAD, type LinkAngleBraceNode, type LinkBareURLNode, type LinkNode, ListFormatOptions, ListType, type LocaleDomainMap, LocaleStorage, LocaleStorageClient, LocaleStorageClientOptions, LocaleStorageOptions, LocaleStorageServer, LocaleStorageServerOptions, type LocalizedPathResult, MarkdownContent, MarkdownContentConstructor, type MarkdownContext, type MarkdownOptions, MarkdownReferences, type MarkdownRuntime, type HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, type MarkedTextNode, MessageFormatDialect, MessageValues, NAMED_CODES_TO_UNICODE, NORMALIZE_WHITESPACE_R, NP_TABLE_R, NestedCond, NestedContent, NestedContentState, NestedFieldReferences, type NestedParser, type NewlineNode, NodeProps, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, type OrderedListNode, PARAGRAPH_R, PRELOADED_DYNAMIC_KEY, type ParagraphNode, type ParseState, ParsedMarkdown, type Parser, type ParserResult, PlainDynamicLoaderMap, Plugins, PluralCategory, PluralCond, PluralContent, PluralContentState, PortableObject, PreloadableDynamicLoaderMap, PreloadedDynamicEntry, Priority, PriorityValue, type ProxyMode, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, type ReferenceImageNode, type ReferenceLinkNode, type ReferenceNode, type RenderRuleHook, ResolvedDynamicLoader, type Rule, type RuleOutput, RuleType, RuleTypeValue, type Rules, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, SelectCond, SelectContent, SelectContentStates, SelectSelector, type SitemapUrlEntry, type StrikethroughTextNode, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, type TableNode, type TableSeparatorNode, TaggedMessageToken, type TextNode, TranslationCond, TranslationContent, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, UnionKeys, type UnorderedListNode, VOID_HTML_ELEMENTS, ValidDotPathsFor, ValueAtKey, WrappedIntl, YamlRecord, YamlValue, allowInline, anyScopeRegex, attributeValueToNodePropValue, bindIntl, blockRegex, buildMaskPlugin, captureNothing, checkIsURLAbsolute, checkMissingLocalesPlugin, compact, comparePaths, compile, compileWithOptions, condition as cond, conditionPlugin, createCompiler, createRenderer, currency, cx, date, deepTransformNode, editDictionaryByKeyPath, enumeration as enu, enumerationPlugin, fallbackPlugin, type file, type fileContent, filePlugin, filterMissingTranslationsOnlyPlugin, filterTranslationsOnlyPlugin, findMatchingCondition, findPlainDynamicLoader, formatProxyEnabledMessage, gender, genderPlugin, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex, generateSitemap, generateSitemapUrl, get, getBasePlugins, getBrowserLocale, getCachedIntl, getCanonicalPath, getCondition, getContent, getContentNodeByKeyPath, getCookie, getDefaultNode, getDictionary, getDictionaryAsync, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getDictionaryTransformCacheKey, getDomainHostname, getDomainOrigin, getEditedContent, getEditedDictionary, getEmptyNode, getEnumeration, getFilterMissingTranslationsContent, getFilterMissingTranslationsDictionary, getFilterTranslationsOnlyContent, getFilterTranslationsOnlyDictionary, getFilteredLocalesContent, getFilteredLocalesDictionary, getGender, getHTML, getHTMLTextDir, getInsertion, getInsertionValues, getInternalPath, getInterpolableContent, getIntlayer, getIntlayerAsync, getLocale, getLocaleFromDomain, getLocaleFromPath, getLocaleFromStorage, getLocaleFromStorageClient, getLocaleFromStorageServer, getLocaleLang, getLocaleName, getLocalizedContent, getLocalizedPath, getLocalizedUrl, getMarkdownMetadata, getMaskContent, getMissingLocalesContent, getMissingLocalesContentFromDictionary, getMultilingualDictionary, getMultilingualUrls, getNestedDictionaryGraph, getNestedDictionaryKeys, getNestedDictionaryReferences, getNesting, getNodeChildren, getNodeType, getPathWithoutLocale, getPerLocaleDictionary, getPluginsCacheKey, getPlural, getPrefix, getPreloadLocale, getPreloadedDictionary, getReplacedValuesContent, getRewritePath, getRewriteRules, getSelect, getSplittedContent, getSplittedDictionaryContent, getTranslation, getVariantIds, html, i18nextToIntlayerFormatter, icuToIntlayerFormatter, inlineRegex, insertion as insert, insertContentInDictionary, insertionPlugin, interpolateMessage, intlayerToI18nextFormatter, intlayerToICUFormatter, intlayerToPortableObjectFormatter, intlayerToVueI18nFormatter, isDeclaredLocale, isInterpolableWrapperNode, isLocaleExclusiveOnDomain, isProxyStorageLocaleEnabled, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, isSameKeyPath, isValidElement, list, localeDetector, localeFlatMap, localeMap, localeRecord, localeResolver, localeStorageOptions, markdown as md, mergeDictionaries, mergeQualifiedDictionaries, navigatePath, nesting as nest, nestedPlugin, normalizeAttributeKey, normalizeDictionaries, normalizeDictionary, normalizePath, normalizeWhitespace, number, orderDictionaries, parseBlock, parseCaptureInline, parseDictionarySelector, parseInline, parseMarkdown, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, parseTaggedMessage, parseYaml, parserFor, percentage, plural, pluralPlugin, portableObjectToIntlayerFormatter, presets, qualifies, readTransformCache, rebuildInterpolableContent, reconstructQualifiedEntry, relativeTime, removeContentNodeByKeyPath, renameContentNodeByKeyPath, renderFor, renderMarkdownAst, renderNothing, resolveBrowserLocale, resolveDictionaryArgument, resolveEffectiveVariantId, resolveLocalizedPath, resolveMessage, resolveMessageNode, resolvePlainDynamicLoader, resolveProviderVariant, resolveProxyMode, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, sanitizer, select, selectPlugin, serializeVariant, serializeVariantChain, setLocaleInStorage, setLocaleInStorageClient, setLocaleInStorageServer, simpleInlineRegex, slugify, some, splitInsertionTemplate, startsWith, stringifyYaml, translation as t, transformInterpolableNode, translationPlugin, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, units, unquote, updateNodeChildren, validateHTML, validateMarkdown, validatePrefix, vueI18nToIntlayerFormatter, writeTransformCache };

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

@@ -9,7 +9,7 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  * @param plugins - The plugin array a transform runs with, or `undefined` when
  *                  the interpreter's base plugins are used.
  */
-declare const getPluginsCacheKey: (plugins?: Plugins[]) => string;
+export declare const getPluginsCacheKey: (plugins?: Plugins[]) => string;
 /**
  * Builds the cache key for one transformed entry.
  *
@@ -17,7 +17,7 @@ declare const getPluginsCacheKey: (plugins?: Plugins[]) => string;
  * @param selectorCacheKey - Serialized selector, empty for a plain dictionary.
  * @param plugins - The plugin array the transform runs with.
  */
-declare const getDictionaryTransformCacheKey: (locale: LocalesValues, selectorCacheKey: string, plugins?: Plugins[]) => string;
+export declare const getDictionaryTransformCacheKey: (locale: LocalesValues, selectorCacheKey: string, plugins?: Plugins[]) => string;
 /**
  * Looks up the transformed content cached for `dictionary` under `cacheKey`.
  *
@@ -25,7 +25,7 @@ declare const getDictionaryTransformCacheKey: (locale: LocalesValues, selectorCa
  * value: `null` is a legitimate cached content — an unresolvable qualified
  * coordinate — so a miss can never be inferred from the value alone.
  */
-declare const readTransformCache: <Content>(dictionary: Dictionary | object, cacheKey: string) => {
+export declare const readTransformCache: <Content>(dictionary: Dictionary | object, cacheKey: string) => {
   hit: true;
   content: Content;
 } | {
@@ -36,7 +36,6 @@ declare const readTransformCache: <Content>(dictionary: Dictionary | object, cac
  *
  * @returns The stored content, so callers can `return writeTransformCache(...)`.
  */
-declare const writeTransformCache: <Content>(dictionary: Dictionary | object, cacheKey: string, content: Content) => Content;
+export declare const writeTransformCache: <Content>(dictionary: Dictionary | object, cacheKey: string, content: Content) => Content;
 //#endregion
-export { getDictionaryTransformCacheKey, getPluginsCacheKey, readTransformCache, writeTransformCache };
 //# sourceMappingURL=dictionaryTransformCache.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"dictionaryTransformCache.d.ts","names":[],"sources":["../../../src/interpreter/dictionaryTransformCache.ts"],"mappings":";;;;;;;;;;;cA2Ba,qBAAkB,UAAc;;;;;;;;cAwDhC,iCAA8B,QACjC,eAAa,0BACG,UACd;;;;;;;;cAUC,qBAAsB,SAAO,YAC5B,qBAAmB;EAE5B;EAAW,SAAS;;EAAc;;;;;;;cAe1B,sBAAuB,SAAO,YAC7B,qBAAmB,kBACf,SACP,YACR"}
+{"version":3,"file":"dictionaryTransformCache.d.ts","names":[],"sources":["../../../src/interpreter/dictionaryTransformCache.ts"],"mappings":";;;;;;;;;;;qBA2Ba,qBAAkB,UAAc;;;;;;;;qBAwDhC,iCAA8B,QACjC,eAAa,0BACG,UACd;;;;;;;;qBAUC,qBAAsB,SAAO,YAC5B,qBAAmB;EAE5B;EAAW,SAAS;;EAAc;;;;;;;qBAe1B,sBAAuB,SAAO,YAC7B,qBAAmB,kBACf,SACP,YACR"}

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

@@ -17,7 +17,6 @@ import "../transpiler/index.js";
  * // 'The condition is validated'
  * ```
  */
-declare const getCondition: <const Content>(conditionContent: ConditionContentStates<Content>, state?: boolean) => Content;
+export declare const getCondition: <const Content>(conditionContent: ConditionContentStates<Content>, state?: boolean) => Content;
 //#endregion
-export { getCondition };
 //# sourceMappingURL=getCondition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getCondition.d.ts","names":[],"sources":["../../../src/interpreter/getCondition.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAkBa,qBAAsB,SAAO,kBACtB,uBAAuB,UAAQ,oBAEhD"}
+{"version":3,"file":"getCondition.d.ts","names":[],"sources":["../../../src/interpreter/getCondition.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAkBa,qBAAsB,SAAO,kBACtB,uBAAuB,UAAQ,oBAEhD"}

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

@@ -5,7 +5,6 @@ import { NodeProps } from "./plugins.js";
  * Applies the *first* plugin that can transform a node, then stops descending further.
  * If no plugin transforms it, it recurses into its children.
  */
-declare const deepTransformNode: (node: any, props: NodeProps) => any;
+export declare const deepTransformNode: (node: any, props: NodeProps) => any;
 //#endregion
-export { deepTransformNode };
 //# sourceMappingURL=deepTransform.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"deepTransform.d.ts","names":[],"sources":["../../../../src/interpreter/getContent/deepTransform.ts"],"mappings":";;;;;;;cASa,oBAAiB,WAAa,OAAS"}
+{"version":3,"file":"deepTransform.d.ts","names":[],"sources":["../../../../src/interpreter/getContent/deepTransform.ts"],"mappings":";;;;;;;qBASa,oBAAiB,WAAa,OAAS"}

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

@@ -2,14 +2,13 @@ import { DeepTransformContent, IInterpreterPluginState, NodeProps, Plugins } fro
 import { ContentNode } from "@intlayer/types/dictionary";
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/interpreter/getContent/getContent.d.ts
-declare const getBasePlugins: (locale?: LocalesValues, fallback?: boolean) => Plugins[];
+export declare const getBasePlugins: (locale?: LocalesValues, fallback?: boolean) => Plugins[];
 /**
  * Transforms a node in a single pass, applying each plugin as needed.
  *
  * @param node The node to transform.
  * @param locale The locale to use if your transformers need it (e.g. for translations).
  */
-declare const getContent: <const T extends ContentNode, const L extends LocalesValues = DeclaredLocales>(node: T, nodeProps: NodeProps, plugins?: Plugins[]) => DeepTransformContent<T, IInterpreterPluginState, L>;
+export declare const getContent: <const T extends ContentNode, const L extends LocalesValues = DeclaredLocales>(node: T, nodeProps: NodeProps, plugins?: Plugins[]) => DeepTransformContent<T, IInterpreterPluginState, L>;
 //#endregion
-export { getBasePlugins, getContent };
 //# sourceMappingURL=getContent.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getContent.d.ts","names":[],"sources":["../../../../src/interpreter/getContent/getContent.ts"],"mappings":";;;;cAsBa,iBAAc,SAChB,eAAa,uBAErB;;;;;;;cAqBU,mBACL,UAAU,mBACV,UAAU,gBAAgB,iBAAe,MAEzC,GAAC,WACI,WAAS,UACX,cAKH,qBAAqB,GAAG,yBAAyB"}
+{"version":3,"file":"getContent.d.ts","names":[],"sources":["../../../../src/interpreter/getContent/getContent.ts"],"mappings":";;;;qBAsBa,iBAAc,SAChB,eAAa,uBAErB;;;;;;;qBAqBU,mBACL,UAAU,mBACV,UAAU,gBAAgB,iBAAe,MAEzC,GAAC,WACI,WAAS,UACX,cAKH,qBAAqB,GAAG,yBAAyB"}