@intlayer/core 9.4.3 → 9.5.0

package/dist/types/messageFormat/vue-i18n.d.ts

@@ -1,8 +1,7 @@
 import { JsonValue } from "./ICU.js";
 import { Dictionary } from "@intlayer/types/dictionary";
 //#region src/messageFormat/vue-i18n.d.ts
-declare const intlayerToVueI18nFormatter: (message: Dictionary['content']) => JsonValue;
-declare const vueI18nToIntlayerFormatter: (message: JsonValue) => Dictionary['content'];
+export declare const intlayerToVueI18nFormatter: (message: Dictionary['content']) => JsonValue;
+export declare const vueI18nToIntlayerFormatter: (message: JsonValue) => Dictionary['content'];
 //#endregion
-export { intlayerToVueI18nFormatter, vueI18nToIntlayerFormatter };
 //# sourceMappingURL=vue-i18n.d.ts.map

package/dist/types/messageFormat/vue-i18n.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vue-i18n.d.ts","names":[],"sources":["../../../src/messageFormat/vue-i18n.ts"],"mappings":";;;cAoVa,6BAA0B,SAC5B,0BACR;cAQU,6BAA0B,SAC5B,cACR"}
+{"version":3,"file":"vue-i18n.d.ts","names":[],"sources":["../../../src/messageFormat/vue-i18n.ts"],"mappings":";;;qBAoVa,6BAA0B,SAC5B,0BACR;qBAQU,6BAA0B,SAC5B,cACR"}

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

@@ -1,9 +1,9 @@
 import { CONDITION, TypedNodeModel } from "@intlayer/types/nodeType";
 //#region src/transpiler/condition/condition.d.ts
