@intlayer/core 9.4.3 → 9.5.0

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

@@ -1,18 +1,19 @@
+import { RuleScopeValue } from "./constants.js";
 //#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;
+export type ElementType = string | any;
 /**
  * Simple HTML tag type - no need to enumerate all tags
  */
-type HTMLTag = string;
+export type HTMLTag = string;
 /**
  * Runtime interface that framework adapters must implement.
  * This allows the markdown compiler to work with any framework.
  */
-type MarkdownRuntime = {
+export type MarkdownRuntime = {
   /**
    * Create an element. Signature matches common UI runtimes.
    * @param type - Tag name or component
@@ -43,7 +44,7 @@ type MarkdownRuntime = {
 /**
  * Context passed to the compiler containing runtime and configuration.
  */
-type MarkdownContext<T> = {
+export type MarkdownContext<T> = {
   /** Framework runtime (createElement, etc.) */
   runtime: MarkdownRuntime;
   /** Component components for HTML tags */
@@ -58,7 +59,7 @@ type MarkdownContext<T> = {
 /**
  * Parser state passed through parsing and rendering.
  */
-type ParseState = {
+export type ParseState = {
   /** true if the current content is inside anchor link grammar */
   inAnchor?: boolean;
   /** true if parsing in an HTML context */
@@ -82,137 +83,137 @@ type ParseState = {
   /** true if parsing in inline context w/o links */
   simple?: boolean;
 };
-type BlockQuoteNode = {
+export type BlockQuoteNode = {
   type: string;
   alert?: string;
   children: ParserResult[];
 };
-type BreakLineNode = {
+export type BreakLineNode = {
   type: string;
 };
-type BreakThematicNode = {
+export type BreakThematicNode = {
   type: string;
 };
-type CodeBlockNode = {
+export type CodeBlockNode = {
   type: string;
   attrs?: Record<string, any>;
   lang?: string;
   text: string;
 };
-type CodeFencedNode = {
+export type CodeFencedNode = {
   type: string;
 };
-type CodeInlineNode = {
+export type CodeInlineNode = {
   type: string;
   text: string;
 };
-type FootnoteNode = {
+export type FootnoteNode = {
   type: string;
 };
-type FootnoteReferenceNode = {
+export type FootnoteReferenceNode = {
   type: string;
   target: string;
   text: string;
 };
-type GFMTaskNode = {
+export type GFMTaskNode = {
   type: string;
   completed: boolean;
 };
-type HeadingNode = {
+export type HeadingNode = {
   type: string;
   children: ParserResult[];
   id: string;
   level: 1 | 2 | 3 | 4 | 5 | 6;
 };
-type HeadingSetextNode = {
+export type HeadingSetextNode = {
   type: string;
 };
-type HTMLCommentNode = {
+export type HTMLCommentNode = {
   type: string;
 };
-type ImageNode = {
+export type ImageNode = {
   type: string;
   alt?: string;
   target: string;
   title?: string;
 };
-type LinkNode = {
+export type LinkNode = {
   type: string;
   children: ParserResult[];
   target: string;
   title?: string;
 };
-type LinkAngleBraceNode = {
+export type LinkAngleBraceNode = {
   type: string;
 };
-type LinkBareURLNode = {
+export type LinkBareURLNode = {
   type: string;
 };
-type OrderedListNode = {
+export type OrderedListNode = {
   type: string;
   items: ParserResult[][];
   ordered: true;
   start?: number;
 };
-type UnorderedListNode = {
+export type UnorderedListNode = {
   type: string;
   items: ParserResult[][];
   ordered: false;
 };
-type NewlineNode = {
+export type NewlineNode = {
   type: string;
 };
-type ParagraphNode = {
+export type ParagraphNode = {
   type: string;
   children: ParserResult[];
 };
-type ReferenceNode = {
+export type ReferenceNode = {
   type: string;
 };
-type ReferenceImageNode = {
+export type ReferenceImageNode = {
   type: string;
   alt?: string;
   ref: string;
 };
-type ReferenceLinkNode = {
+export type ReferenceLinkNode = {
   type: string;
   children: ParserResult[];
   fallbackChildren: string;
   ref: string;
 };
-type TableNode = {
+export type TableNode = {
   type: string;
   align: ('left' | 'right' | 'center')[];
   cells: ParserResult[][][];
   header: ParserResult[][];
 };
-type TableSeparatorNode = {
+export type TableSeparatorNode = {
   type: string;
 };
-type TextNode = {
+export type TextNode = {
   type: string;
   text: string;
 };
-type BoldTextNode = {
+export type BoldTextNode = {
   type: string;
   children: ParserResult[];
 };
-type ItalicTextNode = {
+export type ItalicTextNode = {
   type: string;
   children: ParserResult[];
 };
-type EscapedTextNode = {
+export type EscapedTextNode = {
   type: string;
 };
-type MarkedTextNode = {
+export type MarkedTextNode = {
   type: string;
   children: ParserResult[];
 };
-type StrikethroughTextNode = {
+export type StrikethroughTextNode = {
   type: string;
   children: ParserResult[];
 };
-type HTMLNode = {
+export type HTMLNode = {
   type: string;
   attrs: Record<string, any> | null;
   children?: ParserResult[];
@@ -220,12 +221,12 @@ type HTMLNode = {
   tag: HTMLTag;
   text?: string;
 };
-type HTMLSelfClosingNode = {
+export type HTMLSelfClosingNode = {
   type: string;
   attrs: Record<string, any> | null;
   tag: string;
 };
-type CustomComponentNode = {
+export type CustomComponentNode = {
   type: string;
   attrs: Record<string, any> | null;
   children?: ParserResult[];
@@ -236,23 +237,23 @@ type CustomComponentNode = {
 /**
  * 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;
+export 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[];
+export type NestedParser = (input: string, state: ParseState) => ParserResult[];
 /**
  * Parser function type for a rule.
  */
-type Parser<ParserOutput> = (capture: RegExpMatchArray, nestedParse: NestedParser, state: ParseState) => ParserOutput;
+export type Parser<ParserOutput> = (capture: RegExpMatchArray, nestedParse: NestedParser, state: ParseState) => ParserOutput;
 /**
  * Output function type for rendering.
  */
-type RuleOutput = (ast: ParserResult | ParserResult[], state: ParseState) => unknown;
+export type RuleOutput = (ast: ParserResult | ParserResult[], state: ParseState) => unknown;
 /**
  * Rule definition for parsing and rendering markdown.
  */
-type Rule<ParserOutput = ParserResult> = {
+export 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 */
@@ -264,6 +265,18 @@ type Rule<ParserOutput = ParserResult> = {
    * should even be attempted.
    */
   _qualify?: string[] | ((source: string, state: ParseState) => boolean);
+  /**
+   * Optional ASCII charCodes that can trigger this rule.
+   * If provided, the rule is only evaluated when source starts with one of these characters.
+   */
+  _firstChars?: number[];
+  /**
+   * Optional parsing scope for this rule.
+   * SCOPE_BLOCK (1) / 'block': evaluated only when !state.inline && !state.simple
+   * SCOPE_INLINE (2) / 'inline': evaluated only when state.inline || state.simple
+   * SCOPE_BOTH (3) / 'both': evaluated in both scopes (default)
+   */
+  _scope?: RuleScopeValue;
   /**
    * Render function - converts AST node to output.
    * Uses context's runtime.createElement for element creation.
@@ -273,19 +286,19 @@ type Rule<ParserOutput = ParserResult> = {
 /**
  * Map of all rules keyed by rule type.
  */
-type Rules = {
+export type Rules = {
   [key: string]: Rule<any>;
 };
 /**
  * Map of tag overrides.
  */
-type ComponentOverrides<T> = {
+export type ComponentOverrides<T> = {
   [tag: string]: T;
 };
 /**
  * Render rule hook for custom rendering logic.
  */
-type RenderRuleHook = (
+export type RenderRuleHook = (
 /** Resume normal processing, call this function as a fallback */
 next: () => unknown,
 /** The current AST node */
@@ -298,7 +311,7 @@ state: ParseState) => unknown;
  * Options for the markdown compiler.
  * This is the framework-agnostic version of MarkdownRendererOptions.
  */
-type MarkdownOptions = {
+export type MarkdownOptions = {
   /**
    * Disable automatic link detection for bare URLs.
    */
@@ -344,7 +357,7 @@ type MarkdownOptions = {
  * Combined options including context and compiler options.
  * Used by framework adapters.
  */
-type CompileOptions<T = any> = MarkdownOptions & {
+export type CompileOptions<T = any> = MarkdownOptions & {
   /** Component components */
   components?: ComponentOverrides<T>;
   /** Custom named codes to unicode mappings */
@@ -355,5 +368,4 @@ type CompileOptions<T = any> = MarkdownOptions & {
   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

@@ -1 +1 @@
-{"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;;;;;;EAMA;;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"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../../src/markdown/types.ts"],"mappings":";;;;;;YAUY;;;;YAKA;;;;;YAMA;;;;;;;EAOV,gBACE,MAAM,aACN,OAAO,+BACJ;;;;;EAOL;;;;;;;;;;EAWA,kBACE,KAAK,SACL,OAAO,wBACJ;;;;GAKJ;;;;;YAMS,gBAAgB;;EAE1B,SAAS;;EAET,aAAa,mBAAmB;;EAEhC,aAAa,aAAa,KAAK,SAAS;;EAExC,WAAW,cAAc,YAAY;;EAErC,sBAAsB;;;;;YAUZ;;EAEV;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;EAMA;;EAEA;;EAEA;;YAOU;EACV;EACA;EACA,UAAU;;YAGA;EACV;;YAGU;EACV;;YAGU;EACV;EACA,QAAQ;EACR;EACA;;YAGU;EACV;;YAGU;EACV;EACA;;YAGU;EACV;;YAGU;EACV;EACA;EACA;;YAGU;EACV;EACA;;YAGU;EACV;EACA,UAAU;EACV;EACA;;YAGU;EACV;;YAGU;EACV;;YAGU;EACV;EACA;EACA;EACA;;YAGU;EACV;EACA,UAAU;EACV;EACA;;YAGU;EACV;;YAGU;EACV;;YAGU;EACV;EACA,OAAO;EACP;EACA;;YAGU;EACV;EACA,OAAO;EACP;;YAGU;EACV;;YAGU;EACV;EACA,UAAU;;YAGA;EACV;;YAGU;EACV;EACA;EACA;;YAGU;EACV;EACA,UAAU;EACV;EACA;;YAGU;EACV;EACA;EACA,OAAO;EACP,QAAQ;;YAGE;EACV;;YAGU;EACV;EACA;;YAGU;EACV;EACA,UAAU;;YAGA;EACV;EACA,UAAU;;YAGA;EACV;;YAGU;EACV;EACA,UAAU;;YAGA;EACV;EACA,UAAU;;YAGA;EACV;EACA,OAAO;EACP,WAAW;EACX;EACA,KAAK;EACL;;YAGU;EACV;EACA,OAAO;EACP;;YAGU;EACV;EACA,OAAO;EACP,WAAW;EACX;EACA;EACA;;;;;YAMU,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;;;;YASQ,gBAAgB,eAAe,OAAO,eAAe;;;;YAKrD,OAAO,iBACjB,SAAS,kBACT,aAAa,cACb,OAAO,eACJ;;;;YAKO,cACV,KAAK,eAAe,gBACpB,OAAO;;;;YAMG,KAAK,eAAe;;EAE9B,SACE,gBACA,OAAO,YACP,gCACG;;EAGL;;EAGA,QAAQ,OAAO,KAAK;;;;;EAMpB,wBAAwB,gBAAgB,OAAO;;;;;EAM/C;;;;;;;EAQA,SAAS;;;;;EAMT,WACE,MAAM,cACN,QAAQ,YACR,OAAO;;;;;YAOC;GACT,cAAc;;;;;YAUL,mBAAmB;GAC5B,cAAc;;;;;YAUL,kBAEV;;AAAA,qBAEA;;AAAA,MAAM,cAEN;;AAAA,gBAAgB,YAEhB;;AAAA,OAAO;;;;;YAOG;;;;EAIV;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA;;;;EAKA,aAAa;;;;EAKb,UAAU;;;;EAKV;;;;EAKA;;;;;;YAOU,eAAe,WAAW;;EAEpC,aAAa,mBAAmB;;EAEhC,sBAAsB;;EAEtB,aAAa,eAAe,KAAK,SAAS;;EAE1C,WAAW,eAAe,YAAY"}

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: <T extends string | undefined>(rawString: T) => T;
 /**
  * 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,102 @@ 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;
+/**
+ * A block-syntax probe: either a regex to test, or a predicate for the rules
+ * whose regex was replaced by a linear scanner.
+ */
+export type BlockSyntaxProbe = RegExp | ((input: string) => boolean);
+export declare const some: (probes: BlockSyntaxProbe[], 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":";;;;;qBAwBa,UAAO;;;;qBAWP,aAAU,aAAe;;;;qBAOzB,UAAO;;;;qBAiBP,iBAAkB,8BAA4B,WAAa,MAAI;;;;qBAQ/D,QAAE;;;;qBAKF,MAAG,UAAY,cAAc;qBAyC7B,UAAO;;;;;qBA4BP,YAAS;;;;qBAqCT,sBAAmB;;;;;;;;;;;qBA+BnB,qCAAkC,cACjC;;;;qBAwCD,wBAAqB;KAY7B,cAAc,aAAa;;;;qBAKnB,sBAAmB,wBAA0B;;;;qBA+D7C,gCAA6B,aAC7B,aACA,eACE,gBAEX,eACA,aACA;;;;qBA0CS,yBAAsB;;;;qBAqBtB,kBAAe;;;;qBAUf,gBAAa,gBACV,OACP,cAAY,OACZ,YAAU,yBAEhB;;;;qBA4HU,kBAAe,gBACZ,OACP,cAAY,OACZ,eACN;;;;qBAqCU,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;;;;;;;;YASD,mBAAmB,WAAW;qBAE7B,OAAI,QAAY,oBAAkB"}

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