@intlayer/core 7.6.0-canary.0 → 8.0.0-canary.0

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

@@ -0,0 +1,193 @@
+//#region src/markdown/constants.d.ts
+/**
+ * Constants for the framework-agnostic markdown processor.
+ *
+ * This is part of the Solution F (Hybrid AST + Callback Pattern) implementation
+ * for GitHub Issue #289: Adapt markdown parser in custom packages
+ */
+/**
+ * Analogous to `node.type`. Please note that the values here may change at any time,
+ * so do not hard code against the value directly.
+ */
+declare const RuleType: {
+  readonly blockQuote: "0";
+  readonly breakLine: "1";
+  readonly breakThematic: "2";
+  readonly codeBlock: "3";
+  readonly codeFenced: "4";
+  readonly codeInline: "5";
+  readonly footnote: "6";
+  readonly footnoteReference: "7";
+  readonly gfmTask: "8";
+  readonly heading: "9";
+  readonly headingSetext: "10";
+  /** only available if not `disableHTMLParsing` */
+  readonly htmlBlock: "11";
+  readonly htmlComment: "12";
+  /** only available if not `disableHTMLParsing` */
+  readonly htmlSelfClosing: "13";
+  /** Custom components like <Tabs>, <TabItem> */
+  readonly customComponent: "34";
+  readonly image: "14";
+  readonly link: "15";
+  /** emits a `link` 'node', does not render directly */
+  readonly linkAngleBraceStyleDetector: "16";
+  /** emits a `link` 'node', does not render directly */
+  readonly linkBareUrlDetector: "17";
+  readonly newlineCoalescer: "19";
+  readonly orderedList: "20";
+  readonly paragraph: "21";
+  readonly ref: "22";
+  readonly refImage: "23";
+  readonly refLink: "24";
+  readonly table: "25";
+  readonly tableSeparator: "26";
+  readonly text: "27";
+  readonly textBolded: "28";
+  readonly textEmphasized: "29";
+  readonly textEscaped: "30";
+  readonly textMarked: "31";
+  readonly textStrikethroughed: "32";
+  readonly unorderedList: "33";
+};
+type RuleTypeValue = (typeof RuleType)[keyof typeof RuleType];
+/**
+ * Priority levels for rule ordering.
+ */
+declare const Priority: {
+  /** anything that must scan the tree before everything else */
+  readonly MAX: 0;
+  /** scans for block-level constructs */
+  readonly HIGH: 1;
+  /** inline w/ more priority than other inline */
+  readonly MED: 2;
+  /** inline elements */
+  readonly LOW: 3;
+  /** bare text and stuff that is considered leftovers */
+  readonly MIN: 4;
+};
+type PriorityValue = (typeof Priority)[keyof typeof Priority];
+/** Threshold for performance logging (in milliseconds) */
+declare const DURATION_DELAY_TRIGGER = 20;
+/**
+ * Map of HTML attributes to their JSX prop equivalents.
+ * Some renderers use camelCase for certain attributes.
+ */
+declare const ATTRIBUTE_TO_NODE_PROP_MAP: Record<string, string>;
+/**
+ * Default HTML entity to unicode mappings.
+ */
+declare const NAMED_CODES_TO_UNICODE: Record<string, string>;
+/** HTML elements that should not have their content processed */
+declare const DO_NOT_PROCESS_HTML_ELEMENTS: string[];
+/** Attributes that require URL sanitization */
+declare const ATTRIBUTES_TO_SANITIZE: string[];
+/** Attribute extractor regex */
+declare const ATTR_EXTRACTOR_R: RegExp;
+/** Block end detection */
+declare const BLOCK_END_R: RegExp;
+/** Blockquote patterns */
+declare const BLOCKQUOTE_R: RegExp;
+declare const BLOCKQUOTE_TRIM_LEFT_MULTILINE_R: RegExp;
+declare const BLOCKQUOTE_ALERT_R: RegExp;
+/** Line break patterns */
+declare const BREAK_LINE_R: RegExp;
+declare const BREAK_THEMATIC_R: RegExp;
+/** Code block patterns */
+declare const CODE_BLOCK_FENCED_R: RegExp;
+declare const CODE_BLOCK_R: RegExp;
+declare const CODE_INLINE_R: RegExp;
+/** Newline patterns */
+declare const CONSECUTIVE_NEWLINE_R: RegExp;
+declare const CR_NEWLINE_R: RegExp;
+/** Footnote patterns */
+declare const FOOTNOTE_R: RegExp;
+declare const FOOTNOTE_REFERENCE_R: RegExp;
+/** Form feed */
+declare const FORMFEED_R: RegExp;
+/** Front matter */
+declare const FRONT_MATTER_R: RegExp;
+/** GFM task */
+declare const GFM_TASK_R: RegExp;
+/** Heading patterns */
+declare const HEADING_R: RegExp;
+declare const HEADING_ATX_COMPLIANT_R: RegExp;
+declare const HEADING_SETEXT_R: RegExp;
+/** HTML patterns */
+declare const HTML_BLOCK_ELEMENT_R: RegExp;
+declare const HTML_CHAR_CODE_R: RegExp;
+declare const HTML_COMMENT_R: RegExp;
+declare const HTML_CUSTOM_ATTR_R: RegExp;
+declare const HTML_SELF_CLOSING_ELEMENT_R: RegExp;
+/** Custom component pattern */
+declare const CUSTOM_COMPONENT_R: RegExp;
+/** Interpolation */
+declare const INTERPOLATION_R: RegExp;
+/** Link patterns */
+declare const LINK_AUTOLINK_BARE_URL_R: RegExp;
+declare const LINK_AUTOLINK_R: RegExp;
+declare const CAPTURE_LETTER_AFTER_HYPHEN: RegExp;
+/** Table patterns */
+declare const NP_TABLE_R: RegExp;
+declare const TABLE_TRIM_PIPES: RegExp;
+declare const TABLE_CENTER_ALIGN: RegExp;
+declare const TABLE_LEFT_ALIGN: RegExp;
+declare const TABLE_RIGHT_ALIGN: RegExp;
+/** Paragraph */
+declare const PARAGRAPH_R: RegExp;
+/** Reference patterns */
+declare const REFERENCE_IMAGE_OR_LINK: RegExp;
+declare const REFERENCE_IMAGE_R: RegExp;
+declare const REFERENCE_LINK_R: RegExp;
+/** Block detection */
+declare const SHOULD_RENDER_AS_BLOCK_R: RegExp;
+/** Tab and whitespace */
+declare const TAB_R: RegExp;
+declare const TRIM_STARTING_NEWLINES: RegExp;
+declare const HTML_LEFT_TRIM_AMOUNT_R: RegExp;
+/** List patterns */
+declare const LIST_LOOKBEHIND_R: RegExp;
+declare const ORDERED_LIST_BULLET = "(?:\\d+\\.)";
+declare const UNORDERED_LIST_BULLET = "(?:[*+-])";
+/** Text formatting patterns */
+declare const TEXT_ESCAPED_R: RegExp;
+declare const UNESCAPE_R: RegExp;
+declare const TEXT_PLAIN_R: RegExp;
+/** Shortcode pattern */
+declare const SHORTCODE_R: RegExp;
+type ListType = 1 | 2;
+declare const ORDERED: ListType;
+declare const UNORDERED: ListType;
+/**
+ * Ensure there's at least one more instance of the delimiter later
+ * in the current sequence.
+ */
+declare const LOOKAHEAD: (double: number) => string;
+/**
+ * For inline formatting, this partial attempts to ignore characters that
+ * may appear in nested formatting.
+ */
+declare const INLINE_SKIP_R = "((?:\\[.*?\\][([].*?[)\\]]|<.*?>(?:.*?<.*?>)?|`.*?`|\\\\[^\\s]|[\\s\\S])+?)";
+/** Bold text pattern */
+declare const TEXT_BOLD_R: RegExp;
+/** Emphasized text pattern */
+declare const TEXT_EMPHASIZED_R: RegExp;
+/** Marked text pattern */
+declare const TEXT_MARKED_R: RegExp;
+/** Strikethrough text pattern */
+declare const TEXT_STRIKETHROUGHED_R: RegExp;
+declare const generateListItemPrefix: (type: ListType) => string;
+declare const ORDERED_LIST_ITEM_PREFIX: string;
+declare const UNORDERED_LIST_ITEM_PREFIX: string;
+declare const generateListItemPrefixRegex: (type: ListType) => RegExp;
+declare const ORDERED_LIST_ITEM_PREFIX_R: RegExp;
+declare const UNORDERED_LIST_ITEM_PREFIX_R: RegExp;
+declare const generateListItemRegex: (type: ListType) => RegExp;
+declare const ORDERED_LIST_ITEM_R: RegExp;
+declare const UNORDERED_LIST_ITEM_R: RegExp;
+declare const generateListRegex: (type: ListType) => RegExp;
+declare const ORDERED_LIST_R: RegExp;
+declare const UNORDERED_LIST_R: RegExp;
+//#endregion
+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, 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 };
+//# sourceMappingURL=constants.d.ts.map

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

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

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

