@intlayer/core 9.4.3 → 9.4.4

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

@@ -3,7 +3,7 @@
  * 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: {
+export declare const RuleType: {
   readonly blockQuote: '0';
   readonly breakLine: '1';
   readonly breakThematic: '2';
@@ -44,11 +44,11 @@ declare const RuleType: {
   readonly textStrikethroughed: '32';
   readonly unorderedList: '33';
 };
-type RuleTypeValue = (typeof RuleType)[keyof typeof RuleType];
+export type RuleTypeValue = (typeof RuleType)[keyof typeof RuleType];
 /**
  * Priority levels for rule ordering.
  */
-declare const Priority: {
+export declare const Priority: {
   /** anything that must scan the tree before everything else */
   readonly MAX: 0;
   /** scans for block-level constructs */
@@ -60,136 +60,135 @@ declare const Priority: {
   /** bare text and stuff that is considered leftovers */
   readonly MIN: 4;
 };
-type PriorityValue = (typeof Priority)[keyof typeof Priority];
+export type PriorityValue = (typeof Priority)[keyof typeof Priority];
 /**
  * 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>;
+export 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>;
+export 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[];
+export declare const DO_NOT_PROCESS_HTML_ELEMENTS: string[];
 /** Attributes that require URL sanitization */
-declare const ATTRIBUTES_TO_SANITIZE: string[];
+export declare const ATTRIBUTES_TO_SANITIZE: string[];
 /** Attribute extractor regex */
-declare const ATTR_EXTRACTOR_R: RegExp;
+export declare const ATTR_EXTRACTOR_R: RegExp;
 /** Block end detection */
-declare const BLOCK_END_R: RegExp;
+export 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;
+export declare const BLOCKQUOTE_R: RegExp;
+export declare const BLOCKQUOTE_TRIM_LEFT_MULTILINE_R: RegExp;
+export declare const BLOCKQUOTE_ALERT_R: RegExp;
 /** Line break patterns */
-declare const BREAK_LINE_R: RegExp;
-declare const BREAK_THEMATIC_R: RegExp;
+export declare const BREAK_LINE_R: RegExp;
+export declare const BREAK_THEMATIC_R: RegExp;
 /** Code block patterns */
-declare const CODE_BLOCK_FENCED_R: RegExp;
-declare const CODE_BLOCK_R: RegExp;
+export declare const CODE_BLOCK_FENCED_R: RegExp;
+export declare const CODE_BLOCK_R: RegExp;
 /** A single line opening or closing a fenced code block, with its indentation. */
-declare const FENCE_DELIMITER_R: RegExp;
-declare const CODE_INLINE_R: RegExp;
+export declare const FENCE_DELIMITER_R: RegExp;
+export declare const CODE_INLINE_R: RegExp;
 /** Newline patterns */
-declare const CONSECUTIVE_NEWLINE_R: RegExp;
-declare const CR_NEWLINE_R: RegExp;
+export declare const CONSECUTIVE_NEWLINE_R: RegExp;
+export declare const CR_NEWLINE_R: RegExp;
 /** Footnote patterns */
-declare const FOOTNOTE_R: RegExp;
-declare const FOOTNOTE_REFERENCE_R: RegExp;
+export declare const FOOTNOTE_R: RegExp;
+export declare const FOOTNOTE_REFERENCE_R: RegExp;
 /** Form feed */
-declare const FORMFEED_R: RegExp;
+export declare const FORMFEED_R: RegExp;
 /** Front matter */
-declare const FRONT_MATTER_R: RegExp;
+export declare const FRONT_MATTER_R: RegExp;
 /** GFM task */
-declare const GFM_TASK_R: RegExp;
+export 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;
-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;
+export declare const HEADING_R: RegExp;
+export declare const HEADING_ATX_COMPLIANT_R: RegExp;
+export declare const HEADING_SETEXT_R: RegExp;
+export declare const HTML_BLOCK_ELEMENT_R: RegExp;
+export declare const HTML_CHAR_CODE_R: RegExp;
+export declare const HTML_COMMENT_R: RegExp;
+export declare const HTML_CUSTOM_ATTR_R: RegExp;
+export declare const HTML_SELF_CLOSING_ELEMENT_R: RegExp;
 /** Custom component pattern */
-declare const CUSTOM_COMPONENT_R: RegExp;
+export declare const CUSTOM_COMPONENT_R: RegExp;
 /** Interpolation */
-declare const INTERPOLATION_R: RegExp;
+export 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;
+export declare const LINK_AUTOLINK_BARE_URL_R: RegExp;
+export declare const LINK_AUTOLINK_R: RegExp;
+export 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;
+export declare const NP_TABLE_R: RegExp;
+export declare const TABLE_TRIM_PIPES: RegExp;
+export declare const TABLE_CENTER_ALIGN: RegExp;
+export declare const TABLE_LEFT_ALIGN: RegExp;
+export declare const TABLE_RIGHT_ALIGN: RegExp;
 /** Paragraph */
-declare const PARAGRAPH_R: RegExp;
+export 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;
+export declare const REFERENCE_IMAGE_OR_LINK: RegExp;
+export declare const REFERENCE_IMAGE_R: RegExp;
+export declare const REFERENCE_LINK_R: RegExp;
 /**
  * Cheap prefix probes used to reject a rule before its full (and far more
  * expensive) block regex runs. Kept as module constants so the parser's inner
  * loop never allocates a `RegExp` per candidate position.
  */
-declare const HTML_BLOCK_OPENING_TAG_R: RegExp;
-declare const HTML_SELF_CLOSING_OPENING_TAG_R: RegExp;
-declare const CUSTOM_COMPONENT_OPENING_TAG_R: RegExp;
+export declare const HTML_BLOCK_OPENING_TAG_R: RegExp;
+export declare const HTML_SELF_CLOSING_OPENING_TAG_R: RegExp;
+export declare const CUSTOM_COMPONENT_OPENING_TAG_R: RegExp;
 /** Block detection */
-declare const SHOULD_RENDER_AS_BLOCK_R: RegExp;
+export declare const SHOULD_RENDER_AS_BLOCK_R: RegExp;
 /** Tab and whitespace */
-declare const TAB_R: RegExp;
+export declare const TAB_R: RegExp;
 /** Every character `normalizeWhitespace` rewrites, so it needs a single pass. */
-declare const NORMALIZE_WHITESPACE_R: RegExp;
-declare const TRIM_STARTING_NEWLINES: RegExp;
-declare const HTML_LEFT_TRIM_AMOUNT_R: RegExp;
+export declare const NORMALIZE_WHITESPACE_R: RegExp;
+export declare const TRIM_STARTING_NEWLINES: RegExp;
+export declare const HTML_LEFT_TRIM_AMOUNT_R: RegExp;
 /** List patterns */
-declare const ORDERED_LIST_BULLET = "(?:\\d+\\.)";
-declare const UNORDERED_LIST_BULLET = "(?:[*+-])";
+export declare const ORDERED_LIST_BULLET = "(?:\\d+\\.)";
+export 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;
+export declare const TEXT_ESCAPED_R: RegExp;
+export declare const UNESCAPE_R: RegExp;
+export 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;
+export declare const SHORTCODE_R: RegExp;
+export type ListType = 1 | 2;
+export declare const ORDERED: ListType;
+export 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;
+export 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])+?)";
+export declare const INLINE_SKIP_R = "((?:\\[.*?\\][([].*?[)\\]]|<.*?>(?:.*?<.*?>)?|`.*?`|\\\\[^\\s]|[\\s\\S])+?)";
 /** Bold text pattern */
-declare const TEXT_BOLD_R: RegExp;
+export declare const TEXT_BOLD_R: RegExp;
 /** Emphasized text pattern */
-declare const TEXT_EMPHASIZED_R: RegExp;
+export declare const TEXT_EMPHASIZED_R: RegExp;
 /** Marked text pattern */
-declare const TEXT_MARKED_R: RegExp;
+export 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;
+export declare const TEXT_STRIKETHROUGHED_R: RegExp;
+export declare const generateListItemPrefix: (type: ListType) => string;
+export declare const ORDERED_LIST_ITEM_PREFIX: string;
+export declare const UNORDERED_LIST_ITEM_PREFIX: string;
+export declare const generateListItemPrefixRegex: (type: ListType) => RegExp;
+export declare const ORDERED_LIST_ITEM_PREFIX_R: RegExp;
+export declare const UNORDERED_LIST_ITEM_PREFIX_R: RegExp;
+export declare const generateListItemRegex: (type: ListType) => RegExp;
+export declare const ORDERED_LIST_ITEM_R: RegExp;
+export declare const UNORDERED_LIST_ITEM_R: RegExp;
+export declare const generateListRegex: (type: ListType) => RegExp;
+export declare const ORDERED_LIST_R: RegExp;
+export 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_OPENING_TAG_R, CUSTOM_COMPONENT_R, DO_NOT_PROCESS_HTML_ELEMENTS, FENCE_DELIMITER_R, 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_BLOCK_OPENING_TAG_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, HTML_SELF_CLOSING_OPENING_TAG_R, INLINE_SKIP_R, INTERPOLATION_R, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LOOKAHEAD, ListType, NAMED_CODES_TO_UNICODE, NORMALIZE_WHITESPACE_R, 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

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","names":[],"sources":["../../../src/markdown/constants.ts"],"mappings":";;;;;cAQa;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;WAEA;WACA;;WAEA;;WAEA;WACA;WACA;;WAEA;;WAEA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;KAUU,wBAAwB,uBAAuB;;;;cAS9C;;WAEX;;WAEA;;WAEA;;WAEA;;WAEA;;KAGU,wBAAwB,uBAAuB;;;;;cAU9C,4BAA4B;;;;cAuD5B,wBAAwB;;cAcxB;;cAGA;;cAcA,kBAAgB;;cAIhB,aAAW;;cAGX,cAAY;cACZ,kCAAgC;cAChC,oBAAkB;;cAGlB,cAAY;cACZ,kBAAgB;;cAGhB,qBAAmB;cAEnB,cAAY;;cAEZ,mBAAiB;cACjB,eAAa;;cAGb,uBAAqB;cACrB,cAAY;;cAGZ,YAAU;cACV,sBAAoB;;cAGpB,YAAU;;cAGV,gBAAc;;cAGd,YAAU;;cAGV,WAAS;cACT,yBAAuB;cAEvB,kBAAgB;cAqChB,sBAAoB;cAIpB,kBAAgB;cAEhB,gBAAc;cACd,oBAAkB;cAClB,6BAA2B;;cAM3B,oBAAkB;;cAKlB,iBAAe;;cAGf,0BAAwB;cACxB,iBAAe;cACf,6BAA2B;;cAG3B,YAAU;cAEV,kBAAgB;cAChB,oBAAkB;cAClB,kBAAgB;cAChB,mBAAiB;;cAGjB,aAAW;;cAGX,yBAAuB;cAEvB,mBAAiB;cACjB,kBAAgB;;;;;;cAOhB,0BAAwB;cACxB,iCAA+B;cAE/B,gCAA8B;;cAG9B,0BAAwB;;cAGxB,OAAK;;cAEL,wBAAsB;cACtB,wBAAsB;cACtB,yBAAuB;;cAGvB;cACA;;cAGA,gBAAc;cACd,YAAU;cACV,cAAY;;cAIZ,aAAW;KAMZ;cACC,SAAS;cACT,WAAW;;;;;cAUX,YAAS;;;;;cAOT;;cAIA,aAAW;;cAKX,mBAAiB;;cAKjB,eAAa;;cAKb,wBAAsB;cAQtB,yBAAsB,MAAU;cAQhC;cACA;cAEA,8BAA2B,MAAU,aAAW;cAOhD,4BAA0B;cAC1B,8BAA4B;cAG5B,wBAAqB,MAAU,aAAW;cAc1C,qBAAmB;cACnB,uBAAqB;cAErB,oBAAiB,MAAU,aAAW;cAiBtC,gBAAc;cACd,kBAAgB"}
+{"version":3,"file":"constants.d.ts","names":[],"sources":["../../../src/markdown/constants.ts"],"mappings":";;;;;qBAQa;WACX;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;WAEA;WACA;;WAEA;;WAEA;WACA;WACA;;WAEA;;WAEA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;YAUU,wBAAwB,uBAAuB;;;;qBAS9C;;WAEX;;WAEA;;WAEA;;WAEA;;WAEA;;YAGU,wBAAwB,uBAAuB;;;;;qBAU9C,4BAA4B;;;;qBAuD5B,wBAAwB;;qBAcxB;;qBAGA;;qBAcA,kBAAgB;;qBAIhB,aAAW;;qBAGX,cAAY;qBACZ,kCAAgC;qBAChC,oBAAkB;;qBAGlB,cAAY;qBACZ,kBAAgB;;qBAGhB,qBAAmB;qBAEnB,cAAY;;qBAEZ,mBAAiB;qBACjB,eAAa;;qBAGb,uBAAqB;qBACrB,cAAY;;qBAGZ,YAAU;qBACV,sBAAoB;;qBAGpB,YAAU;;qBAGV,gBAAc;;qBAGd,YAAU;;qBAGV,WAAS;qBACT,yBAAuB;qBAEvB,kBAAgB;qBAqChB,sBAAoB;qBAIpB,kBAAgB;qBAEhB,gBAAc;qBACd,oBAAkB;qBAClB,6BAA2B;;qBAM3B,oBAAkB;;qBAKlB,iBAAe;;qBAGf,0BAAwB;qBACxB,iBAAe;qBACf,6BAA2B;;qBAG3B,YAAU;qBAEV,kBAAgB;qBAChB,oBAAkB;qBAClB,kBAAgB;qBAChB,mBAAiB;;qBAGjB,aAAW;;qBAGX,yBAAuB;qBAEvB,mBAAiB;qBACjB,kBAAgB;;;;;;qBAOhB,0BAAwB;qBACxB,iCAA+B;qBAE/B,gCAA8B;;qBAG9B,0BAAwB;;qBAGxB,OAAK;;qBAEL,wBAAsB;qBACtB,wBAAsB;qBACtB,yBAAuB;;qBAGvB;qBACA;;qBAGA,gBAAc;qBACd,YAAU;qBACV,cAAY;;qBAIZ,aAAW;YAMZ;qBACC,SAAS;qBACT,WAAW;;;;;qBAUX,YAAS;;;;;qBAOT;;qBAIA,aAAW;;qBAKX,mBAAiB;;qBAKjB,eAAa;;qBAKb,wBAAsB;qBAQtB,yBAAsB,MAAU;qBAQhC;qBACA;qBAEA,8BAA2B,MAAU,aAAW;qBAOhD,4BAA0B;qBAC1B,8BAA4B;qBAG5B,wBAAqB,MAAU,aAAW;qBAc1C,qBAAmB;qBACnB,uBAAqB;qBAErB,oBAAiB,MAAU,aAAW;qBAiBtC,gBAAc;qBACd,kBAAgB"}

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

@@ -9,7 +9,6 @@ import { ParseState, ParserResult, Rules } from "./types.js";
  *
  * @returns The resulting parse function
  */
-declare const parserFor: (rules: Rules) => ((source: string, state: ParseState) => ParserResult[]);
+export 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

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","names":[],"sources":["../../../src/markdown/parser.ts"],"mappings":";;;;;;;;;;;cAoHa,YAAS,OACb,YACJ,gBAAgB,OAAO,eAAe"}
+{"version":3,"file":"parser.d.ts","names":[],"sources":["../../../src/markdown/parser.ts"],"mappings":";;;;;;;;;;;qBAoHa,YAAS,OACb,YACJ,gBAAgB,OAAO,eAAe"}

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

@@ -7,7 +7,7 @@ import { ParseState, ParserResult, RenderRuleHook, RuleOutput, Rules } from "./t
  * @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;
+export 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.
  *
@@ -15,7 +15,6 @@ declare const renderFor: (render: (ast: ParserResult, render: RuleOutput, state:
  * @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;
+export 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

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","names":[],"sources":["../../../src/markdown/renderer.ts"],"mappings":";;;;;;;;;cAea,YAAS,SACX,KAAK,cAAc,QAAQ,YAAY,OAAO,4BAAsB,KAKtE,eAAe,gBAAc,QAC3B;;;;;;;;cA8CE,iBAAc,OACjB,OAAK,aAAe,oBAAc,KACpC,cAAY,QAAU,YAAU,OAAS"}
+{"version":3,"file":"renderer.d.ts","names":[],"sources":["../../../src/markdown/renderer.ts"],"mappings":";;;;;;;;;qBAea,YAAS,SACX,KAAK,cAAc,QAAQ,YAAY,OAAO,4BAAsB,KAKtE,eAAe,gBAAc,QAC3B;;;;;;;;qBA8CE,iBAAc,OACjB,OAAK,aAAe,oBAAc,KACpC,cAAY,QAAU,YAAU,OAAS"}

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

@@ -3,16 +3,16 @@
  * 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 +43,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 +58,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 +82,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 +220,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 +236,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 */
@@ -273,19 +273,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 +298,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 +344,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 +355,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":";;;;;YAQY;;;;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,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"}