@intlayer/core 8.4.4 → 8.4.5

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

@@ -1,2 +1,16 @@
-import { t as parserFor } from "../parser-BVwR6Tjw.js";
-export { parserFor };
+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
+ * specified as a list of rules.
+ *
+ * @param rules - An object containing rule type -> {match, order, parse} objects
+ *                (lower order is higher precedence)
+ *
+ * @returns The resulting parse function
+ */
+declare const parserFor: (rules: Rules) => ((source: string, state: ParseState) => ParserResult[]);
+//#endregion
+export { parserFor };
+//# sourceMappingURL=parser.d.ts.map

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

@@ -0,0 +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"}

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

@@ -1,2 +1,22 @@
-import { n as renderFor, t as createRenderer } from "../renderer-C06x2Orf.js";
-export { createRenderer, renderFor };
+import { ParseState, ParserResult, RenderRuleHook, RuleOutput, Rules } from "./types.js";
+
+//#region src/markdown/renderer.d.ts
+/**
+ * Creates a renderer for AST nodes.
+ * Renamed from `reactFor` to be framework-agnostic.
+ *
+ * @param render - The render function to call for each node
+ * @returns A function that renders AST to output
+ */
+declare const renderFor: (render: (ast: ParserResult, render: RuleOutput, state: ParseState) => unknown) => (ast: ParserResult | ParserResult[], state?: ParseState) => any;
+/**
+ * Creates a renderer from rules with optional custom render hook.
+ *
+ * @param rules - The rules object containing _render functions
+ * @param userRender - Optional custom render hook for full control
+ * @returns A render function for AST nodes
+ */
+declare const createRenderer: (rules: Rules, userRender?: RenderRuleHook) => (ast: ParserResult, render: RuleOutput, state: ParseState) => unknown;
+//#endregion
+export { createRenderer, renderFor };
+//# sourceMappingURL=renderer.d.ts.map

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

@@ -0,0 +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"}

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