@@ -0,0 +1,7 @@
+import { BlockQuoteNode, BoldTextNode, BreakLineNode, BreakThematicNode, CodeBlockNode, CodeInlineNode, CompileOptions, CustomComponentNode, ElementType, FootnoteNode, FootnoteReferenceNode, GFMTaskNode, HTMLNode, HTMLSelfClosingNode, HTMLTag, HeadingNode, ImageNode, ItalicTextNode, LinkNode, MarkdownContext, MarkdownOptions, MarkdownRuntime, MarkedTextNode, NestedParser, NewlineNode, OrderedListNode, Overrides, ParagraphNode, ParseState, ParserResult, ReferenceImageNode, ReferenceLinkNode, ReferenceNode, RenderRuleHook, Rule, RuleOutput, Rules, StrikethroughTextNode, TableNode, TableSeparatorNode, TextNode, UnorderedListNode } from "./types.js";
+import { compile, compileWithOptions, createCompiler } from "./compiler.js";
+import { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, DO_NOT_PROCESS_HTML_ELEMENTS, DURATION_DELAY_TRIGGER, ListType, NAMED_CODES_TO_UNICODE, ORDERED, Priority, PriorityValue, RuleType, RuleTypeValue, UNORDERED } 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, parseTableCells, parseTableRow, qualifies, renderNothing, sanitizer, simpleInlineRegex, slugify, some, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, unquote } from "./utils.js";
+export { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, type BlockQuoteNode, type BoldTextNode, type BreakLineNode, type BreakThematicNode, type CodeBlockNode, type CodeInlineNode, type CompileOptions, type CustomComponentNode, DO_NOT_PROCESS_HTML_ELEMENTS, DURATION_DELAY_TRIGGER, type ElementType, type FootnoteNode, type FootnoteReferenceNode, type GFMTaskNode, type HTMLNode, type HTMLSelfClosingNode, type HTMLTag, type HeadingNode, type ImageNode, type ItalicTextNode, type LinkNode, type ListType, type MarkdownContext, type MarkdownOptions, type MarkdownRuntime, type MarkedTextNode, NAMED_CODES_TO_UNICODE, type NestedParser, type NewlineNode, ORDERED, type OrderedListNode, type Overrides, type ParagraphNode, type ParseState, type ParserResult, Priority, type PriorityValue, type ReferenceImageNode, type ReferenceLinkNode, type ReferenceNode, type RenderRuleHook, type Rule, type RuleOutput, RuleType, type RuleTypeValue, type Rules, type StrikethroughTextNode, type TableNode, type TableSeparatorNode, type TextNode, UNORDERED, type UnorderedListNode, allowInline, anyScopeRegex, attributeValueToNodePropValue, blockRegex, captureNothing, compile, compileWithOptions, createCompiler, createRenderer, cx, get, inlineRegex, normalizeAttributeKey, normalizeWhitespace, parseBlock, parseCaptureInline, parseInline, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableCells, parseTableRow, parserFor, qualifies, renderFor, renderNothing, sanitizer, simpleInlineRegex, slugify, some, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, unquote };

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

