@intlayer/core 9.4.2 → 9.4.4

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

@@ -3,37 +3,37 @@ import { NestedParser, ParseState, ParserResult, Rule } from "./types.js";
 /**
  * Trim trailing whitespace from a string.
  */
-declare const trimEnd: (str: string) => string;
+export declare const trimEnd: (str: string) => string;
 /**
  * Check if string starts with prefix.
  */
-declare const startsWith: (str: string, prefix: string) => boolean;
+export declare const startsWith: (str: string, prefix: string) => boolean;
 /**
  * Remove symmetrical leading and trailing quotes.
  */
-declare const unquote: (str: string) => string;
+export declare const unquote: (str: string) => string;
 /**
  * Unescape backslash-escaped characters.
  */
-declare const unescapeString: (rawString: string) => string;
+export declare const unescapeString: (rawString: string) => string;
 /**
  * Join class names, filtering out falsy values.
  */
-declare const cx: (...args: any[]) => string;
+export declare const cx: (...args: any[]) => string;
 /**
  * Get a nested property from an object using dot notation.
  */
-declare const get: (src: any, path: string, fb?: any) => any;
-declare const slugify: (str: string) => string;
+export declare const get: (src: any, path: string, fb?: any) => any;
+export declare const slugify: (str: string) => string;
 /**
  * Sanitize URLs to prevent XSS attacks.
  * Returns null if the URL is unsafe.
  */
-declare const sanitizer: (input: string) => string | null;
+export declare const sanitizer: (input: string) => string | null;
 /**
  * Normalize whitespace in source string.
  */
-declare const normalizeWhitespace: (source: string) => string;
+export declare const normalizeWhitespace: (source: string) => string;
 /**
  * Safely remove a uniform leading indentation from lines, but do NOT touch
  * the content inside fenced code blocks (``` or ~~~).
@@ -44,98 +44,97 @@ declare const normalizeWhitespace: (source: string) => string;
  * element but written with its fence at column 0 therefore keeps its code
  * verbatim, instead of losing the first level of indentation.
  */
-declare const trimLeadingWhitespaceOutsideFences: (text: string, whitespace: string) => string;
+export declare const trimLeadingWhitespaceOutsideFences: (text: string, whitespace: string) => string;
 /**
  * Normalize HTML attribute key to JSX prop name.
  */
-declare const normalizeAttributeKey: (key: string) => string;
+export declare const normalizeAttributeKey: (key: string) => string;
 type StyleTuple = [key: string, value: string];
 /**
  * Parse a CSS style string into an array of [key, value] tuples.
  */
-declare const parseStyleAttribute: (styleString: string) => StyleTuple[];
+export declare const parseStyleAttribute: (styleString: string) => StyleTuple[];
 /**
  * Convert an attribute value to a Node prop value.
  */
-declare const attributeValueToNodePropValue: (tag: string, key: string, value: string, sanitizeUrlFn: (value: string, tag: string, attribute: string) => string | null) => any;
+export declare const attributeValueToNodePropValue: (tag: string, key: string, value: string, sanitizeUrlFn: (value: string, tag: string, attribute: string) => string | null) => any;
 /**
  * Parse table alignment from a separator row.
  */
-declare const parseTableAlignCapture: (alignCapture: string) => 'left' | 'right' | 'center';
+export declare const parseTableAlignCapture: (alignCapture: string) => 'left' | 'right' | 'center';
 /**
  * Parse table alignment row.
  */
-declare const parseTableAlign: (source: string) => ('left' | 'right' | 'center')[];
+export declare const parseTableAlign: (source: string) => ('left' | 'right' | 'center')[];
 /**
  * Parse a single table row.
  */
-declare const parseTableRow: (source: string, parse: NestedParser, state: ParseState, tableOutput: boolean) => ParserResult[][];
+export declare const parseTableRow: (source: string, parse: NestedParser, state: ParseState, tableOutput: boolean) => ParserResult[][];
 /**
  * Parse table cells (multiple rows).
  */
-declare const parseTableCells: (source: string, parse: NestedParser, state: ParseState) => ParserResult[][][];
+export declare const parseTableCells: (source: string, parse: NestedParser, state: ParseState) => ParserResult[][][];
 /**
  * Check if a rule qualifies for the current source and state.
  */