@@ -1,2 +1,333 @@
-import { A as MarkedTextNode, B as ReferenceNode, C as ItalicTextNode, D as MarkdownContext, E as LinkNode, F as ParseState, G as StrikethroughTextNode, H as Rule, I as Parser, J as TextNode, K as TableNode, L as ParserResult, M as NewlineNode, N as OrderedListNode, O as MarkdownOptions, P as ParagraphNode, R as ReferenceImageNode, S as ImageNode, T as LinkBareURLNode, U as RuleOutput, V as RenderRuleHook, W as Rules, Y as UnorderedListNode, _ as HTMLNode, a as CodeBlockNode, b as HeadingNode, c as CompileOptions, d as ElementType, f as EscapedTextNode, g as HTMLCommentNode, h as GFMTaskNode, i as BreakThematicNode, j as NestedParser, k as MarkdownRuntime, l as ComponentOverrides, m as FootnoteReferenceNode, n as BoldTextNode, o as CodeFencedNode, p as FootnoteNode, q as TableSeparatorNode, r as BreakLineNode, s as CodeInlineNode, t as BlockQuoteNode, u as CustomComponentNode, v as HTMLSelfClosingNode, w as LinkAngleBraceNode, x as HeadingSetextNode, y as HTMLTag, z as ReferenceLinkNode } from "../types-C2Om0aEM.js";
-export { 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 };
+//#region src/markdown/types.d.ts
+/**
+ * Permissive element type - core doesn't care what frameworks accept.
+ * Can be a string tag ('div', 'span') or any component (function, object, class)
+ */
+type ElementType = string | any;
+/**
+ * Simple HTML tag type - no need to enumerate all tags
+ */
+type HTMLTag = string;
+/**
+ * Runtime interface that framework adapters must implement.
+ * This allows the markdown compiler to work with any framework.
+ */
+type MarkdownRuntime = {
+  /**
+   * Create an element. Signature matches common UI runtimes.
+   * @param type - Tag name or component
+   * @param props - Element properties
+   * @param children - Child elements
+   */
+  createElement: (type: ElementType, props: Record<string, any> | null, ...children: any[]) => unknown;
+  /**
+   * Fragment component for grouping without wrapper DOM node.
+   * Optional - falls back to array if not provided.
+   */
+  Fragment?: any;
+  /**
+   * Normalize props for runtime differences.
+   * Called before createElement with (tag, props).
+   *
+   * Examples:
+   * - { className } -> { className } (no change needed)
+   * - { className } -> { class }
+   * - { htmlFor } -> { for }
+   */
+  normalizeProps?: (tag: HTMLTag, props: Record<string, any>) => Record<string, any>;
+  /**
+   * Adapter-specific helpers can be exposed without coupling core.
+   */
+  [key: string]: unknown;
+};
+/**
+ * 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 */
+  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 */
+  simple?: boolean;
+};
+type BlockQuoteNode = {
+  type: string;
+  alert?: string;
+  children: ParserResult[];
+};
+type BreakLineNode = {
+  type: string;
+};
+type BreakThematicNode = {
+  type: string;
+};
+type CodeBlockNode = {
+  type: string;
+  attrs?: Record<string, any>;
+  lang?: string;
+  text: string;
+};
+type CodeFencedNode = {
+  type: string;
+};
+type CodeInlineNode = {
+  type: string;
+  text: string;
+};
+type FootnoteNode = {
+  type: string;
+};
+type FootnoteReferenceNode = {
+  type: string;
+  target: string;
+  text: string;
+};
+type GFMTaskNode = {
+  type: string;
+  completed: boolean;
+};
+type HeadingNode = {
+  type: string;
+  children: ParserResult[];
+  id: string;
+  level: 1 | 2 | 3 | 4 | 5 | 6;
+};
+type HeadingSetextNode = {
+  type: string;
+};
+type HTMLCommentNode = {
+  type: string;
+};
+type ImageNode = {
+  type: string;
+  alt?: string;
+  target: string;
+  title?: string;
+};
+type LinkNode = {
+  type: string;
+  children: ParserResult[];
+  target: string;
+  title?: string;
+};
+type LinkAngleBraceNode = {
+  type: string;
+};
+type LinkBareURLNode = {
+  type: string;
+};
+type OrderedListNode = {
+  type: string;
+  items: ParserResult[][];
+  ordered: true;
+  start?: number;
+};
+type UnorderedListNode = {
+  type: string;
+  items: ParserResult[][];
+  ordered: false;
+};
+type NewlineNode = {
+  type: string;
+};
+type ParagraphNode = {
+  type: string;
+  children: ParserResult[];
+};
+type ReferenceNode = {
+  type: string;
+};
+type ReferenceImageNode = {
+  type: string;
+  alt?: string;
+  ref: string;
+};
+type ReferenceLinkNode = {
+  type: string;
+  children: ParserResult[];
+  fallbackChildren: string;
+  ref: string;
+};
+type TableNode = {
+  type: string;
+  align: ('left' | 'right' | 'center')[];
+  cells: ParserResult[][][];
+  header: ParserResult[][];
+};
+type TableSeparatorNode = {
+  type: string;
+};
+type TextNode = {
+  type: string;
+  text: string;
+};
+type BoldTextNode = {
+  type: string;
+  children: ParserResult[];
+};
+type ItalicTextNode = {
+  type: string;
+  children: ParserResult[];
+};
+type EscapedTextNode = {
+  type: string;
+};
+type MarkedTextNode = {
+  type: string;
+  children: ParserResult[];
+};
+type StrikethroughTextNode = {
+  type: string;
+  children: ParserResult[];
+};
+type HTMLNode = {
+  type: string;
+  attrs: Record<string, any> | null;
+  children?: ParserResult[];
+  noInnerParse: boolean;
+  tag: HTMLTag;
+  text?: string;
+};
+type HTMLSelfClosingNode = {
+  type: string;
+  attrs: Record<string, any> | null;
+  tag: string;
+};
+type CustomComponentNode = {
+  type: string;
+  attrs: Record<string, any> | null;
+  children?: ParserResult[];
+  noInnerParse: boolean;
+  tag: string;
+  text?: string;
+};
+/**
+ * Union of all possible parser result node types.
+ */
+type ParserResult = BlockQuoteNode | BreakLineNode | BreakThematicNode | CodeBlockNode | CodeFencedNode | CodeInlineNode | CustomComponentNode | FootnoteNode | FootnoteReferenceNode | GFMTaskNode | HeadingNode | HeadingSetextNode | HTMLCommentNode | ImageNode | LinkNode | LinkAngleBraceNode | LinkBareURLNode | OrderedListNode | UnorderedListNode | NewlineNode | ParagraphNode | ReferenceNode | ReferenceImageNode | ReferenceLinkNode | TableNode | TableSeparatorNode | TextNode | BoldTextNode | ItalicTextNode | EscapedTextNode | MarkedTextNode | StrikethroughTextNode | HTMLNode | HTMLSelfClosingNode;
+/**
+ * Nested parser function type.
+ */
+type NestedParser = (input: string, state: ParseState) => ParserResult[];
+/**
+ * Parser function type for a rule.
+ */
+type Parser<ParserOutput> = (capture: RegExpMatchArray, nestedParse: NestedParser, state: ParseState) => ParserOutput;
+/**
+ * Output function type for rendering.
+ */
+type RuleOutput = (ast: ParserResult | ParserResult[], state: ParseState) => unknown;
+/**
+ * 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 */
+  _parse: Parser<Omit<ParserOutput, 'type'>>;
+  /**
+   * Optional fast check that can quickly determine if this rule
+   * should even be attempted.
+   */
+  _qualify?: string[] | ((source: string, state: ParseState) => boolean);
+  /**
+   * Render function - converts AST node to output.
+   * Uses context's runtime.createElement for element creation.
+   */
+  _render?: (node: ParserOutput, render: RuleOutput, state: ParseState) => unknown;
+};
+/**
+ * Map of all rules keyed by rule type.
+ */
+type Rules = {
+  [key: string]: Rule<any>;
+};
+/**
+ * Map of tag overrides.
+ */
+type ComponentOverrides<T> = {
+  [tag: string]: 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 */
+
+state: ParseState) => unknown;
+/**
+ * Options for the markdown compiler.
+ * This is the framework-agnostic version of MarkdownRendererOptions.
+ */
+type MarkdownOptions = {
+  /**
+   * Disable automatic link detection for bare URLs.
+   */
+  disableAutoLink?: boolean;
+  /**
+   * Disable parsing of raw HTML in markdown.
+   */
+  disableParsingRawHTML?: boolean;
+  /**
+   * Force ATX-compliant headings (require space after #).
+   */
+  enforceAtxHeadings?: boolean;
+  /**
+   * Force block-level output.
+   */
+  forceBlock?: boolean;
+  /**
+   * Force inline output.
+   */
+  forceInline?: boolean;
+  /**
+   * Force wrapper element even for single children.
+   */
+  forceWrapper?: boolean;
+  /**
+   * Custom render rule hook for full control over rendering.
+   */
+  renderRule?: RenderRuleHook;
+  /**
+   * Wrapper element type, or null for no wrapper.
+   */
+  wrapper?: HTMLTag | null;
+  /**
+   * Whether to preserve frontmatter.
+   */
+  preserveFrontmatter?: boolean;
+  /**
+   * Whether to use tag filter.
+   */
+  tagfilter?: boolean;
+};
+/**
+ * Combined options including context and compiler options.
+ * 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 */
+  slugify?: (input: string, defaultFn: (input: string) => string) => string;
+};
+//#endregion
+export { 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 };
+//# sourceMappingURL=types.d.ts.map

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

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

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