@@ -0,0 +1,17 @@
+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"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;cAqBa,mBACJ,mCACmB,eAAe"}

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

@@ -0,0 +1,23 @@
+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"],"sourcesContent":[],"mappings":";;;;;;;AAiGA;;;;AAE8B,cA3EjB,SA2EiB,EAAA,CAAA,MAAA,EAAA,CAAA,GAAA,EAxEnB,YAwEmB,EAAA,MAAA,EAvEhB,UAuEgB,EAAA,KAAA,EAtEjB,UAsEiB,EAAA,GAAA,OAAA,EAAA,GAAA,CAAA,GAAA,EAnEtB,YAmEsB,GAnEP,YAmEO,EAAA,EAAA,KAAA,CAAA,EAnEgB,UAmEhB,EAAA,GAAA,GAAA;;;;;;;;cAFjB,wBACH,oBAAoB,yBACtB,sBAAsB,mBAAmB"}

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

@@ -0,0 +1,367 @@
+//#region src/markdown/types.d.ts
+/**
+ * Framework-agnostic markdown processor types.
+ * No framework-specific imports allowed in this file.
+ *
+ * This is part of the Solution F (Hybrid AST + Callback Pattern) implementation
+ * for GitHub Issue #289: Adapt markdown parser in custom packages
+ */
+/**
+ * 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.
+ */
+interface 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.
+ */
+interface MarkdownContext {
+  /** Framework runtime (createElement, etc.) */
+  runtime: MarkdownRuntime;
+  /** Component components for HTML tags */
+  components?: Overrides;
+  /** 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>;
+};
+/**
+ * RequireAtLeastOne utility type.
+ */
+type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & { [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>> }[Keys];
+/**
+ * Override configuration for a single tag.
+ */
+type Override = RequireAtLeastOne<{
+  component: any;
+  props: Record<string, any>;
+}> | any;
+/**
+ * Map of tag overrides.
+ */
+type Overrides = {
+  [tag: string]: Override;
+};
+/**
+ * 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 MarkdownProcessorOptions.
+ */
+interface 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.
+ */
+interface CompileOptions extends MarkdownOptions {
+  /** Component components */
+  components?: Overrides;
+  /** 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, CustomComponentNode, ElementType, EscapedTextNode, FootnoteNode, FootnoteReferenceNode, GFMTaskNode, HTMLCommentNode, HTMLNode, HTMLSelfClosingNode, HTMLTag, HeadingNode, HeadingSetextNode, ImageNode, ItalicTextNode, LinkAngleBraceNode, LinkBareURLNode, LinkNode, MarkdownContext, MarkdownOptions, MarkdownRuntime, MarkedTextNode, NestedParser, NewlineNode, OrderedListNode, Override, Overrides, 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"],"sourcesContent":[],"mappings":"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"}