@intlayer/core 9.4.2 → 9.4.4

package/dist/types/transpiler/markdown/markdown.d.ts

@@ -2,8 +2,8 @@ import { MARKDOWN, TypedNodeModel } from "@intlayer/types/nodeType";
 //#region src/transpiler/markdown/markdown.d.ts
 type PropsType = 'number' | 'string' | 'node';
 type ComponentName = string;
-type MarkdownContentConstructor<T extends Record<string, any> = {}, Content = unknown> = TypedNodeModel<typeof MARKDOWN, Content, T>;
-type MarkdownContent<Content = unknown, Components extends Record<ComponentName, PropsType> = Record<ComponentName, PropsType>> = MarkdownContentConstructor<{
+export type MarkdownContentConstructor<T extends Record<string, any> = {}, Content = unknown> = TypedNodeModel<typeof MARKDOWN, Content, T>;
+export type MarkdownContent<Content = unknown, Components extends Record<ComponentName, PropsType> = Record<ComponentName, PropsType>> = MarkdownContentConstructor<{
   metadata?: Record<string, any>;
   tags?: string[] | Components;
 }, Content>;
@@ -21,5 +21,5 @@ type MarkdownContent<Content = unknown, Components extends Record<ComponentName,
  */
 declare const markdown: <Components extends Record<string, any> = Record<string, any>, Content = unknown>(content: Content, components?: Components) => MarkdownContent<Content, Components>;
 //#endregion
-export { MarkdownContent, MarkdownContentConstructor, markdown as md };
+export { markdown as md };
 //# sourceMappingURL=markdown.d.ts.map

package/dist/types/transpiler/markdown/markdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"markdown.d.ts","names":[],"sources":["../../../../src/transpiler/markdown/markdown.ts"],"mappings":";;KAOK;KAEA;KAEO,2BACV,UAAU,0BACV,qBACE,sBAAsB,UAAU,SAAS;KAEjC,gBACV,mBACA,mBAAmB,OAAO,eAAe,aAAa,OACpD,eACA,cAEA;EAEA,WAAW;EACX,kBAAkB;GAEpB;;;;;;;;;;;;;cA4BI,WACJ,mBAAmB,sBAAsB,qBACzC,mBAAiB,SAER,SAAO,aACH,eACZ,gBAAgB,SAAS"}
+{"version":3,"file":"markdown.d.ts","names":[],"sources":["../../../../src/transpiler/markdown/markdown.ts"],"mappings":";;KAOK;KAEA;YAEO,2BACV,UAAU,0BACV,qBACE,sBAAsB,UAAU,SAAS;YAEjC,gBACV,mBACA,mBAAmB,OAAO,eAAe,aAAa,OACpD,eACA,cAEA;EAEA,WAAW;EACX,kBAAkB;GAEpB;;;;;;;;;;;;;cA4BI,WACJ,mBAAmB,sBAAsB,qBACzC,mBAAiB,SAER,SAAO,aACH,eACZ,gBAAgB,SAAS"}

package/dist/types/transpiler/markdown/validateMarkdown.d.ts

@@ -1,6 +1,6 @@
 import { HTMLValidationIssue } from "../html/validateHTML.js";
 //#region src/transpiler/markdown/validateMarkdown.d.ts