@@ -1,2 +1,140 @@
-import { A as unquote, C as simpleInlineRegex, D as trimEnd, E as startsWith, O as trimLeadingWhitespaceOutsideFences, S as sanitizer, T as some, _ as parseTableAlignCapture, a as captureNothing, b as qualifies, c as inlineRegex, d as parseBlock, f as parseCaptureInline, g as parseTableAlign, h as parseStyleAttribute, i as blockRegex, k as unescapeString, l as normalizeAttributeKey, m as parseSimpleInline, n as anyScopeRegex, o as cx, p as parseInline, r as attributeValueToNodePropValue, s as get, t as allowInline, u as normalizeWhitespace, v as parseTableCells, w as slugify, x as renderNothing, y as parseTableRow } from "../utils-Dcmgh_80.js";
-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 };
+import { NestedParser, ParseState, ParserResult, Rule } from "./types.js";
+
+//#region src/markdown/utils.d.ts
+/**
+ * Trim trailing whitespace from a string.
+ */
+declare const trimEnd: (str: string) => string;
+/**
+ * Check if string starts with prefix.
+ */
+declare const startsWith: (str: string, prefix: string) => boolean;
+/**
+ * Remove symmetrical leading and trailing quotes.
+ */
+declare const unquote: (str: string) => string;
+/**
+ * Unescape backslash-escaped characters.
+ */
+declare const unescapeString: (rawString: string) => string;
+/**
+ * Join class names, filtering out falsy values.
+ */
+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;
+/**
+ * Convert a string to a URL-safe slug.
+ * Based on https://stackoverflow.com/a/18123682/1141611
+ */
+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;
+/**
+ * Normalize whitespace in source string.
+ */
+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 ~~~).
+ */
+declare const trimLeadingWhitespaceOutsideFences: (text: string, whitespace: string) => string;
+/**
+ * Normalize HTML attribute key to JSX prop name.
+ */
+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[];
+/**
+ * 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;
+/**
+ * Parse table alignment from a separator row.
+ */
+declare const parseTableAlignCapture: (alignCapture: string) => "left" | "right" | "center";
+/**
+ * Parse table alignment row.
+ */
+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[][];
+/**
+ * Parse table cells (multiple rows).
+ */
+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;
+/**
+ * Marks a matcher function as eligible for being run inside an inline context.
+ */
+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) & {
+  inline: 1;
+};
+/**
+ * Creates a match function for inline elements except links.
+ */
+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;
+/**
+ * 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) & {
+  inline: 1;
+};
+/**
+ * Parse inline content (including links).
+ */
+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[];
+/**
+ * Parse block content.
+ */
+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) => {
+  children: ParserResult[];
+};
+/**
+ * Helper that captures nothing (empty object).
+ */
+declare const captureNothing: () => Record<string, never>;
+/**
+ * Helper that renders nothing (null).
+ */
+declare const renderNothing: () => null;
+/**
+ * Check if any regex in a list matches the input.
+ */
+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

