@intlayer/core 9.4.2 → 9.4.4

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"}