-type ConditionContentStates<Content> = Record<`${boolean}`, Content> & {
+export type ConditionContentStates<Content> = Record<`${boolean}`, Content> & {
   fallback?: Content;
 };
-type ConditionContent<Content = unknown> = TypedNodeModel<typeof CONDITION, ConditionContentStates<Content>>;
+export type ConditionContent<Content = unknown> = TypedNodeModel<typeof CONDITION, ConditionContentStates<Content>>;
 /**
  * Function intended to be used to build intlayer dictionaries.
  *
@@ -23,5 +23,5 @@ type ConditionContent<Content = unknown> = TypedNodeModel<typeof CONDITION, Cond
  */
 declare const condition: <Content>(content?: ConditionContentStates<Content>) => ConditionContent<Content>;
 //#endregion
-export { ConditionContent, ConditionContentStates, condition as cond };
+export { condition as cond };
 //# sourceMappingURL=condition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"condition.d.ts","names":[],"sources":["../../../../src/transpiler/condition/condition.ts"],"mappings":";;KAGY,uBAAuB,WAAW,qBAAqB;EACjE,WAAW;;KAGD,iBAAiB,qBAAqB,sBACzC,WACP,uBAAuB;;;;;;;;;;;;;;;;;;cAoBnB,YAAa,SAAO,UACd,uBAAuB,aAChC,iBAAiB"}
+{"version":3,"file":"condition.d.ts","names":[],"sources":["../../../../src/transpiler/condition/condition.ts"],"mappings":";;YAGY,uBAAuB,WAAW,qBAAqB;EACjE,WAAW;;YAGD,iBAAiB,qBAAqB,sBACzC,WACP,uBAAuB;;;;;;;;;;;;;;;;;;cAoBnB,YAAa,SAAO,UACd,uBAAuB,aAChC,iBAAiB"}

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

@@ -9,11 +9,11 @@ type Superior = `>${Numbers}`;
 type SuperiorOrEqual = `>=${Numbers}`;
 type Inferior = `<${Numbers}`;
 type InferiorOrEqual = `<=${Numbers}`;
-type EnterFormat = Equal | EqualString | Superior | SuperiorOrEqual | Inferior | InferiorOrEqual;
-type EnumerationContentState<Content> = Partial<Record<EnterFormat, Content>> & {
+export type EnterFormat = Equal | EqualString | Superior | SuperiorOrEqual | Inferior | InferiorOrEqual;
+export type EnumerationContentState<Content> = Partial<Record<EnterFormat, Content>> & {
   fallback?: Content;
 };
-type EnumerationContent<Content = unknown> = TypedNodeModel<typeof ENUMERATION, EnumerationContentState<Content>>;
+export type EnumerationContent<Content = unknown> = TypedNodeModel<typeof ENUMERATION, EnumerationContentState<Content>>;
 /**
  * Function intended to be used to build intlayer dictionaries.
  *
@@ -35,5 +35,5 @@ type EnumerationContent<Content = unknown> = TypedNodeModel<typeof ENUMERATION,
  */
 declare const enumeration: <Content = unknown>(content?: EnumerationContentState<Content>) => EnumerationContent<Content>;
 //#endregion
-export { EnterFormat, EnumerationContent, EnumerationContentState, enumeration as enu };
+export { enumeration as enu };
 //# sourceMappingURL=enumeration.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"enumeration.d.ts","names":[],"sources":["../../../../src/transpiler/enumeration/enumeration.ts"],"mappings":";;KAGK;KACA;KACA,UAAU,WAAW;KAErB,QAAQ;KACR,kBAAkB;KAClB,eAAe;KACf,uBAAuB;KACvB,eAAe;KACf,uBAAuB;KAEhB,cACR,QACA,cACA,WACA,kBACA,WACA;KAEQ,wBAAwB,WAAW,QAC7C,OAAO,aAAa;EAEpB,WAAW;;KAGD,mBAAmB,qBAAqB,sBAC3C,aACP,wBAAwB;;;;;;;;;;;;;;;;;;;;cAsBpB,cAAe,mBAAiB,UAC1B,wBAAwB,aACjC,mBAAmB"}
+{"version":3,"file":"enumeration.d.ts","names":[],"sources":["../../../../src/transpiler/enumeration/enumeration.ts"],"mappings":";;KAGK;KACA;KACA,UAAU,WAAW;KAErB,QAAQ;KACR,kBAAkB;KAClB,eAAe;KACf,uBAAuB;KACvB,eAAe;KACf,uBAAuB;YAEhB,cACR,QACA,cACA,WACA,kBACA,WACA;YAEQ,wBAAwB,WAAW,QAC7C,OAAO,aAAa;EAEpB,WAAW;;YAGD,mBAAmB,qBAAqB,sBAC3C,aACP,wBAAwB;;;;;;;;;;;;;;;;;;;;cAsBpB,cAAe,mBAAiB,UAC1B,wBAAwB,aACjC,mBAAmB"}

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

@@ -1,11 +1,11 @@
 import { FILE, TypedNodeModel } from "@intlayer/types/nodeType";
 //#region src/transpiler/file/file.d.ts
-type FileContentConstructor<T extends Record<string, any> = {}> = TypedNodeModel<typeof FILE, string, T>;
-type FileContent = FileContentConstructor<{
+export type FileContentConstructor<T extends Record<string, any> = {}> = TypedNodeModel<typeof FILE, string, T>;
+export type FileContent = FileContentConstructor<{
   content: string;
   fixedPath?: string;
 }>;
-declare const fileContent: (path: string, callerDir: string, baseDir: string) => FileContent;
+export declare const fileContent: (path: string, callerDir: string, baseDir: string) => FileContent;
 /**
  * Function intended to be used to build intlayer dictionaries.
  *
@@ -21,7 +21,6 @@ declare const fileContent: (path: string, callerDir: string, baseDir: string) =>
  * file('path/to/file.md') // relative path
  * ```
  */
-declare const file: (path: string) => FileContent;
+export declare const file: (path: string) => FileContent;
 //#endregion
-export { FileContent, FileContentConstructor, file, fileContent };
 //# sourceMappingURL=file.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"file.d.ts","names":[],"sources":["../../../../src/transpiler/file/file.ts"],"mappings":";;KAMY,uBAAuB,UAAU,4BAC3C,sBAAsB,cAAc;KAE1B,cAAc;EACxB;EACA;;cAGW,cAAW,cACV,mBACK,oBAEhB;;;;;;;;;;;;;;;;cAyDU,OAAI,iBAAmB"}
+{"version":3,"file":"file.d.ts","names":[],"sources":["../../../../src/transpiler/file/file.ts"],"mappings":";;YAMY,uBAAuB,UAAU,4BAC3C,sBAAsB,cAAc;YAE1B,cAAc;EACxB;EACA;;qBAGW,cAAW,cACV,mBACK,oBAEhB;;;;;;;;;;;;;;;;qBAyDU,OAAI,iBAAmB"}

package/dist/types/transpiler/file/fileBrowser.d.ts

@@ -15,7 +15,6 @@ import { FileContent } from "./file.js";
  * file('path/to/file.md') // relative path
  * ```
  */
-declare const file: (_path: string) => FileContent;
+export declare const file: (_path: string) => FileContent;
 //#endregion
-export { file };
 //# sourceMappingURL=fileBrowser.d.ts.map

package/dist/types/transpiler/file/fileBrowser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fileBrowser.d.ts","names":[],"sources":["../../../../src/transpiler/file/fileBrowser.ts"],"mappings":";;;;;;;;;;;;;;;;;cAiBa,OAAI,kBAAoB"}
+{"version":3,"file":"fileBrowser.d.ts","names":[],"sources":["../../../../src/transpiler/file/fileBrowser.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAiBa,OAAI,kBAAoB"}

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

@@ -1,10 +1,10 @@
 import { GENDER, TypedNodeModel } from "@intlayer/types/nodeType";
 //#region src/transpiler/gender/gender.d.ts
-type Gender = 'male' | 'female' | 'fallback';
-type GenderContentStates<Content> = Record<`${Gender}`, Content> & {
+export type Gender = 'male' | 'female' | 'fallback';
+export type GenderContentStates<Content> = Record<`${Gender}`, Content> & {
   fallback?: Content;
 };
-type GenderContent<Content = unknown> = TypedNodeModel<typeof GENDER, GenderContentStates<Content>>;
+export type GenderContent<Content = unknown> = TypedNodeModel<typeof GENDER, GenderContentStates<Content>>;
 /**
  * Function intended to be used to build intlayer dictionaries.
  *
@@ -24,5 +24,5 @@ type GenderContent<Content = unknown> = TypedNodeModel<typeof GENDER, GenderCont
  */
 declare const gender: <Content>(content?: GenderContentStates<Content>) => GenderContent<Content>;
 //#endregion
-export { Gender, GenderContent, GenderContentStates, gender };
+export { gender };
 //# sourceMappingURL=gender.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"gender.d.ts","names":[],"sources":["../../../../src/transpiler/gender/gender.ts"],"mappings":";;KAGY;KAEA,oBAAoB,WAAW,UAAU,UAAU;EAC7D,WAAW;;KAGD,cAAc,qBAAqB,sBACtC,QACP,oBAAoB;;;;;;;;;;;;;;;;;;cAoBhB,SAAU,SAAO,UACX,oBAAoB,aAC7B,cAAc"}
+{"version":3,"file":"gender.d.ts","names":[],"sources":["../../../../src/transpiler/gender/gender.ts"],"mappings":";;YAGY;YAEA,oBAAoB,WAAW,UAAU,UAAU;EAC7D,WAAW;;YAGD,cAAc,qBAAqB,sBACtC,QACP,oBAAoB;;;;;;;;;;;;;;;;;;cAoBhB,SAAU,SAAO,UACX,oBAAoB,aAC7B,cAAc"}

package/dist/types/transpiler/html/getHTMLCustomComponents.d.ts

@@ -4,7 +4,6 @@
  * - Standard HTML tags are set to `true`.
  * - Custom components are parsed to extract their attributes/props.
  */
-declare const getHTMLCustomComponents: (content: string) => Record<string, Record<string, string> | true>;
+export declare const getHTMLCustomComponents: (content: string) => Record<string, Record<string, string> | true>;
 //#endregion
-export { getHTMLCustomComponents };
 //# sourceMappingURL=getHTMLCustomComponents.d.ts.map

package/dist/types/transpiler/html/getHTMLCustomComponents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getHTMLCustomComponents.d.ts","names":[],"sources":["../../../../src/transpiler/html/getHTMLCustomComponents.ts"],"mappings":";;;;;;cA2Ba,0BAAuB,oBAEjC,eAAe"}
+{"version":3,"file":"getHTMLCustomComponents.d.ts","names":[],"sources":["../../../../src/transpiler/html/getHTMLCustomComponents.ts"],"mappings":";;;;;;qBA2Ba,0BAAuB,oBAEjC,eAAe"}

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

@@ -2,8 +2,8 @@ import { HTML, TypedNodeModel } from "@intlayer/types/nodeType";
 //#region src/transpiler/html/html.d.ts
 type PropsType = 'number' | 'string' | 'node';
 type ComponentName = string;
-type HTMLContentConstructor<Content = unknown, T extends Record<string, any> = {}> = TypedNodeModel<typeof HTML, Content, T>;
-type HTMLContent<Content = unknown, Components extends Record<ComponentName, PropsType> = Record<ComponentName, PropsType>> = HTMLContentConstructor<Content, {
+export type HTMLContentConstructor<Content = unknown, T extends Record<string, any> = {}> = TypedNodeModel<typeof HTML, Content, T>;
+export type HTMLContent<Content = unknown, Components extends Record<ComponentName, PropsType> = Record<ComponentName, PropsType>> = HTMLContentConstructor<Content, {
   tags: string[] | Components;
 }>;
 /**
@@ -18,7 +18,6 @@ type HTMLContent<Content = unknown, Components extends Record<ComponentName, Pro
  * ```
  *
  */
-declare const html: <Components extends Record<string, any> = Record<string, any>, Content = unknown>(content: Content, components?: Components) => HTMLContent<Content, Components>;
+export declare const html: <Components extends Record<string, any> = Record<string, any>, Content = unknown>(content: Content, components?: Components) => HTMLContent<Content, Components>;
 //#endregion
-export { HTMLContent, HTMLContentConstructor, html };
 //# sourceMappingURL=html.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"html.d.ts","names":[],"sources":["../../../../src/transpiler/html/html.ts"],"mappings":";;KAKK;KAEA;KAEO,uBACV,mBACA,UAAU,4BACR,sBAAsB,MAAM,SAAS;KAE7B,YACV,mBACA,mBAAmB,OAAO,eAAe,aAAa,OACpD,eACA,cAEA,uBACF;EAEE,iBAAiB;;;;;;;;;;;;;;cAgBR,OACX,mBAAmB,sBAAsB,qBACzC,mBAAiB,SAER,SAAO,aACH,eACZ,YAAY,SAAS"}
+{"version":3,"file":"html.d.ts","names":[],"sources":["../../../../src/transpiler/html/html.ts"],"mappings":";;KAKK;KAEA;YAEO,uBACV,mBACA,UAAU,4BACR,sBAAsB,MAAM,SAAS;YAE7B,YACV,mBACA,mBAAmB,OAAO,eAAe,aAAa,OACpD,eACA,cAEA,uBACF;EAEE,iBAAiB;;;;;;;;;;;;;;qBAgBR,OACX,mBAAmB,sBAAsB,qBACzC,mBAAiB,SAER,SAAO,aACH,eACZ,YAAY,SAAS"}

package/dist/types/transpiler/html/htmlTags.d.ts

@@ -7,8 +7,8 @@
  * Used by framework-specific plugins (react-intlayer, vue-intlayer, etc.)
  * to create default HTML tag components.
  */
-declare const HTML_TAGS: readonly ['html', 'head', 'body', 'main', 'header', 'footer', 'nav', 'aside', 'article', 'section', 'div', 'span', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'a', 'strong', 'b', 'em', 'i', 'u', 's', 'del', 'ins', 'mark', 'small', 'sub', 'sup', 'code', 'pre', 'blockquote', 'q', 'cite', 'abbr', 'address', 'time', 'kbd', 'samp', 'var', 'ul', 'ol', 'li', 'dl', 'dt', 'dd', 'table', 'thead', 'tbody', 'tfoot', 'tr', 'th', 'td', 'caption', 'colgroup', 'col', 'form', 'input', 'textarea', 'button', 'select', 'option', 'optgroup', 'label', 'fieldset', 'legend', 'datalist', 'output', 'progress', 'meter', 'img', 'video', 'audio', 'source', 'track', 'picture', 'figure', 'figcaption', 'iframe', 'embed', 'object', 'canvas', 'svg', 'details', 'summary', 'dialog', 'br', 'hr', 'wbr', 'ruby', 'rt', 'rp', 'bdi', 'bdo', 'data', 'template', 'slot'];
-type HTMLTagsType = {
+export declare const HTML_TAGS: readonly ['html', 'head', 'body', 'main', 'header', 'footer', 'nav', 'aside', 'article', 'section', 'div', 'span', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'a', 'strong', 'b', 'em', 'i', 'u', 's', 'del', 'ins', 'mark', 'small', 'sub', 'sup', 'code', 'pre', 'blockquote', 'q', 'cite', 'abbr', 'address', 'time', 'kbd', 'samp', 'var', 'ul', 'ol', 'li', 'dl', 'dt', 'dd', 'table', 'thead', 'tbody', 'tfoot', 'tr', 'th', 'td', 'caption', 'colgroup', 'col', 'form', 'input', 'textarea', 'button', 'select', 'option', 'optgroup', 'label', 'fieldset', 'legend', 'datalist', 'output', 'progress', 'meter', 'img', 'video', 'audio', 'source', 'track', 'picture', 'figure', 'figcaption', 'iframe', 'embed', 'object', 'canvas', 'svg', 'details', 'summary', 'dialog', 'br', 'hr', 'wbr', 'ruby', 'rt', 'rp', 'bdi', 'bdo', 'data', 'template', 'slot'];
+export type HTMLTagsType = {
   html: HTMLHtmlElement;
   head: HTMLHeadElement;
   body: HTMLBodyElement;
@@ -111,5 +111,4 @@ type HTMLTagsType = {
   slot: HTMLSlotElement;
 };
 //#endregion
-export { HTMLTagsType, HTML_TAGS };
 //# sourceMappingURL=htmlTags.d.ts.map

package/dist/types/transpiler/html/htmlTags.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"htmlTags.d.ts","names":[],"sources":["../../../../src/transpiler/html/htmlTags.ts"],"mappings":";;;;;;;;;cAQa;KAgHD;EAEV,MAAM;EACN,MAAM;EACN,MAAM;EACN,MAAM;EACN,QAAQ;EACR,QAAQ;EACR,KAAK;EACL,OAAO;EACP,SAAS;EACT,SAAS;EACT,KAAK;EACL,MAAM;EAGN,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EAGJ,GAAG;EACH,GAAG;EACH,QAAQ;EACR,GAAG;EACH,IAAI;EACJ,GAAG;EACH,GAAG;EACH,GAAG;EACH,KAAK;EACL,KAAK;EACL,MAAM;EACN,OAAO;EACP,KAAK;EACL,KAAK;EACL,MAAM;EACN,KAAK;EACL,YAAY;EACZ,GAAG;EACH,MAAM;EACN,MAAM;EACN,SAAS;EACT,MAAM;EACN,KAAK;EACL,MAAM;EACN,KAAK;EAGL,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EAGJ,OAAO;EACP,OAAO;EACP,OAAO;EACP,OAAO;EACP,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,SAAS;EACT,UAAU;EACV,KAAK;EAGL,MAAM;EACN,OAAO;EACP,UAAU;EACV,QAAQ;EACR,QAAQ;EACR,QAAQ;EACR,UAAU;EACV,OAAO;EACP,UAAU;EACV,QAAQ;EACR,UAAU;EACV,QAAQ;EACR,UAAU;EACV,OAAO;EAGP,KAAK;EACL,OAAO;EACP,OAAO;EACP,QAAQ;EACR,OAAO;EACP,SAAS;EACT,QAAQ;EACR,YAAY;EACZ,QAAQ;EACR,OAAO;EACP,QAAQ;EACR,QAAQ;EACR,KAAK;EAGL,SAAS;EACT,SAAS;EACT,QAAQ;EAGR,IAAI;EACJ,IAAI;EACJ,KAAK;EACL,MAAM;EACN,IAAI;EACJ,IAAI;EACJ,KAAK;EACL,KAAK;EACL,MAAM;EACN,UAAU;EACV,MAAM"}
+{"version":3,"file":"htmlTags.d.ts","names":[],"sources":["../../../../src/transpiler/html/htmlTags.ts"],"mappings":";;;;;;;;;qBAQa;YAgHD;EAEV,MAAM;EACN,MAAM;EACN,MAAM;EACN,MAAM;EACN,QAAQ;EACR,QAAQ;EACR,KAAK;EACL,OAAO;EACP,SAAS;EACT,SAAS;EACT,KAAK;EACL,MAAM;EAGN,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EAGJ,GAAG;EACH,GAAG;EACH,QAAQ;EACR,GAAG;EACH,IAAI;EACJ,GAAG;EACH,GAAG;EACH,GAAG;EACH,KAAK;EACL,KAAK;EACL,MAAM;EACN,OAAO;EACP,KAAK;EACL,KAAK;EACL,MAAM;EACN,KAAK;EACL,YAAY;EACZ,GAAG;EACH,MAAM;EACN,MAAM;EACN,SAAS;EACT,MAAM;EACN,KAAK;EACL,MAAM;EACN,KAAK;EAGL,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,IAAI;EAGJ,OAAO;EACP,OAAO;EACP,OAAO;EACP,OAAO;EACP,IAAI;EACJ,IAAI;EACJ,IAAI;EACJ,SAAS;EACT,UAAU;EACV,KAAK;EAGL,MAAM;EACN,OAAO;EACP,UAAU;EACV,QAAQ;EACR,QAAQ;EACR,QAAQ;EACR,UAAU;EACV,OAAO;EACP,UAAU;EACV,QAAQ;EACR,UAAU;EACV,QAAQ;EACR,UAAU;EACV,OAAO;EAGP,KAAK;EACL,OAAO;EACP,OAAO;EACP,QAAQ;EACR,OAAO;EACP,SAAS;EACT,QAAQ;EACR,YAAY;EACZ,QAAQ;EACR,OAAO;EACP,QAAQ;EACR,QAAQ;EACR,KAAK;EAGL,SAAS;EACT,SAAS;EACT,QAAQ;EAGR,IAAI;EACJ,IAAI;EACJ,KAAK;EACL,MAAM;EACN,IAAI;EACJ,IAAI;EACJ,KAAK;EACL,KAAK;EACL,MAAM;EACN,UAAU;EACV,MAAM"}

package/dist/types/transpiler/html/validateHTML.d.ts

@@ -1,10 +1,10 @@
 //#region src/transpiler/html/validateHTML.d.ts
-declare const VOID_HTML_ELEMENTS: Set<string>;
-type HTMLValidationIssue = {
+export declare const VOID_HTML_ELEMENTS: Set<string>;
+export type HTMLValidationIssue = {
   type: 'error' | 'warning';
   message: string;
 };
-type HTMLValidationResult = {
+export type HTMLValidationResult = {
   valid: boolean;
   issues: HTMLValidationIssue[];
 };
@@ -15,7 +15,6 @@ type HTMLValidationResult = {
  * False-positive exclusions:
  * - Tags whose attribute string starts with `://` are URL autolinks (e.g. `<https://…>`).
  */
-declare const validateHTML: (content: string) => HTMLValidationResult;
+export declare const validateHTML: (content: string) => HTMLValidationResult;
 //#endregion
-export { HTMLValidationIssue, HTMLValidationResult, VOID_HTML_ELEMENTS, validateHTML };
 //# sourceMappingURL=validateHTML.d.ts.map

package/dist/types/transpiler/html/validateHTML.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validateHTML.d.ts","names":[],"sources":["../../../../src/transpiler/html/validateHTML.ts"],"mappings":";cAAa,oBAAkB;KAgBnB;EACV;EACA;;KAGU;EACV;EACA,QAAQ;;;;;;;;;cAiBG,eAAY,oBAAsB"}
+{"version":3,"file":"validateHTML.d.ts","names":[],"sources":["../../../../src/transpiler/html/validateHTML.ts"],"mappings":";qBAAa,oBAAkB;YAgBnB;EACV;EACA;;YAGU;EACV;EACA,QAAQ;;;;;;;;;qBAiBG,eAAY,oBAAsB"}

package/dist/types/transpiler/insertion/getInsertionValues.d.ts

@@ -1,5 +1,4 @@
 //#region src/transpiler/insertion/getInsertionValues.d.ts
-declare const getInsertionValues: (content: string) => string[];
+export declare const getInsertionValues: (content: string) => string[];
 //#endregion
-export { getInsertionValues };
 //# sourceMappingURL=getInsertionValues.d.ts.map

package/dist/types/transpiler/insertion/getInsertionValues.d.ts.map

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

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

@@ -1,7 +1,7 @@
 import { INSERTION, TypedNodeModel } from "@intlayer/types/nodeType";
 //#region src/transpiler/insertion/insertion.d.ts
-type InsertionContentConstructor<Content = unknown, T extends Record<string, any> = {}> = TypedNodeModel<typeof INSERTION, Content, T>;
-type InsertionContent<Content = unknown> = InsertionContentConstructor<Content, {
+export type InsertionContentConstructor<Content = unknown, T extends Record<string, any> = {}> = TypedNodeModel<typeof INSERTION, Content, T>;
+export type InsertionContent<Content = unknown> = InsertionContentConstructor<Content, {
   fields: string[];
 }>;
 /**
@@ -18,5 +18,5 @@ type InsertionContent<Content = unknown> = InsertionContentConstructor<Content,
  */
 declare const insertion: <Content = unknown>(content: Content) => InsertionContent<Content>;
 //#endregion
-export { InsertionContent, InsertionContentConstructor, insertion as insert };
+export { insertion as insert };
 //# sourceMappingURL=insertion.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"insertion.d.ts","names":[],"sources":["../../../../src/transpiler/insertion/insertion.ts"],"mappings":";;KAIY,4BACV,mBACA,UAAU,4BACR,sBAAsB,WAAW,SAAS;KAElC,iBAAiB,qBAAqB,4BAChD;EAEE;;;;;;;;;;;;;;cAgBE,YAAa,mBAAiB,SACzB,YACR,iBAAiB"}
+{"version":3,"file":"insertion.d.ts","names":[],"sources":["../../../../src/transpiler/insertion/insertion.ts"],"mappings":";;YAIY,4BACV,mBACA,UAAU,4BACR,sBAAsB,WAAW,SAAS;YAElC,iBAAiB,qBAAqB,4BAChD;EAEE;;;;;;;;;;;;;;cAgBE,YAAa,mBAAiB,SACzB,YACR,iBAAiB"}

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

@@ -1,5 +1,4 @@
 //#region src/transpiler/markdown/getMarkdownMetadata.d.ts
-declare const getMarkdownMetadata: <T extends Record<string, any>>(markdown: string) => T;
+export declare const getMarkdownMetadata: <T extends Record<string, any>>(markdown: string) => T;
 //#endregion
-export { getMarkdownMetadata };
 //# sourceMappingURL=getMarkdownMetadata.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getMarkdownMetadata.d.ts","names":[],"sources":["../../../../src/transpiler/markdown/getMarkdownMetadata.ts"],"mappings":";cAEa,sBAAuB,UAAU,qBAAmB,qBAE9D"}
+{"version":3,"file":"getMarkdownMetadata.d.ts","names":[],"sources":["../../../../src/transpiler/markdown/getMarkdownMetadata.ts"],"mappings":";qBAEa,sBAAuB,UAAU,qBAAmB,qBAE9D"}

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