@@ -0,0 +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;;;;cA4DW,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"}

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

@@ -1,2 +1,11 @@
-import { n as icuToIntlayerFormatter, r as intlayerToICUFormatter, t as JsonValue } from "../ICU-tA3ZHN5U.js";
-export { JsonValue, icuToIntlayerFormatter, intlayerToICUFormatter };
+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;
+//#endregion
+export { JsonValue, icuToIntlayerFormatter, intlayerToICUFormatter };
+//# sourceMappingURL=ICU.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ICU.d.ts","names":[],"sources":["../../../src/messageFormat/ICU.ts"],"mappings":";;;KA6CY,SAAA,sCAKR,SAAA;EAAA,CACG,GAAA,WAAc,SAAA;AAAA;AAAA,cAyeR,sBAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA;AAAA,cAQU,sBAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA"}

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

@@ -1,2 +1,9 @@
-import { n as intlayerToI18nextFormatter, t as i18nextToIntlayerFormatter } from "../i18next-qY0AixrB.js";
-export { i18nextToIntlayerFormatter, intlayerToI18nextFormatter };
+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"];
+//#endregion
+export { i18nextToIntlayerFormatter, intlayerToI18nextFormatter };
+//# sourceMappingURL=i18next.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"i18next.d.ts","names":[],"sources":["../../../src/messageFormat/i18next.ts"],"mappings":";;;;cAqfa,0BAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA;AAAA,cAQU,0BAAA,GACX,OAAA,EAAS,SAAA,KACR,UAAA"}

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

