@intlayer/core 9.0.0-canary.2 → 9.0.0-canary.20

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

@@ -2,10 +2,11 @@ import { HTMLValidationIssue } from "../transpiler/html/validateHTML.js";
 import { getMarkdownMetadata } from "../transpiler/markdown/getMarkdownMetadata.js";
 import { MarkdownContent, MarkdownContentConstructor, md as markdown } from "../transpiler/markdown/markdown.js";
 import { MarkdownValidationResult, validateMarkdown } from "../transpiler/markdown/validateMarkdown.js";
+import "../transpiler/markdown/index.js";
 import { BlockQuoteNode, BoldTextNode, BreakLineNode, BreakThematicNode, CodeBlockNode, CodeFencedNode, CodeInlineNode, CompileOptions, ComponentOverrides, CustomComponentNode, ElementType, EscapedTextNode, FootnoteNode, FootnoteReferenceNode, GFMTaskNode, HTMLCommentNode, HTMLNode, HTMLSelfClosingNode, HTMLTag, HeadingNode, HeadingSetextNode, ImageNode, ItalicTextNode, LinkAngleBraceNode, LinkBareURLNode, LinkNode, MarkdownContext, MarkdownOptions, MarkdownRuntime, MarkedTextNode, NestedParser, NewlineNode, OrderedListNode, ParagraphNode, ParseState, Parser, ParserResult, ReferenceImageNode, ReferenceLinkNode, ReferenceNode, RenderRuleHook, Rule, RuleOutput, Rules, StrikethroughTextNode, TableNode, TableSeparatorNode, TextNode, UnorderedListNode } from "./types.js";
 import { ParsedMarkdown, compile, compileWithOptions, createCompiler, parseMarkdown, renderMarkdownAst } from "./compiler.js";
 import { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_R, DO_NOT_PROCESS_HTML_ELEMENTS, DURATION_DELAY_TRIGGER, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, GFM_TASK_R, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, HTML_BLOCK_ELEMENT_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, INLINE_SKIP_R, INTERPOLATION_R, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, LOOKAHEAD, ListType, NAMED_CODES_TO_UNICODE, NP_TABLE_R, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, PARAGRAPH_R, Priority, PriorityValue, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleType, RuleTypeValue, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex } from "./constants.js";
 import { parserFor } from "./parser.js";
 import { createRenderer, renderFor } from "./renderer.js";
 import { 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 } from "./utils.js";
-export { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, BlockQuoteNode, BoldTextNode, BreakLineNode, BreakThematicNode, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_R, CodeBlockNode, CodeFencedNode, CodeInlineNode, CompileOptions, ComponentOverrides, CustomComponentNode, DO_NOT_PROCESS_HTML_ELEMENTS, DURATION_DELAY_TRIGGER, ElementType, EscapedTextNode, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, FootnoteNode, FootnoteReferenceNode, GFMTaskNode, GFM_TASK_R, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, HTMLCommentNode, HTMLNode, HTMLSelfClosingNode, HTMLTag, HTML_BLOCK_ELEMENT_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, HeadingNode, HeadingSetextNode, INLINE_SKIP_R, INTERPOLATION_R, ImageNode, ItalicTextNode, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, LOOKAHEAD, LinkAngleBraceNode, LinkBareURLNode, LinkNode, ListType, MarkdownContent, MarkdownContentConstructor, MarkdownContext, MarkdownOptions, MarkdownRuntime, HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, MarkedTextNode, NAMED_CODES_TO_UNICODE, NP_TABLE_R, NestedParser, NewlineNode, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, OrderedListNode, PARAGRAPH_R, ParagraphNode, ParseState, ParsedMarkdown, Parser, ParserResult, Priority, PriorityValue, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, ReferenceImageNode, ReferenceLinkNode, ReferenceNode, RenderRuleHook, Rule, RuleOutput, RuleType, RuleTypeValue, Rules, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, StrikethroughTextNode, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, TableNode, TableSeparatorNode, TextNode, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, UnorderedListNode, allowInline, anyScopeRegex, attributeValueToNodePropValue, blockRegex, captureNothing, compile, compileWithOptions, createCompiler, createRenderer, cx, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex, get, getMarkdownMetadata, inlineRegex, markdown as md, normalizeAttributeKey, normalizeWhitespace, parseBlock, parseCaptureInline, parseInline, parseMarkdown, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, parserFor, qualifies, renderFor, renderMarkdownAst, renderNothing, sanitizer, simpleInlineRegex, slugify, some, startsWith, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, unquote, validateMarkdown };
+export { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, type BlockQuoteNode, type BoldTextNode, type BreakLineNode, type BreakThematicNode, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_R, type CodeBlockNode, type CodeFencedNode, type CodeInlineNode, type CompileOptions, type ComponentOverrides, type CustomComponentNode, DO_NOT_PROCESS_HTML_ELEMENTS, DURATION_DELAY_TRIGGER, type ElementType, type EscapedTextNode, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, type FootnoteNode, type FootnoteReferenceNode, type GFMTaskNode, GFM_TASK_R, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, type HTMLCommentNode, type HTMLNode, type HTMLSelfClosingNode, type HTMLTag, HTML_BLOCK_ELEMENT_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, type HeadingNode, type HeadingSetextNode, INLINE_SKIP_R, INTERPOLATION_R, type ImageNode, type ItalicTextNode, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, LOOKAHEAD, type LinkAngleBraceNode, type LinkBareURLNode, type LinkNode, ListType, MarkdownContent, MarkdownContentConstructor, type MarkdownContext, type MarkdownOptions, type MarkdownRuntime, type HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, type MarkedTextNode, NAMED_CODES_TO_UNICODE, NP_TABLE_R, type NestedParser, type NewlineNode, ORDERED, ORDERED_LIST_BULLET, ORDERED_LIST_ITEM_PREFIX, ORDERED_LIST_ITEM_PREFIX_R, ORDERED_LIST_ITEM_R, ORDERED_LIST_R, type OrderedListNode, PARAGRAPH_R, type ParagraphNode, type ParseState, ParsedMarkdown, type Parser, type ParserResult, Priority, PriorityValue, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, type ReferenceImageNode, type ReferenceLinkNode, type ReferenceNode, type RenderRuleHook, type Rule, type RuleOutput, RuleType, RuleTypeValue, type Rules, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, type StrikethroughTextNode, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, type TableNode, type TableSeparatorNode, type TextNode, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, type UnorderedListNode, allowInline, anyScopeRegex, attributeValueToNodePropValue, blockRegex, captureNothing, compile, compileWithOptions, createCompiler, createRenderer, cx, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex, get, getMarkdownMetadata, inlineRegex, markdown as md, normalizeAttributeKey, normalizeWhitespace, parseBlock, parseCaptureInline, parseInline, parseMarkdown, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, parserFor, qualifies, renderFor, renderMarkdownAst, renderNothing, sanitizer, simpleInlineRegex, slugify, some, startsWith, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, unquote, validateMarkdown };

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