-declare const qualifies: (source: string, state: ParseState, qualify: NonNullable<Rule<any>['_qualify']>) => boolean;
+export declare const qualifies: (source: string, state: ParseState, qualify: NonNullable<Rule<any>['_qualify']>) => boolean;
 /**
  * Marks a matcher function as eligible for being run inside an inline context.
  */
-declare const allowInline: <T extends (...args: any[]) => any>(fn: T) => T & {
+export declare const allowInline: <T extends (...args: any[]) => any>(fn: T) => T & {
   inline: 1;
 };
 /**
  * Creates a match function for an inline scoped element from a regex.
  */
-declare const inlineRegex: (regex: RegExp) => ((source: string, state: ParseState) => RegExpMatchArray | null) & {
+export declare const inlineRegex: (regex: RegExp) => ((source: string, state: ParseState) => RegExpMatchArray | null) & {
   inline: 1;
 };
 /**
  * Creates a match function for inline elements except links.
  */
-declare const simpleInlineRegex: (regex: RegExp) => ((source: string, state: ParseState) => RegExpMatchArray | null) & {
+export declare const simpleInlineRegex: (regex: RegExp) => ((source: string, state: ParseState) => RegExpMatchArray | null) & {
   inline: 1;
 };
 /**
  * Creates a match function for a block scoped element from a regex.
  */
-declare const blockRegex: (regex: RegExp) => (source: string, state: ParseState) => RegExpMatchArray | null;
+export declare const blockRegex: (regex: RegExp) => (source: string, state: ParseState) => RegExpMatchArray | null;
 /**
  * Creates a match function from a regex, ignoring block/inline scope.
  */
-declare const anyScopeRegex: (fn: RegExp | ((source: string, state: ParseState) => RegExpMatchArray | null)) => ((source: string, state: ParseState) => RegExpMatchArray | null) & {
+export declare const anyScopeRegex: (fn: RegExp | ((source: string, state: ParseState) => RegExpMatchArray | null)) => ((source: string, state: ParseState) => RegExpMatchArray | null) & {
   inline: 1;
 };
 /**
  * Parse inline content (including links).
  */
-declare const parseInline: (parse: NestedParser, children: string, state: ParseState) => ParserResult[];
+export declare const parseInline: (parse: NestedParser, children: string, state: ParseState) => ParserResult[];
 /**
  * Parse simple inline content (no links).
  */
-declare const parseSimpleInline: (parse: NestedParser, children: string, state: ParseState) => ParserResult[];
+export declare const parseSimpleInline: (parse: NestedParser, children: string, state: ParseState) => ParserResult[];
 /**
  * Parse block content.
  */
-declare const parseBlock: (parse: NestedParser, children: string, state?: ParseState) => ParserResult[];
+export declare const parseBlock: (parse: NestedParser, children: string, state?: ParseState) => ParserResult[];
 /**
  * Helper to parse capture group 2 as inline content.
  */
-declare const parseCaptureInline: (capture: RegExpMatchArray, parse: NestedParser, state: ParseState) => {
+export declare const parseCaptureInline: (capture: RegExpMatchArray, parse: NestedParser, state: ParseState) => {
   children: ParserResult[];
 };
 /**
  * Helper that captures nothing (empty object).
  */
-declare const captureNothing: () => Record<string, never>;
+export declare const captureNothing: () => Record<string, never>;
 /**
  * Helper that renders nothing (null).
  */
-declare const renderNothing: () => null;
+export declare const renderNothing: () => null;
 /**
  * Check if any regex in a list matches the input.
  */
-declare const some: (regexes: RegExp[], input: string) => boolean;
+export declare const some: (regexes: RegExp[], input: string) => boolean;
 //#endregion
-export { allowInline, anyScopeRegex, attributeValueToNodePropValue, blockRegex, captureNothing, cx, get, inlineRegex, normalizeAttributeKey, normalizeWhitespace, parseBlock, parseCaptureInline, parseInline, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, qualifies, renderNothing, sanitizer, simpleInlineRegex, slugify, some, startsWith, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, unquote };
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../src/markdown/utils.ts"],"mappings":";;;;;cAsBa,UAAO;;;;cAWP,aAAU,aAAe;;;;cAOzB,UAAO;;;;cAiBP,iBAAc;;;;cAMd,QAAE;;;;cAKF,MAAG,UAAY,cAAc;cAoC7B,UAAO;;;;;cAsBP,YAAS;;;;cAqCT,sBAAmB;;;;;;;;;;;cAoBnB,qCAAkC,cACjC;;;;cAwCD,wBAAqB;KAY7B,cAAc,aAAa;;;;cAKnB,sBAAmB,wBAA0B;;;;cA+D7C,gCAA6B,aAC7B,aACA,eACE,gBAEX,eACA,aACA;;;;cA0CS,yBAAsB;;;;cAiBtB,kBAAe;;;;cAUf,gBAAa,gBACV,OACP,cAAY,OACZ,YAAU,yBAEhB;;;;cA8CU,kBAAe,gBACZ,OACP,cAAY,OACZ,eACN;;;;cAiBU,YAAS,gBACN,OACP,YAAU,SACR,YAAY;;;;cAmBV,cAAe,cAAc,qBAAmB,IACvD,MACH;EAAM;;;;;cAQI,cAAW,OAAW,aAAM,gBACZ,OAAS,eAAa;EATlC;;;;;cAoBJ,oBAAiB,OAAW,aAAM,gBAClB,OAAS,eAAa;EArBlC;;;;;cAgCJ,aAAU,OACb,YAAM,gBACC,OAAS,eAAa;;;;cAW1B,gBAAa,IACpB,WAAW,gBAAgB,OAAO,eAAe,+BAAwB,gBAElD,OAAS,eAAa;EAhDlC;;;;;cA0DJ,cAAW,OACf,cAAY,kBACH,OACT,eACN;;;;cAeU,oBAAiB,OACrB,cAAY,kBACH,OACT,eACN;;;;cAgBU,aAAU,OACd,cAAY,kBACH,QACT,eACN;;;;cAoBU,qBAAkB,SACpB,kBAAgB,OAClB,cAAY,OACZ;EACJ,UAAU;;;;;cASF,sBAAqB;;;;cAKrB;;;;cAKA,OAAI,SAAa,UAAQ"}
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../src/markdown/utils.ts"],"mappings":";;;;;qBAsBa,UAAO;;;;qBAWP,aAAU,aAAe;;;;qBAOzB,UAAO;;;;qBAiBP,iBAAc;;;;qBAMd,QAAE;;;;qBAKF,MAAG,UAAY,cAAc;qBAoC7B,UAAO;;;;;qBAsBP,YAAS;;;;qBAqCT,sBAAmB;;;;;;;;;;;qBAoBnB,qCAAkC,cACjC;;;;qBAwCD,wBAAqB;KAY7B,cAAc,aAAa;;;;qBAKnB,sBAAmB,wBAA0B;;;;qBA+D7C,gCAA6B,aAC7B,aACA,eACE,gBAEX,eACA,aACA;;;;qBA0CS,yBAAsB;;;;qBAiBtB,kBAAe;;;;qBAUf,gBAAa,gBACV,OACP,cAAY,OACZ,YAAU,yBAEhB;;;;qBA8CU,kBAAe,gBACZ,OACP,cAAY,OACZ,eACN;;;;qBAiBU,YAAS,gBACN,OACP,YAAU,SACR,YAAY;;;;qBAmBV,cAAe,cAAc,qBAAmB,IACvD,MACH;EAAM;;;;;qBAQI,cAAW,OAAW,aAAM,gBACZ,OAAS,eAAa;EATlC;;;;;qBAoBJ,oBAAiB,OAAW,aAAM,gBAClB,OAAS,eAAa;EArBlC;;;;;qBAgCJ,aAAU,OACb,YAAM,gBACC,OAAS,eAAa;;;;qBAW1B,gBAAa,IACpB,WAAW,gBAAgB,OAAO,eAAe,+BAAwB,gBAElD,OAAS,eAAa;EAhDlC;;;;;qBA0DJ,cAAW,OACf,cAAY,kBACH,OACT,eACN;;;;qBAeU,oBAAiB,OACrB,cAAY,kBACH,OACT,eACN;;;;qBAgBU,aAAU,OACd,cAAY,kBACH,QACT,eACN;;;;qBAoBU,qBAAkB,SACpB,kBAAgB,OAClB,cAAY,OACZ;EACJ,UAAU;;;;;qBASF,sBAAqB;;;;qBAKrB;;;;qBAKA,OAAI,SAAa,UAAQ"}

package/dist/types/messageFormat/ICU.d.ts

@@ -1,10 +1,9 @@
 import { Dictionary } from "@intlayer/types/dictionary";
 //#region src/messageFormat/ICU.d.ts
-type JsonValue = string | number | boolean | null | JsonValue[] | {
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
   [key: string]: JsonValue;
 };
-declare const intlayerToICUFormatter: (message: Dictionary['content']) => JsonValue;
-declare const icuToIntlayerFormatter: (message: Dictionary['content']) => JsonValue;
+export declare const intlayerToICUFormatter: (message: Dictionary['content']) => JsonValue;
+export declare const icuToIntlayerFormatter: (message: Dictionary['content']) => JsonValue;
 //#endregion
-export { JsonValue, icuToIntlayerFormatter, intlayerToICUFormatter };
 //# sourceMappingURL=ICU.d.ts.map

package/dist/types/messageFormat/ICU.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ICU.d.ts","names":[],"sources":["../../../src/messageFormat/ICU.ts"],"mappings":";;KAkDY,+CAKR;GACG,cAAc;;cAknBR,yBAAsB,SACxB,0BACR;cAQU,yBAAsB,SACxB,0BACR"}
+{"version":3,"file":"ICU.d.ts","names":[],"sources":["../../../src/messageFormat/ICU.ts"],"mappings":";;YAkDY,+CAKR;GACG,cAAc;;qBAknBR,yBAAsB,SACxB,0BACR;qBAQU,yBAAsB,SACxB,0BACR"}

package/dist/types/messageFormat/i18next.d.ts

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

package/dist/types/messageFormat/i18next.d.ts.map

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

package/dist/types/messageFormat/navigatePath.d.ts

@@ -16,7 +16,6 @@
  *   (flat lookup only), mirroring i18next's `keySeparator: false`.
  * @returns The value found at `path`, or `undefined` when any segment is absent.
  */
-declare const navigatePath: (contentValue: unknown, path: string, keySeparator?: string | false) => unknown;
+export declare const navigatePath: (contentValue: unknown, path: string, keySeparator?: string | false) => unknown;
 //#endregion
-export { navigatePath };
 //# sourceMappingURL=navigatePath.d.ts.map

package/dist/types/messageFormat/navigatePath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"navigatePath.d.ts","names":[],"sources":["../../../src/messageFormat/navigatePath.ts"],"mappings":";;;;;;;;;;;;;;;;;;cAiBa,eAAY,uBACF,cACT"}
+{"version":3,"file":"navigatePath.d.ts","names":[],"sources":["../../../src/messageFormat/navigatePath.ts"],"mappings":";;;;;;;;;;;;;;;;;;qBAiBa,eAAY,uBACF,cACT"}

package/dist/types/messageFormat/po.d.ts

@@ -1,14 +1,13 @@
 import { JsonValue } from "./ICU.js";
 import { Dictionary } from "@intlayer/types/dictionary";
 //#region src/messageFormat/po.d.ts
-type PortableObject = {
+export type PortableObject = {
   msgid: string;
   msgctxt?: string;
   msgid_plural?: string;
   msgstr: string[];
 };
-declare const intlayerToPortableObjectFormatter: (dictionary: Dictionary['content']) => JsonValue;
-declare const portableObjectToIntlayerFormatter: (message: JsonValue) => Dictionary['content'];
+export declare const intlayerToPortableObjectFormatter: (dictionary: Dictionary['content']) => JsonValue;
+export declare const portableObjectToIntlayerFormatter: (message: JsonValue) => Dictionary['content'];
 //#endregion
-export { PortableObject, intlayerToPortableObjectFormatter, portableObjectToIntlayerFormatter };
 //# sourceMappingURL=po.d.ts.map

package/dist/types/messageFormat/po.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"po.d.ts","names":[],"sources":["../../../src/messageFormat/po.ts"],"mappings":";;;KAMY;EACV;EACA;EACA;EACA;;cAgPW,oCAAiC,YAChC,0BACX;cAQU,oCAAiC,SACnC,cACR"}
+{"version":3,"file":"po.d.ts","names":[],"sources":["../../../src/messageFormat/po.ts"],"mappings":";;;YAMY;EACV;EACA;EACA;EACA;;qBAgPW,oCAAiC,YAChC,0BACX;qBAQU,oCAAiC,SACnC,cACR"}

package/dist/types/messageFormat/resolveMessage.d.ts

@@ -13,9 +13,9 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  * (`@intlayer/i18next`, `@intlayer/next-intl`, `@intlayer/vue-i18n`, …).
  */
 /** Message syntax dialect of the source i18n library. */
-type MessageFormatDialect = 'icu' | 'i18next' | 'vue-i18n';
+export type MessageFormatDialect = 'icu' | 'i18next' | 'vue-i18n';
 /** Interpolation values passed alongside a translation lookup. */
-type MessageValues = Record<string, unknown>;
+export type MessageValues = Record<string, unknown>;
 /**
  * Interpolates a message template with values.
  *
@@ -24,7 +24,7 @@ type MessageValues = Record<string, unknown>;
  * 2. ICU formatted arguments `{value, number}` / `{ts, date, long}`
  * 3. Bare single-brace arguments `{name}` (ICU / vue-i18n simple args)
  */
-declare const interpolateMessage: (template: string, values?: MessageValues, locale?: LocalesValues) => string;
+export declare const interpolateMessage: (template: string, values?: MessageValues, locale?: LocalesValues) => string;
 /**
  * Resolves an intlayer message node tree (as produced by the
  * `*ToIntlayerFormatter` converters, or already present in a built
@@ -33,7 +33,7 @@ declare const interpolateMessage: (template: string, values?: MessageValues, loc
  * Function nodes (produced by the interpreter plugins for `insertion`,
  * `enumeration` and `plural` content) are invoked with the values.
  */
-declare const resolveMessageNode: (node: unknown, values?: MessageValues, locale?: LocalesValues) => unknown;
+export declare const resolveMessageNode: (node: unknown, values?: MessageValues, locale?: LocalesValues) => unknown;
 /**
  * Resolves a raw message — string in a library dialect, or an intlayer node
  * tree — into a final string using interpolation values and locale.
@@ -52,9 +52,9 @@ declare const resolveMessageNode: (node: unknown, values?: MessageValues, locale
  * // '3 items'
  * ```
  */
-declare const resolveMessage: (message: unknown, values?: MessageValues, locale?: LocalesValues, dialect?: MessageFormatDialect) => string;
+export declare const resolveMessage: (message: unknown, values?: MessageValues, locale?: LocalesValues, dialect?: MessageFormatDialect) => string;
 /** A parsed token of a tagged message: plain text or a tag with children. */
-type TaggedMessageToken = string | {
+export type TaggedMessageToken = string | {
   tag: string;
   children: TaggedMessageToken[];
 };
@@ -65,7 +65,6 @@ type TaggedMessageToken = string | {
  * Used by rich-text renderers (`t.rich`, `<Trans components>`,
  * `<i18n-t>` slots) to map tags to framework elements.
  */
-declare const parseTaggedMessage: (message: string) => TaggedMessageToken[];
+export declare const parseTaggedMessage: (message: string) => TaggedMessageToken[];
 //#endregion
-export { MessageFormatDialect, MessageValues, TaggedMessageToken, interpolateMessage, parseTaggedMessage, resolveMessage, resolveMessageNode };
 //# sourceMappingURL=resolveMessage.d.ts.map

package/dist/types/messageFormat/resolveMessage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolveMessage.d.ts","names":[],"sources":["../../../src/messageFormat/resolveMessage.ts"],"mappings":";;;;;;;;;;;;;;;KAyBY;;KAGA,gBAAgB;;;;;;;;;cAsFf,qBAAkB,kBACb,SACR,eAAa,SACb;;;;;;;;;cAkCG,qBAAkB,eAChB,SACL,eAAa,SACb;;;;;;;;;;;;;;;;;;;cA2JG,iBAAc,kBACT,SACR,eAAa,SACb,eAAa,UACZ;;KAaC;EAEN;EAAa,UAAU;;;;;;;;;cAShB,qBAAkB,oBAAsB"}
+{"version":3,"file":"resolveMessage.d.ts","names":[],"sources":["../../../src/messageFormat/resolveMessage.ts"],"mappings":";;;;;;;;;;;;;;;YAyBY;;YAGA,gBAAgB;;;;;;;;;qBAsFf,qBAAkB,kBACb,SACR,eAAa,SACb;;;;;;;;;qBAkCG,qBAAkB,eAChB,SACL,eAAa,SACb;;;;;;;;;;;;;;;;;;;qBA2JG,iBAAc,kBACT,SACR,eAAa,SACb,eAAa,UACZ;;YAaC;EAEN;EAAa,UAAU;;;;;;;;;qBAShB,qBAAkB,oBAAsB"}

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