@@ -1,4 +1,4 @@
-import { n as icuToIntlayerFormatter, r as intlayerToICUFormatter, t as JsonValue } from "../ICU-tA3ZHN5U.js";
-import { n as intlayerToI18nextFormatter, t as i18nextToIntlayerFormatter } from "../i18next-qY0AixrB.js";
-import { n as vueI18nToIntlayerFormatter, t as intlayerToVueI18nFormatter } from "../vue-i18n-JtUB7N_m.js";
+import { JsonValue, icuToIntlayerFormatter, intlayerToICUFormatter } from "./ICU.js";
+import { i18nextToIntlayerFormatter, intlayerToI18nextFormatter } from "./i18next.js";
+import { intlayerToVueI18nFormatter, vueI18nToIntlayerFormatter } from "./vue-i18n.js";
 export { JsonValue, i18nextToIntlayerFormatter, icuToIntlayerFormatter, intlayerToI18nextFormatter, intlayerToICUFormatter, intlayerToVueI18nFormatter, vueI18nToIntlayerFormatter };

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

@@ -1,2 +1,9 @@
-import { n as vueI18nToIntlayerFormatter, t as intlayerToVueI18nFormatter } from "../vue-i18n-JtUB7N_m.js";
-export { intlayerToVueI18nFormatter, vueI18nToIntlayerFormatter };
+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"];
+//#endregion
+export { intlayerToVueI18nFormatter, vueI18nToIntlayerFormatter };
+//# sourceMappingURL=vue-i18n.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vue-i18n.d.ts","names":[],"sources":["../../../src/messageFormat/vue-i18n.ts"],"mappings":";;;;cA2Ra,0BAAA,GACX,OAAA,EAAS,UAAA,gBACR,SAAA;AAAA,cAQU,0BAAA,GACX,OAAA,EAAS,SAAA,KACR,UAAA"}

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

@@ -1,2 +1,28 @@
-import { n as ConditionContentStates, r as condition, t as ConditionContent } from "../../condition-BDUtoh_1.js";
-export { ConditionContent, ConditionContentStates, condition as cond };
+import { CONDITION, TypedNodeModel } from "@intlayer/types/nodeType";
+
+//#region src/transpiler/condition/condition.d.ts
+type ConditionContentStates<Content> = Record<`${boolean}`, Content> & {
+  fallback?: Content;
+};
+type ConditionContent<Content = unknown> = TypedNodeModel<typeof CONDITION, ConditionContentStates<Content>>;
+/**
+ * Function intended to be used to build intlayer dictionaries.
+ *
+ * Allow to pick a content based on a condition.
+ *
+ * Usage:
+ *
+ * ```ts
+ * cond({
+ *  'true': 'The condition is validated',
+ *  'false': 'The condition is not validated',
+ * });
+ * ```
+ *
+ * The last key provided will be used as the fallback value.
+ *
+ */
+declare const condition: <Content>(content?: ConditionContentStates<Content>) => TypedNodeModel<"condition", ConditionContentStates<Content>, {}>;
+//#endregion
+export { ConditionContent, ConditionContentStates, condition as cond };
+//# sourceMappingURL=condition.d.ts.map

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

@@ -0,0 +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,YAAsB,OAAA,GAAU,sBAAA,CAAuB,OAAA,MAAQ,cAAA,cAAA,sBAAA,CAAA,OAAA"}

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

@@ -1,2 +1,2 @@
-import { n as ConditionContentStates, r as condition, t as ConditionContent } from "../../condition-BDUtoh_1.js";
+import { ConditionContent, ConditionContentStates, cond as condition } from "./condition.js";
 export { ConditionContent, ConditionContentStates, condition as cond };