@@ -1,5 +1,4 @@
 import { ParseState, ParserResult, Rules } from "./types.js";
-
 //#region src/markdown/parser.d.ts
 /**
  * Creates a parser for a given set of rules, with the precedence

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

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","names":[],"sources":["../../../src/markdown/parser.ts"],"mappings":";;;;;AAaA;;;;;;;cAAa,SAAA,GACX,KAAA,EAAO,KAAA,OACJ,MAAA,UAAgB,KAAA,EAAO,UAAA,KAAe,YAAA"}
+{"version":3,"file":"parser.d.ts","names":[],"sources":["../../../src/markdown/parser.ts"],"mappings":";;;;;;;;;;;cAaa,YAAS,OACb,YACJ,gBAAgB,OAAO,eAAe"}

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

@@ -1,5 +1,4 @@
 import { ParseState, ParserResult, RenderRuleHook, RuleOutput, Rules } from "./types.js";
-
 //#region src/markdown/renderer.d.ts
 /**
  * Creates a renderer for AST nodes.

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

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","names":[],"sources":["../../../src/markdown/renderer.ts"],"mappings":";;;;;AAgBA;;;;;cAAa,SAAA,GAET,MAAA,GACE,GAAA,EAAK,YAAA,EACL,MAAA,EAAQ,UAAA,EACR,KAAA,EAAO,UAAA,kBAGV,GAAA,EAAK,YAAA,GAAe,YAAA,IAAgB,KAAA,GAAO,UAAA;;;;;;;;cAiEjC,cAAA,GACV,KAAA,EAAO,KAAA,EAAO,UAAA,GAAa,cAAA,MAC3B,GAAA,EAAK,YAAA,EAAc,MAAA,EAAQ,UAAA,EAAY,KAAA,EAAO,UAAA"}
+{"version":3,"file":"renderer.d.ts","names":[],"sources":["../../../src/markdown/renderer.ts"],"mappings":";;;;;;;;;cAgBa,YAAS,SAGhB,KAAK,cACL,QAAQ,YACR,OAAO,4BACG,KAER,eAAe,gBAAc,QAAS;;;;;;;;cAiEjC,iBAAc,OACjB,OAAK,aAAe,oBAAc,KACpC,cAAY,QAAU,YAAU,OAAS"}

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

@@ -44,23 +44,36 @@ type MarkdownRuntime = {
  * Context passed to the compiler containing runtime and configuration.
  */
 type MarkdownContext<T> = {
-  /** Framework runtime (createElement, etc.) */runtime: MarkdownRuntime; /** Component components for HTML tags */
-  components?: ComponentOverrides<T>; /** Custom URL sanitizer */
-  sanitizer?: (url: string, tag: HTMLTag, attr: string) => string | null; /** Custom slugify function for heading IDs */
-  slugify?: (text: string, defaultFn: (input: string) => string) => string; /** Custom named codes to unicode mappings */
+  /** Framework runtime (createElement, etc.) */
+  runtime: MarkdownRuntime;
+  /** Component components for HTML tags */
+  components?: ComponentOverrides<T>;
+  /** Custom URL sanitizer */
+  sanitizer?: (url: string, tag: HTMLTag, attr: string) => string | null;
+  /** Custom slugify function for heading IDs */
+  slugify?: (text: string, defaultFn: (input: string) => string) => string;
+  /** Custom named codes to unicode mappings */
   namedCodesToUnicode?: Record<string, string>;
 };
 /**
  * Parser state passed through parsing and rendering.
  */
 type ParseState = {
-  /** true if the current content is inside anchor link grammar */inAnchor?: boolean; /** true if parsing in an HTML context */
-  inHTML?: boolean; /** true if parsing in an inline context (subset of rules around formatting and links) */
-  inline?: boolean; /** true if in a table */
-  inTable?: boolean; /** use this for the `key` prop */
-  key?: string | number; /** true if in a list */
-  list?: boolean; /** used for lookbacks */
-  prevCapture?: string; /** true if parsing in inline context w/o links */
+  /** true if the current content is inside anchor link grammar */
+  inAnchor?: boolean;
+  /** true if parsing in an HTML context */
+  inHTML?: boolean;
+  /** true if parsing in an inline context (subset of rules around formatting and links) */
+  inline?: boolean;
+  /** true if in a table */
+  inTable?: boolean;
+  /** use this for the `key` prop */
+  key?: string | number;
+  /** true if in a list */
+  list?: boolean;
+  /** used for lookbacks */
+  prevCapture?: string;
+  /** true if parsing in inline context w/o links */
   simple?: boolean;
 };
 type BlockQuoteNode = {
@@ -234,8 +247,11 @@ type RuleOutput = (ast: ParserResult | ParserResult[], state: ParseState) => unk
  * Rule definition for parsing and rendering markdown.
  */
 type Rule<ParserOutput = ParserResult> = {
-  /** Match function - returns regex match or null */_match: (source: string, state: ParseState, prevCapturedString?: string) => RegExpMatchArray | null; /** Priority order for rule application */
-  _order: number; /** Parse function - converts regex capture to AST node */
+  /** Match function - returns regex match or null */
+  _match: (source: string, state: ParseState, prevCapturedString?: string) => RegExpMatchArray | null;
+  /** Priority order for rule application */
+  _order: number;
+  /** Parse function - converts regex capture to AST node */
   _parse: Parser<Omit<ParserOutput, 'type'>>;
   /**
    * Optional fast check that can quickly determine if this rule
@@ -263,14 +279,14 @@ type ComponentOverrides<T> = {
 /**
  * Render rule hook for custom rendering logic.
  */
-type RenderRuleHook = (/** Resume normal processing, call this function as a fallback */
-
-next: () => unknown, /** The current AST node */
-
-node: ParserResult, /** Use as renderChildren(node.children) for block nodes */
-
-renderChildren: RuleOutput, /** Contains key which should be supplied to the topmost element */
-
+type RenderRuleHook = (
+/** Resume normal processing, call this function as a fallback */
+next: () => unknown,
+/** The current AST node */
+node: ParserResult,
+/** Use as renderChildren(node.children) for block nodes */
+renderChildren: RuleOutput,
+/** Contains key which should be supplied to the topmost element */
 state: ParseState) => unknown;
 /**
  * Options for the markdown compiler.
@@ -323,9 +339,13 @@ type MarkdownOptions = {
  * Used by framework adapters.
  */
 type CompileOptions<T = any> = MarkdownOptions & {
-  /** Component components */components?: ComponentOverrides<T>; /** Custom named codes to unicode mappings */
-  namedCodesToUnicode?: Record<string, string>; /** Custom sanitizer function */
-  sanitizer?: (value: string, tag: HTMLTag, attribute: string) => string | null; /** Custom slugify function */
+  /** Component components */
+  components?: ComponentOverrides<T>;
+  /** Custom named codes to unicode mappings */
+  namedCodesToUnicode?: Record<string, string>;
+  /** Custom sanitizer function */
+  sanitizer?: (value: string, tag: HTMLTag, attribute: string) => string | null;
+  /** Custom slugify function */
   slugify?: (input: string, defaultFn: (input: string) => string) => string;
 };
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/markdown/types.ts"],"mappings":"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"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/markdown/types.ts"],"mappings":";;;;;KAQY;;;;KAKA;;;;;KAMA;;;;;;;EAOV,gBACE,MAAM,aACN,OAAO,+BACJ;;;;;EAOL;;;;;;;;;;EAWA,kBACE,KAAK,SACL,OAAO,wBACJ;;;;GAKJ;;;;;KAMS,gBAAgB;;EAE1B,SAAS;;EAET,aAAa,mBAAmB;;EAEhC,aAAa,aAAa,KAAK,SAAS;;EAExC,WAAW,cAAc,YAAY;;EAErC,sBAAsB;;;;;KAUZ;;EAEV;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;KAOU;EACV;EACA;EACA,UAAU;;KAGA;EACV;;KAGU;EACV;;KAGU;EACV;EACA,QAAQ;EACR;EACA;;KAGU;EACV;;KAGU;EACV;EACA;;KAGU;EACV;;KAGU;EACV;EACA;EACA;;KAGU;EACV;EACA;;KAGU;EACV;EACA,UAAU;EACV;EACA;;KAGU;EACV;;KAGU;EACV;;KAGU;EACV;EACA;EACA;EACA;;KAGU;EACV;EACA,UAAU;EACV;EACA;;KAGU;EACV;;KAGU;EACV;;KAGU;EACV;EACA,OAAO;EACP;EACA;;KAGU;EACV;EACA,OAAO;EACP;;KAGU;EACV;;KAGU;EACV;EACA,UAAU;;KAGA;EACV;;KAGU;EACV;EACA;EACA;;KAGU;EACV;EACA,UAAU;EACV;EACA;;KAGU;EACV;EACA;EACA,OAAO;EACP,QAAQ;;KAGE;EACV;;KAGU;EACV;EACA;;KAGU;EACV;EACA,UAAU;;KAGA;EACV;EACA,UAAU;;KAGA;EACV;;KAGU;EACV;EACA,UAAU;;KAGA;EACV;EACA,UAAU;;KAGA;EACV;EACA,OAAO;EACP,WAAW;EACX;EACA,KAAK;EACL;;KAGU;EACV;EACA,OAAO;EACP;;KAGU;EACV;EACA,OAAO;EACP,WAAW;EACX;EACA;EACA;;;;;KAMU,eACR,iBACA,gBACA,oBACA,gBACA,iBACA,iBACA,sBACA,eACA,wBACA,cACA,cACA,oBACA,kBACA,YACA,WACA,qBACA,kBACA,kBACA,oBACA,cACA,gBACA,gBACA,qBACA,oBACA,YACA,qBACA,WACA,eACA,iBACA,kBACA,iBACA,wBACA,WACA;;;;KASQ,gBAAgB,eAAe,OAAO,eAAe;;;;KAKrD,OAAO,iBACjB,SAAS,kBACT,aAAa,cACb,OAAO,eACJ;;;;KAKO,cACV,KAAK,eAAe,gBACpB,OAAO;;;;KAMG,KAAK,eAAe;;EAE9B,SACE,gBACA,OAAO,YACP,gCACG;;EAGL;;EAGA,QAAQ,OAAO,KAAK;;;;;EAMpB,wBAAwB,gBAAgB,OAAO;;;;;EAM/C,WACE,MAAM,cACN,QAAQ,YACR,OAAO;;;;;KAOC;GACT,cAAc;;;;;KAUL,mBAAmB;GAC5B,cAAc;;;;;KAUL,kBAEV;;AAAA,qBAEA;;AAAA,MAAM,cAEN;;AAAA,gBAAgB,YAEhB;;AAAA,OAAO;;;;;KAOG;;;;EAIV;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA,aAAa;;;;EAKb,UAAU;;;;EAKV;;;;EAKA;;;;;;KAOU,eAAe,WAAW;;EAEpC,aAAa,mBAAmB;;EAEhC,sBAAsB;;EAEtB,aAAa,eAAe,KAAK,SAAS;;EAE1C,WAAW,eAAe,YAAY"}

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

@@ -1,5 +1,4 @@
 import { NestedParser, ParseState, ParserResult, Rule } from "./types.js";
-
 //#region src/markdown/utils.d.ts
 /**
  * Trim trailing whitespace from a string.
@@ -60,11 +59,11 @@ declare const attributeValueToNodePropValue: (tag: string, key: string, value: s
 /**
  * Parse table alignment from a separator row.
  */
-declare const parseTableAlignCapture: (alignCapture: string) => "left" | "right" | "center";
+declare const parseTableAlignCapture: (alignCapture: string) => 'left' | 'right' | 'center';
 /**
  * Parse table alignment row.
  */
-declare const parseTableAlign: (source: string) => ("left" | "right" | "center")[];
+declare const parseTableAlign: (source: string) => ('left' | 'right' | 'center')[];
 /**
  * Parse a single table row.
  */
@@ -76,7 +75,7 @@ declare const parseTableCells: (source: string, parse: NestedParser, state: Pars
 /**
  * Check if a rule qualifies for the current source and state.
  */
-declare const qualifies: (source: string, state: ParseState, qualify: NonNullable<Rule<any>["_qualify"]>) => boolean;
+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.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../src/markdown/utils.ts"],"mappings":";;;;;AAwBA;cAAa,OAAA,GAAW,GAAA;;;;cAWX,UAAA,GAAc,GAAA,UAAa,MAAA;;;;cAO3B,OAAA,GAAW,GAAA;AAAxB;;;AAAA,cAiBa,cAAA,GAAkB,SAAA;;AAA/B;;cAMa,EAAA,MAAS,IAAA;;;AAAtB;cAKa,GAAA,GAAO,GAAA,OAAU,IAAA,UAAc,EAAA;;;;AAA5C;cAsBa,OAAA,GAAW,GAAA;;;;;cAyBX,SAAA,GAAa,KAAA;;;AAzB1B;cAyDa,mBAAA,GAAuB,MAAA;;;;AAhCpC;cAsDa,kCAAA,GACX,IAAA,UACA,UAAA;;;;cA6BW,qBAAA,GAAyB,GAAA;AAAA,KAYjC,UAAA,IAAc,GAAA,UAAa,KAAA;;;;cAKnB,mBAAA,GAAuB,WAAA,aAAsB,UAAA;;;;cAwE7C,6BAAA,GACX,GAAA,UACA,GAAA,UACA,KAAA,UACA,aAAA,GACE,KAAA,UACA,GAAA,UACA,SAAA;AAhGJ;;;AAAA,cA0Ia,sBAAA,GACX,YAAA;;AAjIA;;cAiJW,eAAA,GACX,MAAA;;;AA3IF;cAoJa,aAAA,GACX,MAAA,UACA,KAAA,EAAO,YAAA,EACP,KAAA,EAAO,UAAA,EACP,WAAA,cACC,YAAA;;;;cAsDU,eAAA,GACX,MAAA,UACA,KAAA,EAAO,YAAA,EACP,KAAA,EAAO,UAAA,KACN,YAAA;;;;cAyBU,SAAA,GACX,MAAA,UACA,KAAA,EAAO,UAAA,EACP,OAAA,EAAS,WAAA,CAAY,IAAA;;;;cAmBV,WAAA,iBAA6B,IAAA,iBACxC,EAAA,EAAI,CAAA,KACH,CAAA;EAAM,MAAA;AAAA;;;AA3IT;cAmJa,WAAA,GAAe,KAAA,EAAO,MAAA,OAAM,MAAA,UACZ,KAAA,EAAS,UAAA,KAAa,gBAAA;;;;AAnInD;;cA8Ia,iBAAA,GAAqB,KAAA,EAAO,MAAA,OAAM,MAAA,UAClB,KAAA,EAAS,UAAA,KAAa,gBAAA;;;AArInD;;;AAAA,cAgJa,UAAA,GACV,KAAA,EAAO,MAAA,MACP,MAAA,UAAgB,KAAA,EAAO,UAAA,KAAa,gBAAA;;;;cAW1B,aAAA,GACX,EAAA,EAAI,MAAA,KAAW,MAAA,UAAgB,KAAA,EAAO,UAAA,KAAe,gBAAA,eAAwB,MAAA,UAElD,KAAA,EAAS,UAAA,KAAa,gBAAA;;;;;;cAUtC,WAAA,GACX,KAAA,EAAO,YAAA,EACP,QAAA,UACA,KAAA,EAAO,UAAA,KACN,YAAA;;;;cAuBU,iBAAA,GACX,KAAA,EAAO,YAAA,EACP,QAAA,UACA,KAAA,EAAO,UAAA,KACN,YAAA;;;;cAwBU,UAAA,GACX,KAAA,EAAO,YAAA,EACP,QAAA,UACA,KAAA,GAAO,UAAA,KACN,YAAA;;;;cA4BU,kBAAA,GACX,OAAA,EAAS,gBAAA,EACT,KAAA,EAAO,YAAA,EACP,KAAA,EAAO,UAAA;EACJ,QAAA,EAAU,YAAA;AAAA;;;;cASF,cAAA,QAAqB,MAAA;;AAtLlC;;cA2La,aAAA;;;;cAKA,IAAA,GAAQ,OAAA,EAAS,MAAA,IAAU,KAAA"}
+{"version":3,"file":"utils.d.ts","names":[],"sources":["../../../src/markdown/utils.ts"],"mappings":";;;;;cAwBa,UAAO;;;;cAWP,aAAU,aAAe;;;;cAOzB,UAAO;;;;cAiBP,iBAAc;;;;cAMd,QAAE;;;;cAKF,MAAG,UAAY,cAAc;;;;;cAsB7B,UAAO;;;;;cAyBP,YAAS;;;;cAgCT,sBAAmB;;;;;cAsBnB,qCAAkC,cACjC;;;;cA8BD,wBAAqB;KAY7B,cAAc,aAAa;;;;cAKnB,sBAAmB,wBAA0B;;;;cAwE7C,gCAA6B,aAC7B,aACA,eACE,gBAEX,eACA,aACA;;;;cA0CS,yBAAsB;;;;cAiBtB,kBAAe;;;;cAUf,gBAAa,gBACV,OACP,cAAY,OACZ,YAAU,yBAEhB;;;;cAsDU,kBAAe,gBACZ,OACP,cAAY,OACZ,eACN;;;;cAyBU,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;;;;cAuBU,oBAAiB,OACrB,cAAY,kBACH,OACT,eACN;;;;cAwBU,aAAU,OACd,cAAY,kBACH,QACT,eACN;;;;cA4BU,qBAAkB,SACpB,kBAAgB,OAClB,cAAY,OACZ;EACJ,UAAU;;;;;cASF,sBAAqB;;;;cAKrB;;;;cAKA,OAAI,SAAa,UAAQ"}

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

@@ -1,11 +1,10 @@
 import { Dictionary } from "@intlayer/types/dictionary";
-
 //#region src/messageFormat/ICU.d.ts
 type JsonValue = string | number | boolean | null | JsonValue[] | {
   [key: string]: JsonValue;
 };
-declare const intlayerToICUFormatter: (message: Dictionary["content"]) => JsonValue;
-declare const icuToIntlayerFormatter: (message: Dictionary["content"]) => JsonValue;
+declare const intlayerToICUFormatter: (message: Dictionary['content']) => JsonValue;
+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,SAAA,sCAKR,SAAA;EAAA,CACG,GAAA,WAAc,SAAA;AAAA;AAAA,cAwlBR,sBAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA;AAAA,cAQU,sBAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA"}
+{"version":3,"file":"ICU.d.ts","names":[],"sources":["../../../src/messageFormat/ICU.ts"],"mappings":";;KAkDY,+CAKR;GACG,cAAc;;cAwlBR,yBAAsB,SACxB,0BACR;cAQU,yBAAsB,SACxB,0BACR"}

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

@@ -1,9 +1,8 @@
 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"];
+declare const intlayerToI18nextFormatter: (message: Dictionary['content']) => JsonValue;
+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":";;;;cAsjBa,0BAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA;AAAA,cAQU,0BAAA,GACX,OAAA,EAAS,SAAA,KACR,UAAA"}
+{"version":3,"file":"i18next.d.ts","names":[],"sources":["../../../src/messageFormat/i18next.ts"],"mappings":";;;cAsjBa,6BAA0B,SAC5B,0BACR;cAQU,6BAA0B,SAC5B,cACR"}

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

@@ -1,6 +1,7 @@
 import { JsonValue, icuToIntlayerFormatter, intlayerToICUFormatter } from "./ICU.js";
 import { i18nextToIntlayerFormatter, intlayerToI18nextFormatter } from "./i18next.js";
+import { navigatePath } from "./navigatePath.js";
 import { PortableObject, intlayerToPortableObjectFormatter, portableObjectToIntlayerFormatter } from "./po.js";
 import { MessageFormatDialect, MessageValues, TaggedMessageToken, interpolateMessage, parseTaggedMessage, resolveMessage, resolveMessageNode } from "./resolveMessage.js";
 import { intlayerToVueI18nFormatter, vueI18nToIntlayerFormatter } from "./vue-i18n.js";
-export { JsonValue, MessageFormatDialect, MessageValues, PortableObject, TaggedMessageToken, i18nextToIntlayerFormatter, icuToIntlayerFormatter, interpolateMessage, intlayerToI18nextFormatter, intlayerToICUFormatter, intlayerToPortableObjectFormatter, intlayerToVueI18nFormatter, parseTaggedMessage, portableObjectToIntlayerFormatter, resolveMessage, resolveMessageNode, vueI18nToIntlayerFormatter };
+export { JsonValue, MessageFormatDialect, MessageValues, PortableObject, TaggedMessageToken, i18nextToIntlayerFormatter, icuToIntlayerFormatter, interpolateMessage, intlayerToI18nextFormatter, intlayerToICUFormatter, intlayerToPortableObjectFormatter, intlayerToVueI18nFormatter, navigatePath, parseTaggedMessage, portableObjectToIntlayerFormatter, resolveMessage, resolveMessageNode, vueI18nToIntlayerFormatter };

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

@@ -0,0 +1,22 @@
+//#region src/messageFormat/navigatePath.d.ts
+/**
+ * Reads a dotted `path` (e.g. `counter.label`) out of a nested content value.
+ *
+ * The full path is first tried as a *flat* property, supporting catalogs that
+ * use dotted keys as literal field names (i18next flat JSON files, lingui
+ * catalogs: `{ "section.title": "value" }`). When that misses, the path is
+ * split on `keySeparator` and walked segment by segment.
+ *
+ * Shared by every compat adapter's translation lookup — do not re-implement
+ * it locally.
+ *
+ * @param contentValue - The object (dictionary content) to read from.
+ * @param path - Separator-delimited path. An empty path returns `contentValue`.
+ * @param keySeparator - Segment separator; `false` disables nested traversal
+ *   (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;
+//#endregion
+export { navigatePath };
+//# sourceMappingURL=navigatePath.d.ts.map

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

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

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

@@ -1,6 +1,5 @@
 import { JsonValue } from "./ICU.js";
 import { Dictionary } from "@intlayer/types/dictionary";
-
 //#region src/messageFormat/po.d.ts
 type PortableObject = {
   msgid: string;
@@ -8,8 +7,8 @@ type PortableObject = {
   msgid_plural?: string;
   msgstr: string[];
 };
-declare const intlayerToPortableObjectFormatter: (dictionary: Dictionary["content"]) => JsonValue;
-declare const portableObjectToIntlayerFormatter: (message: JsonValue) => Dictionary["content"];
+declare const intlayerToPortableObjectFormatter: (dictionary: Dictionary['content']) => JsonValue;
+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,cAAA;EACV,KAAA;EACA,OAAA;EACA,YAAA;EACA,MAAA;AAAA;AAAA,cAgPW,iCAAA,GACX,UAAA,EAAY,UAAA,gBACX,SAAA;AAAA,cAQU,iCAAA,GACX,OAAA,EAAS,SAAA,KACR,UAAA"}
+{"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"}

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

@@ -1,5 +1,4 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-
 //#region src/messageFormat/resolveMessage.d.ts
 /**
  * Runtime counterpart of the `messageFormat` converters.

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

@@ -1 +1 @@
-{"version":3,"file":"resolveMessage.d.ts","names":[],"sources":["../../../src/messageFormat/resolveMessage.ts"],"mappings":";;;;;AAwBA;;;;;AAGA;;;;;AAsFA;AAAA,KAzFY,oBAAA;;KAGA,aAAA,GAAgB,MAAA;;;;;;;;AA2H5B;cArCa,kBAAA,GACX,QAAA,UACA,MAAA,GAAQ,aAAA,EACR,MAAA,GAAQ,aAAA;;;;;;;;;cAkCG,kBAAA,GACX,IAAA,WACA,MAAA,GAAQ,aAAA,EACR,MAAA,GAAQ,aAAA;AA6IV;;;;;;;;;;;;;;;;;AAiBA;AAjBA,cAAa,cAAA,GACX,OAAA,WACA,MAAA,GAAQ,aAAA,EACR,MAAA,GAAQ,aAAA,EACR,OAAA,GAAS,oBAAA;;KAaC,kBAAA;EAEN,GAAA;EAAa,QAAA,EAAU,kBAAA;AAAA;;;AAS7B;;;;;cAAa,kBAAA,GAAsB,OAAA,aAAkB,kBAAA"}
+{"version":3,"file":"resolveMessage.d.ts","names":[],"sources":["../../../src/messageFormat/resolveMessage.ts"],"mappings":";;;;;;;;;;;;;;;KAwBY;;KAGA,gBAAgB;;;;;;;;;cAsFf,qBAAkB,kBACb,SACR,eAAa,SACb;;;;;;;;;cAkCG,qBAAkB,eAChB,SACL,eAAa,SACb;;;;;;;;;;;;;;;;;;;cA6IG,iBAAc,kBACT,SACR,eAAa,SACb,eAAa,UACZ;;KAaC;EAEN;EAAa,UAAU;;;;;;;;;cAShB,qBAAkB,oBAAsB"}

package/dist/types/messageFormat/verify-icu-format.d.ts

@@ -1 +1 @@
-export { };
+export {}

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

@@ -1,9 +1,8 @@
 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"];
+declare const intlayerToVueI18nFormatter: (message: Dictionary['content']) => JsonValue;
+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":";;;;cAoUa,0BAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA;AAAA,cAQU,0BAAA,GACX,OAAA,EAAS,SAAA,KACR,UAAA"}
+{"version":3,"file":"vue-i18n.d.ts","names":[],"sources":["../../../src/messageFormat/vue-i18n.ts"],"mappings":";;;cAoUa,6BAA0B,SAC5B,0BACR;cAQU,6BAA0B,SAC5B,cACR"}

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

@@ -1,5 +1,4 @@
 import { CONDITION, TypedNodeModel } from "@intlayer/types/nodeType";
-
 //#region src/transpiler/condition/condition.d.ts
 type ConditionContentStates<Content> = Record<`${boolean}`, Content> & {
   fallback?: Content;

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,sBAAA,YAAkC,MAAA,eAAqB,OAAA;EACjE,QAAA,GAAW,OAAA;AAAA;AAAA,KAGD,gBAAA,sBAAsC,cAAA,QACzC,SAAA,EACP,sBAAA,CAAuB,OAAA;;;;;;;;;;;;;AAFzB;;;;;cAsBM,SAAA,YACJ,OAAA,GAAU,sBAAA,CAAuB,OAAA,MAChC,gBAAA,CAAiB,OAAA"}
+{"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"}

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

@@ -1,5 +1,4 @@
 import { ENUMERATION, TypedNodeModel } from "@intlayer/types/nodeType";
-
 //#region src/transpiler/enumeration/enumeration.d.ts
 type Positive = number | `${number}`;
 type Negative = `-${number}`;

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,QAAA;AAAA,KACA,QAAA;AAAA,KACA,OAAA,GAAU,QAAA,GAAW,QAAA;AAAA,KAErB,KAAA,GAAQ,OAAA;AAAA,KACR,WAAA,OAAkB,OAAA;AAAA,KAClB,QAAA,OAAe,OAAA;AAAA,KACf,eAAA,QAAuB,OAAA;AAAA,KACvB,QAAA,OAAe,OAAA;AAAA,KACf,eAAA,QAAuB,OAAA;AAAA,KAEhB,WAAA,GACR,KAAA,GACA,WAAA,GACA,QAAA,GACA,eAAA,GACA,QAAA,GACA,eAAA;AAAA,KAEQ,uBAAA,YAAmC,OAAA,CAC7C,MAAA,CAAO,WAAA,EAAa,OAAA;EAEpB,QAAA,GAAW,OAAA;AAAA;AAAA,KAGD,kBAAA,sBAAwC,cAAA,QAC3C,WAAA,EACP,uBAAA,CAAwB,OAAA;;;AAzBQ;;;;;AAEd;;;;;AACU;;;;;AACH;;cA2CrB,WAAA,sBACJ,OAAA,GAAU,uBAAA,CAAwB,OAAA,MACjC,kBAAA,CAAmB,OAAA"}
+{"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"}

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

@@ -1,5 +1,4 @@
 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<{

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,sBAAA,WAAiC,MAAA,sBAC3C,cAAA,QAAsB,IAAA,UAAc,CAAA;AAAA,KAE1B,WAAA,GAAc,sBAAA;EACxB,OAAA;EACA,SAAA;AAAA;AAAA,cAGW,WAAA,GACX,IAAA,UACA,SAAA,UACA,OAAA,aACC,WAAA;;;;;;;;;;;;AATH;;;;cAkEa,IAAA,GAAQ,IAAA,aAAe,WAAA"}
+{"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"}

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

@@ -1,5 +1,4 @@
 import { FileContent } from "./file.js";
-
 //#region src/transpiler/file/fileBrowser.d.ts
 /**
  * Function intended to be used to build intlayer dictionaries.

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":";;;;;AAiBA;;;;;;;;;;;;;cAAa,IAAA,GAAQ,KAAA,aAAgB,WAAA"}
+{"version":3,"file":"fileBrowser.d.ts","names":[],"sources":["../../../../src/transpiler/file/fileBrowser.ts"],"mappings":";;;;;;;;;;;;;;;;;cAiBa,OAAI,kBAAoB"}

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

@@ -1,5 +1,4 @@
 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> & {

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,MAAA;AAAA,KAEA,mBAAA,YAA+B,MAAA,IAAU,MAAA,IAAU,OAAA;EAC7D,QAAA,GAAW,OAAA;AAAA;AAAA,KAGD,aAAA,sBAAmC,cAAA,QACtC,MAAA,EACP,mBAAA,CAAoB,OAAA;;AANtB;;;;;;;;;;;;;;;;cA0BM,MAAA,YACJ,OAAA,GAAU,mBAAA,CAAoB,OAAA,MAC7B,aAAA,CAAc,OAAA"}
+{"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"}

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":";;AA2BA;;;;cAAa,uBAAA,GACX,OAAA,aACC,MAAA,SAAe,MAAA"}
+{"version":3,"file":"getHTMLCustomComponents.d.ts","names":[],"sources":["../../../../src/transpiler/html/getHTMLCustomComponents.ts"],"mappings":";;;;;;cA2Ba,0BAAuB,oBAEjC,eAAe"}

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

@@ -1,5 +1,4 @@
 import { HTML, TypedNodeModel } from "@intlayer/types/nodeType";
-
 //#region src/transpiler/html/html.d.ts
 type PropsType = 'number' | 'string' | 'node';
 type ComponentName = string;

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,SAAA;AAAA,KAEA,aAAA;AAAA,KAEO,sBAAA,8BAEA,MAAA,sBACR,cAAA,QAAsB,IAAA,EAAM,OAAA,EAAS,CAAA;AAAA,KAE7B,WAAA,uCAES,MAAA,CAAO,aAAA,EAAe,SAAA,IAAa,MAAA,CACpD,aAAA,EACA,SAAA,KAEA,sBAAA,CACF,OAAA;EAEE,IAAA,aAAiB,UAAA;AAAA;AAlBP;;;;;AAId;;;;;;;AAJc,cAkCD,IAAA,sBACQ,MAAA,gBAAsB,MAAA,kCAGzC,OAAA,EAAS,OAAA,EACT,UAAA,GAAa,UAAA,KACZ,WAAA,CAAY,OAAA,EAAS,UAAA"}
+{"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"}

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

@@ -7,7 +7,7 @@
  * 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"];
+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 = {
   html: HTMLHtmlElement;
   head: HTMLHeadElement;

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":"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"}
+{"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"}

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,kBAAA,EAAkB,GAAA;AAAA,KAgBnB,mBAAA;EACV,IAAA;EACA,OAAA;AAAA;AAAA,KAGU,oBAAA;EACV,KAAA;EACA,MAAA,EAAQ,mBAAA;AAAA;;;AAFV;;;;;cAmBa,YAAA,GAAgB,OAAA,aAAkB,oBAAA"}
+{"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"}

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

@@ -1,16 +1,26 @@
 import { ConditionContent, ConditionContentStates, cond as condition } from "./condition/condition.js";
+import "./condition/index.js";
 import { EnterFormat, EnumerationContent, EnumerationContentState, enu as enumeration } from "./enumeration/enumeration.js";
+import "./enumeration/index.js";
 import { FileContent, FileContentConstructor, file, fileContent } from "./file/file.js";
+import "./file/index.js";
 import { Gender, GenderContent, GenderContentStates, gender } from "./gender/gender.js";
+import "./gender/index.js";
 import { HTMLContent, HTMLContentConstructor, html } from "./html/html.js";
 import { HTMLTagsType, HTML_TAGS } from "./html/htmlTags.js";
 import { HTMLValidationIssue, HTMLValidationResult, VOID_HTML_ELEMENTS, validateHTML } from "./html/validateHTML.js";
+import "./html/index.js";
 import { getInsertionValues } from "./insertion/getInsertionValues.js";
 import { InsertionContent, InsertionContentConstructor, insert as insertion } from "./insertion/insertion.js";
+import "./insertion/index.js";
 import { getMarkdownMetadata } from "./markdown/getMarkdownMetadata.js";
 import { MarkdownContent, MarkdownContentConstructor, md as markdown } from "./markdown/markdown.js";
 import { MarkdownValidationResult, validateMarkdown } from "./markdown/validateMarkdown.js";
+import "./markdown/index.js";
 import { DotPath, NestedContent, NestedContentState, ValidDotPathsFor, nest as nesting } from "./nesting/nesting.js";
+import "./nesting/index.js";
 import { PluralCategory, PluralContent, PluralContentState, plural } from "./plural/plural.js";
+import "./plural/index.js";
 import { TranslationContent, t as translation } from "./translation/translation.js";
-export { ConditionContent, ConditionContentStates, DotPath, EnterFormat, EnumerationContent, EnumerationContentState, FileContent, FileContentConstructor, Gender, GenderContent, GenderContentStates, HTMLContent, HTMLContentConstructor, HTMLTagsType, HTMLValidationIssue, HTMLValidationResult, HTML_TAGS, InsertionContent, InsertionContentConstructor, MarkdownContent, MarkdownContentConstructor, HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, NestedContent, NestedContentState, PluralCategory, PluralContent, PluralContentState, TranslationContent, VOID_HTML_ELEMENTS, ValidDotPathsFor, condition as cond, enumeration as enu, file, fileContent, gender, getInsertionValues, getMarkdownMetadata, html, insertion as insert, markdown as md, nesting as nest, plural, translation as t, validateHTML, validateMarkdown };
+import "./translation/index.js";
+export { ConditionContent, ConditionContentStates, DotPath, EnterFormat, EnumerationContent, EnumerationContentState, type FileContent, type FileContentConstructor, Gender, GenderContent, GenderContentStates, HTMLContent, HTMLContentConstructor, HTMLTagsType, HTMLValidationIssue, HTMLValidationResult, HTML_TAGS, InsertionContent, InsertionContentConstructor, MarkdownContent, MarkdownContentConstructor, type HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, NestedContent, NestedContentState, PluralCategory, PluralContent, PluralContentState, TranslationContent, VOID_HTML_ELEMENTS, ValidDotPathsFor, condition as cond, enumeration as enu, type file, type fileContent, gender, getInsertionValues, getMarkdownMetadata, html, insertion as insert, markdown as md, nesting as nest, plural, translation as t, validateHTML, validateMarkdown };

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,kBAAA,GAAsB,OAAA"}
+{"version":3,"file":"getInsertionValues.d.ts","names":[],"sources":["../../../../src/transpiler/insertion/getInsertionValues.ts"],"mappings":";cAAa,qBAAkB"}

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

@@ -1,5 +1,4 @@
 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, {

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,2BAAA,8BAEA,MAAA,sBACR,cAAA,QAAsB,SAAA,EAAW,OAAA,EAAS,CAAA;AAAA,KAElC,gBAAA,sBAAsC,2BAAA,CAChD,OAAA;EAEE,MAAA;AAAA;;;;;;;;;;;;;cAgBE,SAAA,sBACJ,OAAA,EAAS,OAAA,KACR,gBAAA,CAAiB,OAAA"}
+{"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"}

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,mBAAA,aAAiC,MAAA,eAC5C,QAAA,aACC,CAAA"}
+{"version":3,"file":"getMarkdownMetadata.d.ts","names":[],"sources":["../../../../src/transpiler/markdown/getMarkdownMetadata.ts"],"mappings":";cAEa,sBAAuB,UAAU,qBAAmB,qBAE9D"}

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

@@ -2,4 +2,4 @@ import { HTMLValidationIssue } from "../html/validateHTML.js";
 import { getMarkdownMetadata } from "./getMarkdownMetadata.js";
 import { MarkdownContent, MarkdownContentConstructor, md as markdown } from "./markdown.js";
 import { MarkdownValidationResult, validateMarkdown } from "./validateMarkdown.js";
-export { MarkdownContent, MarkdownContentConstructor, HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, getMarkdownMetadata, markdown as md, validateMarkdown };
+export { MarkdownContent, MarkdownContentConstructor, type HTMLValidationIssue as MarkdownValidationIssue, MarkdownValidationResult, getMarkdownMetadata, markdown as md, validateMarkdown };

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

@@ -1,5 +1,4 @@
 import { MARKDOWN, TypedNodeModel } from "@intlayer/types/nodeType";
-
 //#region src/transpiler/markdown/markdown.d.ts
 type PropsType = 'number' | 'string' | 'node';
 type ComponentName = string;

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,SAAA;AAAA,KAEA,aAAA;AAAA,KAEO,0BAAA,WACA,MAAA,yCAER,cAAA,QAAsB,QAAA,EAAU,OAAA,EAAS,CAAA;AAAA,KAEjC,eAAA,uCAES,MAAA,CAAO,aAAA,EAAe,SAAA,IAAa,MAAA,CACpD,aAAA,EACA,SAAA,KAEA,0BAAA;EAEA,QAAA,GAAW,MAAA;EACX,IAAA,cAAkB,UAAA;AAAA,GAEpB,OAAA;;;;;AAhBF;;;;;;;;cA4CM,QAAA,sBACe,MAAA,gBAAsB,MAAA,kCAGzC,OAAA,EAAS,OAAA,EACT,UAAA,GAAa,UAAA,KACZ,eAAA,CAAgB,OAAA,EAAS,UAAA"}
+{"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"}