-type MarkdownValidationResult = {
+export type MarkdownValidationResult = {
   valid: boolean;
   issues: HTMLValidationIssue[];
 };
@@ -11,7 +11,7 @@ type MarkdownValidationResult = {
  *
  * HTML inside code blocks is excluded from HTML validation.
  */
-declare const validateMarkdown: (content: string) => MarkdownValidationResult;
+export declare const validateMarkdown: (content: string) => MarkdownValidationResult;
 //#endregion
-export { type HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, validateMarkdown };
+export type { HTMLValidationIssue as MarkdownValidationIssue };
 //# sourceMappingURL=validateMarkdown.d.ts.map

package/dist/types/transpiler/markdown/validateMarkdown.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateMarkdown.d.ts","names":[],"sources":["../../../../src/transpiler/markdown/validateMarkdown.ts"],"mappings":";;KAIY;EACV;EACA,QAAQ;;;;;;;;;cA6FG,mBAAgB,oBAAsB"}
+{"version":3,"file":"validateMarkdown.d.ts","names":[],"sources":["../../../../src/transpiler/markdown/validateMarkdown.ts"],"mappings":";;YAIY;EACV;EACA,QAAQ;;;;;;;;;qBA6FG,mBAAgB,oBAAsB"}

package/dist/types/transpiler/nesting/nesting.d.ts

@@ -9,16 +9,16 @@ import { NESTED, TypedNodeModel } from "@intlayer/types/nodeType";
  *   type X = { a: { b: { c: string }}, d: number };
  *   DotPath<X> = "a" | "a.b" | "a.b.c" | "d"
  */
-type DotPath<T> = T extends object ? { [K in keyof T & (string | number)]: T[K] extends object // Either just K, or K + '.' + deeper path
+export type DotPath<T> = T extends object ? { [K in keyof T & (string | number)]: T[K] extends object // Either just K, or K + '.' + deeper path
  ? `${K}` | `${K}.${DotPath<T[K]>}` : `${K}`; }[keyof T & (string | number)] : never;
 type DeepReplace<T, From, To> = T extends From ? To : T extends object ? { [K in keyof T]: DeepReplace<T[K], From, To>; } : T;
 /** Build all valid dot-notation strings for a dictionary entry. */
-type ValidDotPathsFor<K extends DictionaryKeys> = DotPath<DeepReplace<DeepTransformContent<DictionaryRegistryContent<K>>, {
+export type ValidDotPathsFor<K extends DictionaryKeys> = DotPath<DeepReplace<DeepTransformContent<DictionaryRegistryContent<K>>, {
   type: any;
   props: any;
   key: any;
 }, string>>;
-type NestedContentState<K extends DictionaryKeys> = {
+export type NestedContentState<K extends DictionaryKeys> = {
   dictionaryKey: K;
   /**
    * Path must match existing keys in DictionaryRegistryContent<K>.
@@ -27,7 +27,7 @@ type NestedContentState<K extends DictionaryKeys> = {
    */
   path?: ValidDotPathsFor<K>;
 };
-type NestedContent<K extends DictionaryKeys = never> = TypedNodeModel<typeof NESTED, NestedContentState<K>>;
+export type NestedContent<K extends DictionaryKeys = never> = TypedNodeModel<typeof NESTED, NestedContentState<K>>;
 /**
  * Function intended to be used to build intlayer dictionaries.
  *
@@ -45,5 +45,5 @@ type NestedContent<K extends DictionaryKeys = never> = TypedNodeModel<typeof NES
  */
 declare const nesting: <K extends DictionaryKeys>(dictionaryKey: K, path?: ValidDotPathsFor<K>) => NestedContent<K>;
 //#endregion
-export { DotPath, NestedContent, NestedContentState, ValidDotPathsFor, nesting as nest };
+export { nesting as nest };
 //# sourceMappingURL=nesting.d.ts.map

package/dist/types/transpiler/nesting/nesting.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nesting.d.ts","names":[],"sources":["../../../../src/transpiler/nesting/nesting.ts"],"mappings":";;;;;;;;;;;KAeY,QAAQ,KAAK,sBAElB,WAAW,wBAAwB,EAAE;MAE/B,SAAS,KAAK,QAAQ,EAAE,WACxB,aACD;KAGP,YAAY,GAAG,MAAM,MAAM,UAAU,OACtC,KACA,sBACK,WAAW,IAAI,YAAY,EAAE,IAAI,MAAM,SAC1C;;KAGM,iBAAiB,UAAU,kBAAkB,QACvD,YACE,qBAAqB,0BAA0B;EAG7C;EACA;EACA;;KAMM,mBAAmB,UAAU;EACvC,eAAe;;;;;;EAOf,OAAO,iBAAiB;;KAGd,cAAc,UAAU,0BAA0B,sBACrD,QACP,mBAAmB;;;;;;;;;;;;;;;;cAkBf,UAAW,UAAU,gBAAc,eACxB,GAAC,OACT,iBAAiB,OACvB,cAAc"}
+{"version":3,"file":"nesting.d.ts","names":[],"sources":["../../../../src/transpiler/nesting/nesting.ts"],"mappings":";;;;;;;;;;;YAeY,QAAQ,KAAK,sBAElB,WAAW,wBAAwB,EAAE;MAE/B,SAAS,KAAK,QAAQ,EAAE,WACxB,aACD;KAGP,YAAY,GAAG,MAAM,MAAM,UAAU,OACtC,KACA,sBACK,WAAW,IAAI,YAAY,EAAE,IAAI,MAAM,SAC1C;;YAGM,iBAAiB,UAAU,kBAAkB,QACvD,YACE,qBAAqB,0BAA0B;EAG7C;EACA;EACA;;YAMM,mBAAmB,UAAU;EACvC,eAAe;;;;;;EAOf,OAAO,iBAAiB;;YAGd,cAAc,UAAU,0BAA0B,sBACrD,QACP,mBAAmB;;;;;;;;;;;;;;;;cAkBf,UAAW,UAAU,gBAAc,eACxB,GAAC,OACT,iBAAiB,OACvB,cAAc"}

package/dist/types/transpiler/plural/plural.d.ts

@@ -1,10 +1,10 @@
 import { PLURAL, TypedNodeModel } from "@intlayer/types/nodeType";
 //#region src/transpiler/plural/plural.d.ts
-type PluralCategory = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
-type PluralContentState<Content> = Partial<Record<PluralCategory, Content>> & {
+export type PluralCategory = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
+export type PluralContentState<Content> = Partial<Record<PluralCategory, Content>> & {
   other: Content;
 };
-type PluralContent<Content = unknown> = TypedNodeModel<typeof PLURAL, PluralContentState<Content>>;
+export type PluralContent<Content = unknown> = TypedNodeModel<typeof PLURAL, PluralContentState<Content>>;
 /**
  * Function intended to be used to build intlayer dictionaries.
  *
@@ -30,5 +30,5 @@ type PluralContent<Content = unknown> = TypedNodeModel<typeof PLURAL, PluralCont
  */
 declare const plural: <Content = unknown>(content: PluralContentState<Content>) => PluralContent<Content>;
 //#endregion
-export { PluralCategory, PluralContent, PluralContentState, plural };
+export { plural };
 //# sourceMappingURL=plural.d.ts.map

package/dist/types/transpiler/plural/plural.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plural.d.ts","names":[],"sources":["../../../../src/transpiler/plural/plural.ts"],"mappings":";;KAGY;KAEA,mBAAmB,WAAW,QACxC,OAAO,gBAAgB;EAEvB,OAAO;;KAGG,cAAc,qBAAqB,sBACtC,QACP,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;cA0Bf,SAAU,mBAAiB,SACtB,mBAAmB,aAC3B,cAAc"}
+{"version":3,"file":"plural.d.ts","names":[],"sources":["../../../../src/transpiler/plural/plural.ts"],"mappings":";;YAGY;YAEA,mBAAmB,WAAW,QACxC,OAAO,gBAAgB;EAEvB,OAAO;;YAGG,cAAc,qBAAqB,sBACtC,QACP,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;cA0Bf,SAAU,mBAAiB,SACtB,mBAAmB,aAC3B,cAAc"}

package/dist/types/transpiler/select/select.d.ts

@@ -7,12 +7,12 @@ import { SELECT, TypedNodeModel } from "@intlayer/types/nodeType";
  * `'Scheduled'`, …). The optional `fallback` key is picked when the provided
  * value matches no declared case.
  */
-type SelectContentStates<Content = unknown> = {
+export type SelectContentStates<Content = unknown> = {
   [caseKey: string]: Content;
 } & {
   fallback?: Content;
 };
-type SelectContent<States extends SelectContentStates = SelectContentStates> = TypedNodeModel<typeof SELECT, States, {
+export type SelectContent<States extends SelectContentStates = SelectContentStates> = TypedNodeModel<typeof SELECT, States, {
   /**
    * Name of the variable the cases are selected on.
    *
@@ -58,5 +58,5 @@ type SelectContent<States extends SelectContentStates = SelectContentStates> = T
  */
 declare const select: <const States extends SelectContentStates>(content?: States, variable?: string) => SelectContent<States>;
 //#endregion
-export { SelectContent, SelectContentStates, select };
+export { select };
 //# sourceMappingURL=select.d.ts.map

package/dist/types/transpiler/select/select.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"select.d.ts","names":[],"sources":["../../../../src/transpiler/select/select.ts"],"mappings":";;;;;;;;;KAUY,oBAAoB;GAC7B,kBAAkB;;EAEnB,WAAW;;KAGD,cACV,eAAe,sBAAsB,uBACnC,sBACK,QACP;;;;;;;;;EAUE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqCE,eAAgB,eAAe,qBAAmB,UAC5C,QAAM,sBAEf,cAAc"}
+{"version":3,"file":"select.d.ts","names":[],"sources":["../../../../src/transpiler/select/select.ts"],"mappings":";;;;;;;;;YAUY,oBAAoB;GAC7B,kBAAkB;;EAEnB,WAAW;;YAGD,cACV,eAAe,sBAAsB,uBACnC,sBACK,QACP;;;;;;;;;EAUE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqCE,eAAgB,eAAe,qBAAmB,UAC5C,QAAM,sBAEf,cAAc"}

package/dist/types/transpiler/translation/translation.d.ts

@@ -1,7 +1,7 @@
 import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
 import { TRANSLATION, TypedNodeModel } from "@intlayer/types/nodeType";
 //#region src/transpiler/translation/translation.d.ts
-type TranslationContent<Content = unknown, RecordContent extends StrictModeLocaleMap<Content> = StrictModeLocaleMap<Content>> = TypedNodeModel<typeof TRANSLATION, RecordContent>;
+export type TranslationContent<Content = unknown, RecordContent extends StrictModeLocaleMap<Content> = StrictModeLocaleMap<Content>> = TypedNodeModel<typeof TRANSLATION, RecordContent>;
 /**
  *
  * Function intended to be used to build intlayer dictionaries.
@@ -24,5 +24,5 @@ type TranslationContent<Content = unknown, RecordContent extends StrictModeLocal
  */
 declare const translation: <Content = unknown, ContentRecord extends StrictModeLocaleMap<Content> = StrictModeLocaleMap<Content>>(content: ContentRecord) => TranslationContent<Content, ContentRecord>;
 //#endregion
-export { TranslationContent, translation as t };
+export { translation as t };
 //# sourceMappingURL=translation.d.ts.map

package/dist/types/transpiler/translation/translation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"translation.d.ts","names":[],"sources":["../../../../src/transpiler/translation/translation.ts"],"mappings":";;;KAIY,mBACV,mBACA,sBACE,oBAAoB,WAAW,oBAAoB,YACnD,sBAAsB,aAAa;;;;;;;;;;;;;;;;;;;;;cAsBjC,cACJ,mBACA,sBACE,oBAAoB,WAAW,oBAAoB,UAAQ,SAEpD,kBACR,mBAAmB,SAAS"}
+{"version":3,"file":"translation.d.ts","names":[],"sources":["../../../../src/transpiler/translation/translation.ts"],"mappings":";;;YAIY,mBACV,mBACA,sBACE,oBAAoB,WAAW,oBAAoB,YACnD,sBAAsB,aAAa;;;;;;;;;;;;;;;;;;;;;cAsBjC,cACJ,mBACA,sBACE,oBAAoB,WAAW,oBAAoB,UAAQ,SAEpD,kBACR,mBAAmB,SAAS"}

package/dist/types/utils/checkIsURLAbsolute.d.ts

@@ -1,5 +1,4 @@
 //#region src/utils/checkIsURLAbsolute.d.ts
-declare const checkIsURLAbsolute: (url: string) => boolean;
+export declare const checkIsURLAbsolute: (url: string) => boolean;
 //#endregion
-export { checkIsURLAbsolute };
 //# sourceMappingURL=checkIsURLAbsolute.d.ts.map

package/dist/types/utils/checkIsURLAbsolute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"checkIsURLAbsolute.d.ts","names":[],"sources":["../../../src/utils/checkIsURLAbsolute.ts"],"mappings":";cAAa,qBAAkB"}
+{"version":3,"file":"checkIsURLAbsolute.d.ts","names":[],"sources":["../../../src/utils/checkIsURLAbsolute.ts"],"mappings":";qBAAa,qBAAkB"}

package/dist/types/utils/cookieExpiry.d.ts

@@ -14,7 +14,7 @@ import { ProcessedCookieAttributes } from "@intlayer/types/config";
  * @param expires - The normalized `expires` value from the built config.
  * @returns The absolute expiry in epoch milliseconds, or `undefined`.
  */
-declare const resolveExpiresToTimestamp: (expires: ProcessedCookieAttributes['expires']) => number | undefined;
+export declare const resolveExpiresToTimestamp: (expires: ProcessedCookieAttributes['expires']) => number | undefined;
 /**
  * Serializes a cookie into a `document.cookie` string. Expiry is emitted as an
  * absolute `Expires=` attribute resolved from the normalized `expires` value.
@@ -24,7 +24,6 @@ declare const resolveExpiresToTimestamp: (expires: ProcessedCookieAttributes['ex
  * @param attributes - The normalized cookie attributes.
  * @returns The serialized cookie string.
  */
-declare const buildCookieString: (name: string, value: string, attributes: ProcessedCookieAttributes) => string;
+export declare const buildCookieString: (name: string, value: string, attributes: ProcessedCookieAttributes) => string;
 //#endregion
-export { buildCookieString, resolveExpiresToTimestamp };
 //# sourceMappingURL=cookieExpiry.d.ts.map

package/dist/types/utils/cookieExpiry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cookieExpiry.d.ts","names":[],"sources":["../../../src/utils/cookieExpiry.ts"],"mappings":";;;;;;;;;;;;;;;;cAgBa,4BAAyB,SAC3B;;;;;;;;;;cAmBE,oBAAiB,cAChB,eACC,YACD"}
+{"version":3,"file":"cookieExpiry.d.ts","names":[],"sources":["../../../src/utils/cookieExpiry.ts"],"mappings":";;;;;;;;;;;;;;;;qBAgBa,4BAAyB,SAC3B;;;;;;;;;;qBAmBE,oBAAiB,cAChB,eACC,YACD"}

package/dist/types/utils/getCookie.d.ts

@@ -5,7 +5,6 @@
  * @param cookieString - Optional cookie string to parse (defaults to document.cookie in browser)
  * @returns The cookie value or undefined if not found
  */
-declare const getCookie: (name: string, cookieString?: string) => string | undefined;
+export declare const getCookie: (name: string, cookieString?: string) => string | undefined;
 //#endregion
-export { getCookie };
 //# sourceMappingURL=getCookie.d.ts.map

package/dist/types/utils/getCookie.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getCookie.d.ts","names":[],"sources":["../../../src/utils/getCookie.ts"],"mappings":";;;;;;;cAMa,YAAS,cACR"}
+{"version":3,"file":"getCookie.d.ts","names":[],"sources":["../../../src/utils/getCookie.ts"],"mappings":";;;;;;;qBAMa,YAAS,cACR"}

package/dist/types/utils/intl.d.ts

@@ -38,7 +38,7 @@ type IntlInstanceByName = {
 /**
  * Names of the `Intl` constructors this module knows how to instantiate.
  */
-type IntlConstructorName = keyof IntlInstanceByName;
+export type IntlConstructorName = keyof IntlInstanceByName;
 type IntlConstructors = { [K in keyof typeof Intl as (typeof Intl)[K] extends (new (...args: any) => any) ? K : never]: (typeof Intl)[K]; };
 type ReplaceLocaleWithLocalesValues<T> = T extends (new (locales: any, options?: infer Options) => infer Instance) ? {
   new (locales?: LocalesValues, options?: Options): Instance;
@@ -59,7 +59,7 @@ type ReplaceLocaleWithLocalesValues<T> = T extends (new (locales: any, options?:
     locale?: LocalesValues;
   }): Instance;
 } : T;
-type WrappedIntl = { [K in keyof typeof Intl]: K extends keyof IntlConstructors ? ReplaceLocaleWithLocalesValues<(typeof Intl)[K]> : (typeof Intl)[K]; };
+export type WrappedIntl = { [K in keyof typeof Intl]: K extends keyof IntlConstructors ? ReplaceLocaleWithLocalesValues<(typeof Intl)[K]> : (typeof Intl)[K]; };
 /**
  * Generic caching instantiator for Intl constructors.
  *
@@ -68,14 +68,14 @@ type WrappedIntl = { [K in keyof typeof Intl]: K extends keyof IntlConstructors
  * late-installed polyfills are picked up and missing constructors degrade to a
  * fallback instead of throwing.
  */
-declare function getCachedIntl<Name extends IntlConstructorName>(constructorName: Name, locale?: LocalesValues | string, options?: any): IntlInstanceByName[Name];
-declare function getCachedIntl<T extends new (...args: any[]) => any>(Ctor: T, locale?: LocalesValues | string, options?: any): InstanceType<T>;
+export declare function getCachedIntl<Name extends IntlConstructorName>(constructorName: Name, locale?: LocalesValues | string, options?: any): IntlInstanceByName[Name];
+export declare function getCachedIntl<T extends new (...args: any[]) => any>(Ctor: T, locale?: LocalesValues | string, options?: any): InstanceType<T>;
 /**
  * Optional: Keep bindIntl if your library exports it publicly.
  * It now uses the much smaller getCachedIntl under the hood.
  */
-declare const bindIntl: (boundLocale: LocalesValues) => WrappedIntl;
-declare const CachedIntl: any;
+export declare const bindIntl: (boundLocale: LocalesValues) => WrappedIntl;
+export declare const CachedIntl: any;
 //#endregion
-export { CachedIntl, CachedIntl as Intl, IntlConstructorName, WrappedIntl, bindIntl, getCachedIntl };
+export { CachedIntl as Intl };
 //# sourceMappingURL=intl.d.ts.map

package/dist/types/utils/intl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intl.d.ts","names":[],"sources":["../../../src/utils/intl.ts"],"mappings":";;;;;;KAoCK;EACH,OAAO,MAAM;EACb,cACE,MAAM;IACH;IAA6B;;;;;;;KAO/B;EACH,QAAQ,gBAAgB;IAAW;IAAiB;;;;;;KAMjD;EACH,UAAU,KAAK;EACf,gBAAgB,KAAK;EACrB,cAAc,KAAK;EACnB,YAAY;EACZ,QAAQ,KAAK;EACb,cAAc,KAAK;EACnB,aAAa,KAAK;EAClB,oBAAoB,KAAK;EACzB,WAAW;;;;;KAMD,4BAA4B;KAiGnC,sBACF,kBAAkB,gBAAgB,MAAM,oBACpC,qBAED,oBACgB,MAAM;KAGvB,+BAA+B,KAAK,gBACvC,cACA,gBAAgB,kBACP;OAEA,UAAU,eAAe,UAAU,UAAU;OAC7C,UAAU;IAAY,SAAS;MAAkB;GACrD,UAAU,eAAe,UAAU,UAAU;GAC7C,UAAU;IAAY,SAAS;MAAkB;IAEpD,gBACI,uBACS;OAEJ,UAAU,gBAAgB;OAC1B;IAAY,SAAS;MAAkB;GAC3C,UAAU,gBAAgB;GAC1B;IAAY,SAAS;MAAkB;IAE1C;KAEM,iBACT,kBAAkB,OAAO,gBAAgB,mBACtC,uCAAuC,MAAM,cACrC,MAAM;;;;;;;;;iBAWJ,cAAc,aAAa,qBACzC,iBAAiB,MACjB,SAAS,wBACT,gBACC,mBAAmB;iBACN,cAAc,kBAAkB,qBAC9C,MAAM,GACN,SAAS,wBACT,gBACC,aAAa;;;;;cAgDH,WAAQ,aAAiB,kBAAgB;cA+BzC"}
+{"version":3,"file":"intl.d.ts","names":[],"sources":["../../../src/utils/intl.ts"],"mappings":";;;;;;KAoCK;EACH,OAAO,MAAM;EACb,cACE,MAAM;IACH;IAA6B;;;;;;;KAO/B;EACH,QAAQ,gBAAgB;IAAW;IAAiB;;;;;;KAMjD;EACH,UAAU,KAAK;EACf,gBAAgB,KAAK;EACrB,cAAc,KAAK;EACnB,YAAY;EACZ,QAAQ,KAAK;EACb,cAAc,KAAK;EACnB,aAAa,KAAK;EAClB,oBAAoB,KAAK;EACzB,WAAW;;;;;YAMD,4BAA4B;KAiGnC,sBACF,kBAAkB,gBAAgB,MAAM,oBACpC,qBAED,oBACgB,MAAM;KAGvB,+BAA+B,KAAK,gBACvC,cACA,gBAAgB,kBACP;OAEA,UAAU,eAAe,UAAU,UAAU;OAC7C,UAAU;IAAY,SAAS;MAAkB;GACrD,UAAU,eAAe,UAAU,UAAU;GAC7C,UAAU;IAAY,SAAS;MAAkB;IAEpD,gBACI,uBACS;OAEJ,UAAU,gBAAgB;OAC1B;IAAY,SAAS;MAAkB;GAC3C,UAAU,gBAAgB;GAC1B;IAAY,SAAS;MAAkB;IAE1C;YAEM,iBACT,kBAAkB,OAAO,gBAAgB,mBACtC,uCAAuC,MAAM,cACrC,MAAM;;;;;;;;;wBAWJ,cAAc,aAAa,qBACzC,iBAAiB,MACjB,SAAS,wBACT,gBACC,mBAAmB;wBACN,cAAc,kBAAkB,qBAC9C,MAAM,GACN,SAAS,wBACT,gBACC,aAAa;;;;;qBAgDH,WAAQ,aAAiB,kBAAgB;qBA+BzC"}

package/dist/types/utils/isSameKeyPath.d.ts

@@ -1,6 +1,5 @@
 import { KeyPath } from "@intlayer/types/keyPath";
 //#region src/utils/isSameKeyPath.d.ts
-declare const isSameKeyPath: (keyPath1: KeyPath[], keyPath2: KeyPath[]) => boolean;
+export declare const isSameKeyPath: (keyPath1: KeyPath[], keyPath2: KeyPath[]) => boolean;
 //#endregion
-export { isSameKeyPath };
 //# sourceMappingURL=isSameKeyPath.d.ts.map

package/dist/types/utils/isSameKeyPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isSameKeyPath.d.ts","names":[],"sources":["../../../src/utils/isSameKeyPath.ts"],"mappings":";;cAIa,gBAAa,UAAc,WAAS,UAAY"}
+{"version":3,"file":"isSameKeyPath.d.ts","names":[],"sources":["../../../src/utils/isSameKeyPath.ts"],"mappings":";;qBAIa,gBAAa,UAAc,WAAS,UAAY"}

package/dist/types/utils/isValidReactElement.d.ts

@@ -6,7 +6,6 @@
  * @return True if `object` is a ReactElement.
  * @final
  */
-declare const isValidElement: (object: any) => boolean;
+export declare const isValidElement: (object: any) => boolean;
 //#endregion
-export { isValidElement };
 //# sourceMappingURL=isValidReactElement.d.ts.map

package/dist/types/utils/isValidReactElement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isValidReactElement.d.ts","names":[],"sources":["../../../src/utils/isValidReactElement.ts"],"mappings":";;;;;;;;cAQa,iBAAc"}
+{"version":3,"file":"isValidReactElement.d.ts","names":[],"sources":["../../../src/utils/isValidReactElement.ts"],"mappings":";;;;;;;;qBAQa,iBAAc"}

package/dist/types/utils/localeStorage.d.ts

@@ -1,7 +1,7 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { Locale } from "@intlayer/types/allLocales";
 //#region src/utils/localeStorage.d.ts
-type CookieBuildAttributes = {
+export type CookieBuildAttributes = {
   domain?: string;
   path?: string;
   secure?: boolean;
@@ -14,7 +14,7 @@ type CookieBuildAttributes = {
    */
   expires?: number | undefined;
 };
-type LocaleStorageClientOptions = {
+export type LocaleStorageClientOptions = {
   overwrite?: boolean;
   isCookieEnabled?: boolean;
   setCookieStore?: (name: string, value: string, cookie: CookieBuildAttributes) => void;
@@ -25,19 +25,19 @@ type LocaleStorageClientOptions = {
   setLocaleStorage?: (name: string, value: string) => void;
   getLocaleStorage?: (name: string) => string | undefined | null;
 };
-declare const localeStorageOptions: LocaleStorageClientOptions;
+export declare const localeStorageOptions: LocaleStorageClientOptions;
 /**
  * Retrieves the locale from browser storage mechanisms
  * (cookies, localStorage, sessionStorage).
  * Does not read from headers — use `getLocaleFromStorageServer` for that.
  */
-declare const getLocaleFromStorageClient: (options?: LocaleStorageClientOptions) => Locale | undefined;
+export declare const getLocaleFromStorageClient: (options?: LocaleStorageClientOptions) => Locale | undefined;
 /**
  * Stores the locale in browser storage mechanisms
  * (cookies, localStorage, sessionStorage).
  * Does not write to headers — use `setLocaleInStorageServer` for that.
  */
-declare const setLocaleInStorageClient: (locale: LocalesValues, options?: LocaleStorageClientOptions) => void;
+export declare const setLocaleInStorageClient: (locale: LocalesValues, options?: LocaleStorageClientOptions) => void;
 /**
  * Client-side locale storage utility.
  * Handles cookies (browser), localStorage and sessionStorage.
@@ -50,11 +50,11 @@ declare const setLocaleInStorageClient: (locale: LocalesValues, options?: Locale
  * storage.setLocale('fr');
  * ```
  */
-declare const LocaleStorageClient: (options: LocaleStorageClientOptions) => {
+export declare const LocaleStorageClient: (options: LocaleStorageClientOptions) => {
   getLocale: () => Locale;
   setLocale: (locale: LocalesValues) => void;
 };
-type LocaleStorageServerOptions = {
+export type LocaleStorageServerOptions = {
   overwrite?: boolean;
   isCookieEnabled?: boolean;
   setCookieStore?: (name: string, value: string, cookie: CookieBuildAttributes) => void;
@@ -68,12 +68,12 @@ type LocaleStorageServerOptions = {
  * Does not access localStorage or sessionStorage.
  * No browser cookie fallback — the caller must provide `getCookie`.
  */
-declare const getLocaleFromStorageServer: (options: LocaleStorageServerOptions) => Locale | undefined;
+export declare const getLocaleFromStorageServer: (options: LocaleStorageServerOptions) => Locale | undefined;
 /**
  * Stores the locale in server-side storage mechanisms (cookies, headers).
  * Does not write to localStorage or sessionStorage.
  */
-declare const setLocaleInStorageServer: (locale: LocalesValues, options?: LocaleStorageServerOptions) => void;
+export declare const setLocaleInStorageServer: (locale: LocalesValues, options?: LocaleStorageServerOptions) => void;
 /**
  * Server-side locale storage utility.
  * Handles cookies (via injected getter/setter) and headers.
@@ -91,14 +91,14 @@ declare const setLocaleInStorageServer: (locale: LocalesValues, options?: Locale
  * storage.setLocale('fr');
  * ```
  */
-declare const LocaleStorageServer: (options: LocaleStorageServerOptions) => {
+export declare const LocaleStorageServer: (options: LocaleStorageServerOptions) => {
   getLocale: () => Locale;
   setLocale: (locale: LocalesValues) => void;
 };
 /**
  * @deprecated Use {@link LocaleStorageClientOptions} or {@link LocaleStorageServerOptions} instead.
  */
-type LocaleStorageOptions = LocaleStorageClientOptions & LocaleStorageServerOptions;
+export type LocaleStorageOptions = LocaleStorageClientOptions & LocaleStorageServerOptions;
 /**
  * Retrieves the locale from all storage mechanisms
  * (cookies, localStorage, sessionStorage, headers).
@@ -106,7 +106,7 @@ type LocaleStorageOptions = LocaleStorageClientOptions & LocaleStorageServerOpti
  * @deprecated Use {@link getLocaleFromStorageClient} (browser) or
  * {@link getLocaleFromStorageServer} (server) instead.
  */
-declare const getLocaleFromStorage: (options: Pick<LocaleStorageOptions, 'getCookie' | 'getSessionStorage' | 'getLocaleStorage' | 'getHeader' | 'isCookieEnabled'>) => Locale | undefined;
+export declare const getLocaleFromStorage: (options: Pick<LocaleStorageOptions, 'getCookie' | 'getSessionStorage' | 'getLocaleStorage' | 'getHeader' | 'isCookieEnabled'>) => Locale | undefined;
 /**
  * Stores the locale in all configured storage mechanisms
  * (cookies, localStorage, sessionStorage, headers).
@@ -114,17 +114,16 @@ declare const getLocaleFromStorage: (options: Pick<LocaleStorageOptions, 'getCoo
  * @deprecated Use {@link setLocaleInStorageClient} (browser) or
  * {@link setLocaleInStorageServer} (server) instead.
  */
-declare const setLocaleInStorage: (locale: LocalesValues, options?: LocaleStorageOptions) => void;
+export declare const setLocaleInStorage: (locale: LocalesValues, options?: LocaleStorageOptions) => void;
 /**
  * Utility object to get and set the locale in storage based on configuration.
  *
  * @deprecated Use {@link LocaleStorageClient} (browser) or
  * {@link LocaleStorageServer} (server) instead.
  */
-declare const LocaleStorage: (options: LocaleStorageOptions) => {
+export declare const LocaleStorage: (options: LocaleStorageOptions) => {
   getLocale: () => Locale;
   setLocale: (locale: LocalesValues) => void;
 };
 //#endregion
-export { CookieBuildAttributes, LocaleStorage, LocaleStorageClient, LocaleStorageClientOptions, LocaleStorageOptions, LocaleStorageServer, LocaleStorageServerOptions, getLocaleFromStorage, getLocaleFromStorageClient, getLocaleFromStorageServer, localeStorageOptions, setLocaleInStorage, setLocaleInStorageClient, setLocaleInStorageServer };
 //# sourceMappingURL=localeStorage.d.ts.map

package/dist/types/utils/localeStorage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localeStorage.d.ts","names":[],"sources":["../../../src/utils/localeStorage.ts"],"mappings":";;;KAsCY;EACV;EACA;EACA;EACA;EACA;;;;;;EAMA;;KAQU;EACV;EACA;EACA,kBACE,cACA,eACA,QAAQ;EAEV,mBAAmB,cAAc;EACjC,aAAa;EACb,qBAAqB,cAAc;EACnC,qBAAqB;EACrB,oBAAoB,cAAc;EAClC,oBAAoB;;cAMT,sBAAsB;;;;;;cA+BtB,6BAA0B,UAC5B,+BACR;;;;;;cA6CU,2BAAwB,QAC3B,eAAa,UACX;;;;;;;;;;;;;cAwEC,sBAAmB,SAAa;EAC3C,iBAAS;EACT,YAAS,QAAW;;KASV;EACV;EACA;EACA,kBACE,cACA,eACA,QAAQ;EAEV,mBAAmB,cAAc;EACjC,aAAa;EACb,aAAa;EACb,aAAa,cAAc;;;;;;;cAQhB,6BAA0B,SAC5B,+BACR;;;;;cA+BU,2BAAwB,QAC3B,eAAa,UACX;;;;;;;;;;;;;;;;;;cA0DC,sBAAmB,SAAa;EAC3C,iBAAS;EACT,YAAS,QAAW;;;;;KAYV,uBAAuB,6BACjC;;;;;;;;cASW,uBAAoB,SACtB,KACP,oHAOD;;;;;;;;cA+DU,qBAAkB,QACrB,eAAa,UACX;;;;;;;cA8EC,gBAAa,SAAa;EACrC,iBAAS;EACT,YAAS,QAAW"}
+{"version":3,"file":"localeStorage.d.ts","names":[],"sources":["../../../src/utils/localeStorage.ts"],"mappings":";;;YAsCY;EACV;EACA;EACA;EACA;EACA;;;;;;EAMA;;YAQU;EACV;EACA;EACA,kBACE,cACA,eACA,QAAQ;EAEV,mBAAmB,cAAc;EACjC,aAAa;EACb,qBAAqB,cAAc;EACnC,qBAAqB;EACrB,oBAAoB,cAAc;EAClC,oBAAoB;;qBAMT,sBAAsB;;;;;;qBA+BtB,6BAA0B,UAC5B,+BACR;;;;;;qBA6CU,2BAAwB,QAC3B,eAAa,UACX;;;;;;;;;;;;;qBAwEC,sBAAmB,SAAa;EAC3C,iBAAS;EACT,YAAS,QAAW;;YASV;EACV;EACA;EACA,kBACE,cACA,eACA,QAAQ;EAEV,mBAAmB,cAAc;EACjC,aAAa;EACb,aAAa;EACb,aAAa,cAAc;;;;;;;qBAQhB,6BAA0B,SAC5B,+BACR;;;;;qBA+BU,2BAAwB,QAC3B,eAAa,UACX;;;;;;;;;;;;;;;;;;qBA0DC,sBAAmB,SAAa;EAC3C,iBAAS;EACT,YAAS,QAAW;;;;;YAYV,uBAAuB,6BACjC;;;;;;;;qBASW,uBAAoB,SACtB,KACP,oHAOD;;;;;;;;qBA+DU,qBAAkB,QACrB,eAAa,UACX;;;;;;;qBA8EC,gBAAa,SAAa;EACrC,iBAAS;EACT,YAAS,QAAW"}

package/dist/types/utils/parseYaml.d.ts

@@ -1,15 +1,14 @@
 //#region src/utils/parseYaml.d.ts
-interface YamlRecord {
+export interface YamlRecord {
   [key: string]: YamlValue;
 }
-type YamlValue = string | number | YamlValue[] | YamlRecord;
+export type YamlValue = string | number | YamlValue[] | YamlRecord;
 /**
  * Parses a YAML/JSON-like string into a typed value.
  * Supports scalars, quoted strings, inline arrays/objects, and indented YAML syntax.
  * Boolean/null literals (true, false, null, yes, no, etc.) are preserved as strings,
  * not coerced to their native JS equivalents.
  */
-declare const parseYaml: <T = YamlValue>(input: string) => T | null;
+export declare const parseYaml: <T = YamlValue>(input: string) => T | null;
 //#endregion
-export { YamlRecord, YamlValue, parseYaml };
 //# sourceMappingURL=parseYaml.d.ts.map

package/dist/types/utils/parseYaml.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseYaml.d.ts","names":[],"sources":["../../../src/utils/parseYaml.ts"],"mappings":";UAciB;GACd,cAAc;;KAEL,8BAA8B,cAAc;;;;;;;cAQ3C,YAAa,IAAI,WAAS,kBAAkB"}
+{"version":3,"file":"parseYaml.d.ts","names":[],"sources":["../../../src/utils/parseYaml.ts"],"mappings":";iBAciB;GACd,cAAc;;YAEL,8BAA8B,cAAc;;;;;;;qBAQ3C,YAAa,IAAI,WAAS,kBAAkB"}

package/dist/types/utils/stringifyYaml.d.ts

@@ -1,5 +1,4 @@
 //#region src/utils/stringifyYaml.d.ts
-declare const stringifyYaml: (value: any) => string;
+export declare const stringifyYaml: (value: any) => string;
 //#endregion
-export { stringifyYaml };
 //# sourceMappingURL=stringifyYaml.d.ts.map

package/dist/types/utils/stringifyYaml.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stringifyYaml.d.ts","names":[],"sources":["../../../src/utils/stringifyYaml.ts"],"mappings":";cAwGa,gBAAa"}
+{"version":3,"file":"stringifyYaml.d.ts","names":[],"sources":["../../../src/utils/stringifyYaml.ts"],"mappings":";qBAwGa,gBAAa"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/core",
-  "version": "9.4.2",
+  "version": "9.4.4",
   "private": false,
   "description": "Includes core Intlayer functions like translation, dictionary, and utility functions shared across multiple packages.",
   "keywords": [
@@ -172,11 +172,11 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "9.4.2",
-    "@intlayer/config": "9.4.2",
-    "@intlayer/dictionaries-entry": "9.4.2",
-    "@intlayer/types": "9.4.2",
-    "@intlayer/unmerged-dictionaries-entry": "9.4.2",
+    "@intlayer/api": "9.4.4",
+    "@intlayer/config": "9.4.4",
+    "@intlayer/dictionaries-entry": "9.4.4",
+    "@intlayer/types": "9.4.4",
+    "@intlayer/unmerged-dictionaries-entry": "9.4.4",
     "defu": "6.1.7"
   },
   "devDependencies": {
@@ -185,9 +185,9 @@
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",
     "rimraf": "6.1.3",
-    "tsdown": "0.22.14",
+    "tsdown": "0.23.0",
     "typescript": "7.0.2",
-    "vitest": "4.1.11"
+    "vitest": "5.0.0"
   },
   "engines": {
     "node": ">=14.18"