@intlayer/core 9.4.3 → 9.4.4

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

@@ -17,7 +17,7 @@ import { NodeType } from "@intlayer/types/nodeType";
  *
  * > `transformFn` is a function that can be used to deeply transform inside the plugin.
  */
-type Plugins = {
+export type Plugins = {
   id: string;
   canHandle: (node: any) => boolean;
   transform: (node: any, props: NodeProps, transformFn: (node: any, props: NodeProps) => any) => any;
@@ -27,31 +27,31 @@ type Plugins = {
  *
  * Used to fallback a tree-shaken plugin
  * --------------------------------------------- */
-declare const fallbackPlugin: Plugins;
+export declare const fallbackPlugin: Plugins;
 /** ---------------------------------------------
  * TRANSLATION PLUGIN
  * --------------------------------------------- */
-type UnionKeys<T> = T extends unknown ? keyof T : never;
-type ValueAtKey<T, K> = T extends unknown ? K extends keyof T ? T[K] : never : never;
-type TranslationCond<T, S, L extends LocalesValues> = T extends {
+export type UnionKeys<T> = T extends unknown ? keyof T : never;
+export type ValueAtKey<T, K> = T extends unknown ? K extends keyof T ? T[K] : never : never;
+export type TranslationCond<T, S, L extends LocalesValues> = T extends {
   nodeType: NodeType | string;
   [NodeTypes.TRANSLATION]: infer U;
 } ? U extends Record<PropertyKey, unknown> ? U[keyof U] extends Record<PropertyKey, unknown> ? { [K in UnionKeys<U[keyof U]>]: L extends keyof U ? K extends keyof U[L] ? U[L][K] : ValueAtKey<U[keyof U], K> : ValueAtKey<U[keyof U], K>; } extends (infer Content) ? DeepTransformContent<Content, S> : never : (L extends keyof U ? U[L] : U[keyof U]) extends (infer Content) ? DeepTransformContent<Content, S> : never : never : never;
 /** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
-declare const translationPlugin: (locale: LocalesValues, fallback?: LocalesValues) => Plugins;
+export declare const translationPlugin: (locale: LocalesValues, fallback?: LocalesValues) => Plugins;
 /** ---------------------------------------------
  * ENUMERATION PLUGIN
  * --------------------------------------------- */
-type EnumerationCond<T, S, _L> = T extends {
+export type EnumerationCond<T, S, _L> = T extends {
   nodeType: NodeType | string;
   [NodeTypes.ENUMERATION]: object;
 } ? (quantity: number) => DeepTransformContent<T[typeof NodeTypes.ENUMERATION][keyof T[typeof NodeTypes.ENUMERATION]], S> : never;
 /** Enumeration plugin. Replaces node with a function that takes quantity => string. */
-declare const enumerationPlugin: Plugins;
+export declare const enumerationPlugin: Plugins;
 /** ---------------------------------------------
  * PLURAL PLUGIN
  * --------------------------------------------- */
-type PluralCond<T, S, _L> = T extends {
+export type PluralCond<T, S, _L> = T extends {
   nodeType: NodeType | string;
   [NodeTypes.PLURAL]: object;
 } ? (arg: number | {
@@ -63,37 +63,37 @@ type PluralCond<T, S, _L> = T extends {
  * `{ count, ...values }`) => string, picking the matching CLDR plural form
  * for the active locale and interpolating `{{count}}` (and other values).
  */
-declare const pluralPlugin: (locale?: LocalesValues) => Plugins;
+export declare const pluralPlugin: (locale?: LocalesValues) => Plugins;
 /** ---------------------------------------------
  * CONDITION PLUGIN
  * --------------------------------------------- */
-type ConditionCond<T, S, _L> = T extends {
+export type ConditionCond<T, S, _L> = T extends {
   nodeType: NodeType | string;
   [NodeTypes.CONDITION]: object;
 } ? (value: boolean | {
   value: boolean;
 }) => DeepTransformContent<T[typeof NodeTypes.CONDITION][keyof T[typeof NodeTypes.CONDITION]], S> : never;
 /** Condition plugin. Replaces node with a function that takes boolean => string. */
-declare const conditionPlugin: Plugins;
+export declare const conditionPlugin: Plugins;
 /** ---------------------------------------------
  *  INSERTION PLUGIN
  *  --------------------------------------------- */
-type InsertionCond<T, S, _L> = T extends {
+export type InsertionCond<T, S, _L> = T extends {
   nodeType: NodeType | string;
   [NodeTypes.INSERTION]: infer I;
   fields: readonly string[];
 } ? (values: { [K in T['fields'][number]]: string | number; }) => I extends string ? DeepTransformContent<string, S> : DeepTransformContent<I, S> : never;
 /** Insertion plugin. Replaces node with a function that takes quantity => string. */
-declare const insertionPlugin: Plugins;
+export declare const insertionPlugin: Plugins;
 /** ---------------------------------------------
  * GENDER PLUGIN
  * --------------------------------------------- */
-type GenderCond<T, S, _L> = T extends {
+export type GenderCond<T, S, _L> = T extends {
   nodeType: NodeType | string;
   [NodeTypes.GENDER]: object;
 } ? (value: Gender) => DeepTransformContent<T[typeof NodeTypes.GENDER][keyof T[typeof NodeTypes.GENDER]], S> : never;
 /** Gender plugin. Replaces node with a function that takes gender => string. */
-declare const genderPlugin: Plugins;
+export declare const genderPlugin: Plugins;
 /** ---------------------------------------------
  * SELECT PLUGIN
  * --------------------------------------------- */
@@ -104,19 +104,19 @@ declare const genderPlugin: Plugins;
  * fallback covers the unmatched values) while the declared cases still
  * autocomplete. Without a `fallback`, only the declared cases are accepted.
  */
-type SelectSelector<States> = 'fallback' extends keyof States ? Exclude<keyof States & string, 'fallback'> | (string & {}) : keyof States & string;
-type SelectCond<T, S, _L> = T extends {
+export type SelectSelector<States> = 'fallback' extends keyof States ? Exclude<keyof States & string, 'fallback'> | (string & {}) : keyof States & string;
+export type SelectCond<T, S, _L> = T extends {
   nodeType: NodeType | string;
   [NodeTypes.SELECT]: object;
 } ? (value: SelectSelector<T[typeof NodeTypes.SELECT]> | {
   value: SelectSelector<T[typeof NodeTypes.SELECT]>;
 }) => DeepTransformContent<T[typeof NodeTypes.SELECT][keyof T[typeof NodeTypes.SELECT]], S> : never;
 /** Select plugin. Replaces node with a function that takes a string => content. */
-declare const selectPlugin: Plugins;
+export declare const selectPlugin: Plugins;
 /** ---------------------------------------------
  * NESTED PLUGIN
  * --------------------------------------------- */
-type NestedCond<T, S, _L> = T extends {
+export type NestedCond<T, S, _L> = T extends {
   nodeType: NodeType | string;
   [NodeTypes.NESTED]: infer U;
 } ? U extends {
@@ -124,17 +124,17 @@ type NestedCond<T, S, _L> = T extends {
   path?: infer P;
 } ? GetNestingResult<K, P, S> : never : never;
 /** Nested plugin. Replaces node with the result of `getNesting`. */
-declare const nestedPlugin: (locale?: LocalesValues) => Plugins;
+export declare const nestedPlugin: (locale?: LocalesValues) => Plugins;
 /** ---------------------------------------------
  * FILE PLUGIN
  * --------------------------------------------- */
-type FileCond<T, S, _L> = T extends {
+export type FileCond<T, S, _L> = T extends {
   nodeType: NodeType | string;
   [NodeTypes.FILE]: string;
   content?: string;
 } ? DeepTransformContent<string, S> : never;
 /** File plugin. Replaces node with the result of `getNesting`. */
-declare const filePlugin: Plugins;
+export declare const filePlugin: Plugins;
 /**
  * PLUGIN RESULT
  */
@@ -142,7 +142,7 @@ declare const filePlugin: Plugins;
  * Interface that defines the properties of a node.
  * This interface can be augmented in other packages, such as `react-intlayer`.
  */
-interface NodeProps {
+export interface NodeProps {
   dictionaryKey: string;
   keyPath: KeyPath[];
   plugins?: Plugins[];
@@ -171,7 +171,7 @@ interface NodeProps {
  * Interface that defines the plugins that can be used to transform a node.
  * This interface can be augmented in other packages, such as `react-intlayer`.
  */
-interface IInterpreterPlugin<T, S, L extends LocalesValues> {
+export interface IInterpreterPlugin<T, S, L extends LocalesValues> {
   translation: TranslationCond<T, S, L>;
   enumeration: EnumerationCond<T, S, L>;
   plural: PluralCond<T, S, L>;
@@ -185,7 +185,7 @@ interface IInterpreterPlugin<T, S, L extends LocalesValues> {
 /**
  * Allow to avoid overwriting import from `intlayer` package when `IInterpreterPlugin<T>` interface is augmented in another package, such as `react-intlayer`.
  */
-type IInterpreterPluginState = {
+export type IInterpreterPluginState = {
   translation: true;
   enumeration: true;
   plural: true;
@@ -204,11 +204,10 @@ type CheckApplyPlugin<T, K extends keyof IInterpreterPlugin<T, S, L>, S, L exten
  * Traverse recursively through an object or array, applying each plugin as needed.
  */
 type Traverse<T, S, L extends LocalesValues = DeclaredLocales> = T extends ReadonlyArray<infer U> ? Array<DeepTransformContent<U, S, L>> : T extends object ? { [K in keyof T]: DeepTransformContent<T[K], S, L>; } : T;
-type IsAny<T> = 0 extends 1 & T ? true : false;
+export type IsAny<T> = 0 extends 1 & T ? true : false;
 /**
  * Traverse recursively through an object or array, applying each plugin as needed.
  */
-type DeepTransformContent<T, S = IInterpreterPluginState, L extends LocalesValues = DeclaredLocales> = IsAny<T> extends true ? T : CheckApplyPlugin<T, keyof IInterpreterPlugin<T, S, L>, S, L> extends never ? Traverse<T, S, L> : CheckApplyPlugin<T, keyof IInterpreterPlugin<T, S, L>, S, L>;
+export type DeepTransformContent<T, S = IInterpreterPluginState, L extends LocalesValues = DeclaredLocales> = IsAny<T> extends true ? T : CheckApplyPlugin<T, keyof IInterpreterPlugin<T, S, L>, S, L> extends never ? Traverse<T, S, L> : CheckApplyPlugin<T, keyof IInterpreterPlugin<T, S, L>, S, L>;
 //#endregion
-export { ConditionCond, DeepTransformContent, EnumerationCond, FileCond, GenderCond, IInterpreterPlugin, IInterpreterPluginState, InsertionCond, IsAny, NestedCond, NodeProps, Plugins, PluralCond, SelectCond, SelectSelector, TranslationCond, UnionKeys, ValueAtKey, conditionPlugin, enumerationPlugin, fallbackPlugin, filePlugin, genderPlugin, insertionPlugin, nestedPlugin, pluralPlugin, selectPlugin, translationPlugin };
 //# sourceMappingURL=plugins.d.ts.map

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

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

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

@@ -12,7 +12,6 @@ import { DeclaredLocales, ExtractSelectorLocale, LocalesValues } from "@intlayer
  * @param plugins An array of NodeTransformer that define how to transform recognized nodes.
  *                If omitted, we’ll use a default set of plugins.
  */
-declare const getDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(dictionary: T, localeOrSelector?: A, plugins?: Plugins[]) => DeepTransformContent<ResolveQualifiedDictionaryContent<T, A>, IInterpreterPluginState, ExtractSelectorLocale<A>>;
+export declare const getDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(dictionary: T, localeOrSelector?: A, plugins?: Plugins[]) => DeepTransformContent<ResolveQualifiedDictionaryContent<T, A>, IInterpreterPluginState, ExtractSelectorLocale<A>>;
 //#endregion
-export { getDictionary };
 //# sourceMappingURL=getDictionary.d.ts.map

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

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

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

@@ -28,7 +28,6 @@ import { DeclaredLocales, ExtractSelectorLocale, LocalesValues } from "@intlayer
  *                           `{ variant }`, optionally with `locale`).
  * @param plugins - Node transformers. Defaults to the base interpreter set.
  */
-declare const getDictionaryAsync: <const T extends Dictionary, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(dictionaryLoaders: PlainDynamicLoaderMap<T> | QualifiedDynamicLoaderMap, key: string, localeOrSelector?: A, plugins?: Plugins[]) => Promise<DeepTransformContent<T['content'], IInterpreterPluginState, ExtractSelectorLocale<A>>>;
+export declare const getDictionaryAsync: <const T extends Dictionary, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(dictionaryLoaders: PlainDynamicLoaderMap<T> | QualifiedDynamicLoaderMap, key: string, localeOrSelector?: A, plugins?: Plugins[]) => Promise<DeepTransformContent<T['content'], IInterpreterPluginState, ExtractSelectorLocale<A>>>;
 //#endregion
-export { getDictionaryAsync };
 //# sourceMappingURL=getDictionaryAsync.d.ts.map

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

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

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

@@ -28,7 +28,7 @@ import "../transpiler/index.js";
  *
  * If no keys match, the default key is '1'.
  */
-declare const findMatchingCondition: <const Content>(enumerationContent: EnumerationContentState<Content>, quantity: number) => EnterFormat | undefined;
+export declare const findMatchingCondition: <const Content>(enumerationContent: EnumerationContentState<Content>, quantity: number) => EnterFormat | undefined;
 /**
  * Picks content from an enumeration map based on a provided quantity.
  *
@@ -53,7 +53,6 @@ declare const findMatchingCondition: <const Content>(enumerationContent: Enumera
  * // 'Many items'
  * ```
  */
-declare const getEnumeration: <const Content>(enumerationContent: EnumerationContentState<Content>, quantity: number) => Content;
+export declare const getEnumeration: <const Content>(enumerationContent: EnumerationContentState<Content>, quantity: number) => Content;
 //#endregion
-export { findMatchingCondition, getEnumeration };
 //# sourceMappingURL=getEnumeration.d.ts.map

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

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

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

@@ -24,7 +24,6 @@ type GenderEntry = Gender | 'm' | 'f';
  * }, undefined);
  * // 'The gender is validated'
  */
-declare const getGender: <const Content>(genderContent: GenderContentStates<Content>, gender: GenderEntry) => Content;
+export declare const getGender: <const Content>(genderContent: GenderContentStates<Content>, gender: GenderEntry) => Content;
 //#endregion
-export { getGender };
 //# sourceMappingURL=getGender.d.ts.map

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

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

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

@@ -26,7 +26,6 @@ type Components = Record<string, Component | string | ComponentObject>;
 /**
  * Interprets a string containing HTML-like tags and replaces them with provided components or strings.
  */
-declare const getHTML: (content: string, values: Components) => any;
+export declare const getHTML: (content: string, values: Components) => any;
 //#endregion
-export { getHTML };
 //# sourceMappingURL=getHTML.d.ts.map

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

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

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

@@ -14,7 +14,6 @@ import "../transpiler/index.js";
  * ```
  *
  */
-declare const getInsertion: (content: string, values: { [K in InsertionContent['fields'][number]]: string | number; }) => string;
+export declare const getInsertion: (content: string, values: { [K in InsertionContent['fields'][number]]: string | number; }) => string;
 //#endregion
-export { getInsertion };
 //# sourceMappingURL=getInsertion.d.ts.map

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

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

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

@@ -13,7 +13,6 @@ import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, ExtractSelec
  * - `{ variant: { id: 'prod_abc', userId: '123' } }` — structured variant
  * - `locale` can be combined with any selector: `{ item: 2, locale: 'fr' }`
  */
-declare const getIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(key: T, localeOrSelector?: A, plugins?: Plugins[]) => DeepTransformContent<DictionaryRegistryResult<T, A>, IInterpreterPluginState, ExtractSelectorLocale<A>>;
+export declare const getIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(key: T, localeOrSelector?: A, plugins?: Plugins[]) => DeepTransformContent<DictionaryRegistryResult<T, A>, IInterpreterPluginState, ExtractSelectorLocale<A>>;
 //#endregion
-export { getIntlayer };
 //# sourceMappingURL=getIntlayer.d.ts.map

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

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

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

@@ -30,7 +30,6 @@ import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, ExtractSelec
  * const { title } = await getIntlayerAsync('home-metadata', locale);
  * ```
  */
-declare const getIntlayerAsync: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(key: T, localeOrSelector?: A, plugins?: Plugins[]) => Promise<DeepTransformContent<DictionaryRegistryResult<T, A>, IInterpreterPluginState, ExtractSelectorLocale<A>>>;
+export declare const getIntlayerAsync: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(key: T, localeOrSelector?: A, plugins?: Plugins[]) => Promise<DeepTransformContent<DictionaryRegistryResult<T, A>, IInterpreterPluginState, ExtractSelectorLocale<A>>>;
 //#endregion
-export { getIntlayerAsync };
 //# sourceMappingURL=getIntlayerAsync.d.ts.map

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

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

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

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

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

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

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

@@ -27,7 +27,6 @@ import { DictionaryKeys } from "@intlayer/types/module_augmentation";
  * @param props - Interpreter node props, carrying the attached dictionaries.
  * @returns The nested content.
  */
-declare const getNesting: <const K extends DictionaryKeys, const P>(dictionaryKey: K, path?: P extends ValidDotPathsFor<K> ? P : never, props?: NodeProps) => GetNestingResult<K, P>;
+export declare const getNesting: <const K extends DictionaryKeys, const P>(dictionaryKey: K, path?: P extends ValidDotPathsFor<K> ? P : never, props?: NodeProps) => GetNestingResult<K, P>;
 //#endregion
-export { getNesting };
 //# sourceMappingURL=getNesting.optimized.d.ts.map

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

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

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

@@ -17,7 +17,6 @@ import { DeclaredLocales } from "@intlayer/types";
  * // '{{count}} items'
  * ```
  */
-declare const getPlural: <const L extends LocalesValues = DeclaredLocales>(pluralContent: PluralContentState<string>, count: number, locale: L) => string;
+export declare const getPlural: <const L extends LocalesValues = DeclaredLocales>(pluralContent: PluralContentState<string>, count: number, locale: L) => string;
 //#endregion
-export { getPlural };
 //# sourceMappingURL=getPlural.d.ts.map

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

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

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

@@ -25,7 +25,6 @@ import "../transpiler/index.js";
  * // 'This post is live'
  * ```
  */
-declare const getSelect: <const Content>(selectContent: SelectContentStates<Content>, value?: string) => Content;
+export declare const getSelect: <const Content>(selectContent: SelectContentStates<Content>, value?: string) => Content;
 //#endregion
-export { getSelect };
 //# sourceMappingURL=getSelect.d.ts.map

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

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

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

@@ -23,7 +23,6 @@ import { LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augme
  * // 'Bonjour'
  * ```
  */
-declare const getTranslation: <const Content = string>(languageContent: StrictModeLocaleMap<Content>, locale: LocalesValues, fallback?: LocalesValues) => Content;
+export declare const getTranslation: <const Content = string>(languageContent: StrictModeLocaleMap<Content>, locale: LocalesValues, fallback?: LocalesValues) => Content;
 //#endregion
-export { getTranslation };
 //# sourceMappingURL=getTranslation.d.ts.map

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

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

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

@@ -10,7 +10,7 @@ import * as NodeTypes from "@intlayer/types/nodeType";
  * be able to interpolate into that inner string before the html/markdown
  * renderer turns it into a component tree.
  */
-type InterpolableNode = string | {
+export type InterpolableNode = string | {
   nodeType: typeof NodeTypes.HTML;
   [NodeTypes.HTML]: string;
 } | {
@@ -25,7 +25,7 @@ type InterpolableNode = string | {
  * so bundlers can eliminate the branch (and downstream handling code) when the
  * html/markdown node types are tree-shaken out of the user bundle.
  */
-declare const isInterpolableWrapperNode: (node: unknown) => node is Exclude<InterpolableNode, string>;
+export declare const isInterpolableWrapperNode: (node: unknown) => node is Exclude<InterpolableNode, string>;
 /**
  * Extracts the raw interpolable string from a string, `html()` or `markdown()`
  * node. Returns `undefined` for any other node so callers can fall back to
@@ -38,7 +38,7 @@ declare const isInterpolableWrapperNode: (node: unknown) => node is Exclude<Inte
  * getInterpolableContent({ nodeType: 'translation' }); // undefined
  * ```
  */
-declare const getInterpolableContent: (node: unknown) => string | undefined;
+export declare const getInterpolableContent: (node: unknown) => string | undefined;
 /**
  * Rebuilds an interpolable node from its interpolated raw string, preserving
  * the original node shape (plain string stays a string, `html()`/`markdown()`
@@ -50,7 +50,7 @@ declare const getInterpolableContent: (node: unknown) => string | undefined;
  * // { nodeType: 'html', html: '<b>1</b>', … }
  * ```
  */
-declare const rebuildInterpolableContent: <T>(node: T, interpolated: string) => T;
+export declare const rebuildInterpolableContent: <T>(node: T, interpolated: string) => T;
 /**
  * Interpolates `{{ … }}` values into an `html()`/`markdown()` wrapper node,
  * then re-runs the transform with the parent plugin list so the html/markdown
@@ -60,7 +60,6 @@ declare const rebuildInterpolableContent: <T>(node: T, interpolated: string) =>
  * framework package — framework nodes (React elements, VNodes…) cannot be
  * injected into a raw markup string, so plain string interpolation is used.
  */
-declare const transformInterpolableNode: (node: Exclude<InterpolableNode, string>, values: Record<string, string | number>, subProps: NodeProps, parentPlugins: Plugins[] | undefined, deepTransformNode: (node: unknown, props: NodeProps) => unknown) => unknown;
+export declare const transformInterpolableNode: (node: Exclude<InterpolableNode, string>, values: Record<string, string | number>, subProps: NodeProps, parentPlugins: Plugins[] | undefined, deepTransformNode: (node: unknown, props: NodeProps) => unknown) => unknown;
 //#endregion
-export { InterpolableNode, getInterpolableContent, isInterpolableWrapperNode, rebuildInterpolableContent, transformInterpolableNode };
 //# sourceMappingURL=interpolableNode.d.ts.map

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

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"splitAndJoinInsertion.d.ts","names":[],"sources":["../../../src/interpreter/splitAndJoinInsertion.ts"],"mappings":";cAaa,yBAA0B,SAAO,kBAC5B,SACR,eAAe;EACpB;EAAmB,gBAAgB"}
+{"version":3,"file":"splitAndJoinInsertion.d.ts","names":[],"sources":["../../../src/interpreter/splitAndJoinInsertion.ts"],"mappings":";qBAaa,yBAA0B,SAAO,kBAC5B,SACR,eAAe;EACpB;EAAmB,gBAAgB"}

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

@@ -30,7 +30,7 @@ import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentat
  *   configured locales.
  * @returns The normalized, locale-agnostic pathname.
  */
-declare const normalizePath: <const L extends LocalesValues = DeclaredLocales>(inputUrl: string, locales?: L[]) => string;
+export declare const normalizePath: <const L extends LocalesValues = DeclaredLocales>(inputUrl: string, locales?: L[]) => string;
 /**
  * Compares two URLs or pathnames for equality, ignoring locale segment,
  * protocol/host, query string, hash and trailing slashes.
@@ -59,7 +59,6 @@ declare const normalizePath: <const L extends LocalesValues = DeclaredLocales>(i
  *   configured locales.
  * @returns `true` when both inputs resolve to the same locale-agnostic path.
  */
-declare const comparePaths: <const L extends LocalesValues = DeclaredLocales>(pathname: string, href: string, locales?: L[]) => boolean;
+export declare const comparePaths: <const L extends LocalesValues = DeclaredLocales>(pathname: string, href: string, locales?: L[]) => boolean;
 //#endregion
-export { comparePaths, normalizePath };
 //# sourceMappingURL=comparePaths.d.ts.map

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

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

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

@@ -5,7 +5,7 @@ import { RoutingConfig } from "@intlayer/types/config";
  * The locale → domain map configured under `routing.domains`
  * (e.g. `{ en: 'intlayer.org', zh: 'intlayer.cn' }`).
  */
-type LocaleDomainMap = RoutingConfig['domains'];
+export type LocaleDomainMap = RoutingConfig['domains'];
 /**
  * Strips the protocol from a domain string and returns only the hostname.
  *
@@ -19,7 +19,7 @@ type LocaleDomainMap = RoutingConfig['domains'];
  * @param domain - A domain value from `routing.domains`, with or without protocol.
  * @returns The bare hostname.
  */
-declare const getDomainHostname: (domain: string) => string;
+export declare const getDomainHostname: (domain: string) => string;
 /**
  * Returns the absolute origin for a domain value, prepending `https://`
  * when no protocol is present.
@@ -34,7 +34,7 @@ declare const getDomainHostname: (domain: string) => string;
  * @param domain - A domain value from `routing.domains`, with or without protocol.
  * @returns The origin usable as a URL base.
  */
-declare const getDomainOrigin: (domain: string) => string;
+export declare const getDomainOrigin: (domain: string) => string;
 /**
  * Returns the locale exclusively mapped to a given hostname via `routing.domains`,
  * or `undefined` when zero or more than one locale share that hostname.
@@ -51,7 +51,7 @@ declare const getDomainOrigin: (domain: string) => string;
  * @param domains - The configured locale → domain map.
  * @returns The exclusively mapped locale, or `undefined`.
  */
-declare const getLocaleFromDomain: (hostname: string, domains: LocaleDomainMap) => DeclaredLocales | undefined;
+export declare const getLocaleFromDomain: (hostname: string, domains: LocaleDomainMap) => DeclaredLocales | undefined;
 /**
  * Checks whether a locale is the only locale mapped to its configured domain.
  * When true, the domain alone identifies the locale and no URL prefix is needed.
@@ -62,7 +62,6 @@ declare const getLocaleFromDomain: (hostname: string, domains: LocaleDomainMap)
  * @param domains - The configured locale → domain map.
  * @returns `true` when the locale has a domain shared with no other locale.
  */
-declare const isLocaleExclusiveOnDomain: (locale: LocalesValues, domains: LocaleDomainMap) => boolean;
+export declare const isLocaleExclusiveOnDomain: (locale: LocalesValues, domains: LocaleDomainMap) => boolean;
 //#endregion
-export { LocaleDomainMap, getDomainHostname, getDomainOrigin, getLocaleFromDomain, isLocaleExclusiveOnDomain };
 //# sourceMappingURL=domainUtils.d.ts.map

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

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

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

@@ -1,7 +1,7 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { RoutingConfig } from "@intlayer/types/config";
 //#region src/localization/generateSitemap.d.ts
-type SitemapUrlEntry = {
+export type SitemapUrlEntry = {
   /** The canonical path, e.g. '/dashboard' */
   path: string;
   changefreq?: string;
@@ -9,7 +9,7 @@ type SitemapUrlEntry = {
   /** ISO date string, e.g. '2024-01-15' */
   lastmod?: string;
 };
-type GenerateSitemapOptions = {
+export type GenerateSitemapOptions = {
   /** Base site URL without trailing slash, e.g. 'https://example.com' */
   siteUrl: string;
   /**
@@ -85,7 +85,7 @@ type GenerateSitemapOptions = {
  * @param options - Configuration options.
  * @returns One or more `<url>` XML strings, joined by a newline.
  */
-declare const generateSitemapUrl: (path: string, options: SitemapUrlEntry & GenerateSitemapOptions) => string;
+export declare const generateSitemapUrl: (path: string, options: SitemapUrlEntry & GenerateSitemapOptions) => string;
 /**
  * Generates a full XML sitemap string from an array of URL entries.
  *
@@ -114,7 +114,6 @@ declare const generateSitemapUrl: (path: string, options: SitemapUrlEntry & Gene
  * @param options - Sitemap generation options.
  * @returns A full XML sitemap string.
  */
-declare const generateSitemap: (entries: SitemapUrlEntry[], options: GenerateSitemapOptions) => string;
+export declare const generateSitemap: (entries: SitemapUrlEntry[], options: GenerateSitemapOptions) => string;
 //#endregion
-export { GenerateSitemapOptions, SitemapUrlEntry, generateSitemap, generateSitemapUrl };
 //# sourceMappingURL=generateSitemap.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"generateSitemap.d.ts","names":[],"sources":["../../../src/localization/generateSitemap.ts"],"mappings":";;;KAMY;;EAEV;EACA;EACA;;EAEA;;KAGU;;EAEV;;;;;;;;;;;;;EAaA;;;;;;;;;;;;;;;;;;;;;EAqBA;EACA,UAAU;EACV,gBAAgB;EAChB,OAAO;EACP,UAAU;EACV,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsFC,qBAAkB,cACjB,SACH,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAuFhB,kBAAe,SACjB,mBAAiB,SACjB"}
+{"version":3,"file":"generateSitemap.d.ts","names":[],"sources":["../../../src/localization/generateSitemap.ts"],"mappings":";;;YAMY;;EAEV;EACA;EACA;;EAEA;;YAGU;;EAEV;;;;;;;;;;;;;EAaA;;;;;;;;;;;;;;;;;;;;;EAqBA;EACA,UAAU;EACV,gBAAgB;EAChB,OAAO;EACP,UAAU;EACV,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsFC,qBAAkB,cACjB,SACH,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAuFhB,kBAAe,SACjB,mBAAiB,SACjB"}