@intlayer/core 8.4.4 → 8.4.6

package/dist/esm/markdown/index.mjs

@@ -1 +1,10 @@
-import{getMarkdownMetadata as e}from"../transpiler/markdown/getMarkdownMetadata.mjs";import{validateMarkdown as t}from"../transpiler/markdown/validateMarkdown.mjs";import{md as n}from"../transpiler/markdown/markdown.mjs";import{ATTRIBUTES_TO_SANITIZE as r,ATTRIBUTE_TO_NODE_PROP_MAP as i,ATTR_EXTRACTOR_R as a,BLOCKQUOTE_ALERT_R as o,BLOCKQUOTE_R as s,BLOCKQUOTE_TRIM_LEFT_MULTILINE_R as c,BLOCK_END_R as l,BREAK_LINE_R as u,BREAK_THEMATIC_R as d,CAPTURE_LETTER_AFTER_HYPHEN as f,CODE_BLOCK_FENCED_R as p,CODE_BLOCK_R as m,CODE_INLINE_R as h,CONSECUTIVE_NEWLINE_R as g,CR_NEWLINE_R as _,CUSTOM_COMPONENT_R as v,DO_NOT_PROCESS_HTML_ELEMENTS as y,DURATION_DELAY_TRIGGER as b,FOOTNOTE_R as x,FOOTNOTE_REFERENCE_R as S,FORMFEED_R as C,FRONT_MATTER_R as w,GFM_TASK_R as T,HEADING_ATX_COMPLIANT_R as E,HEADING_R as D,HEADING_SETEXT_R as O,HTML_BLOCK_ELEMENT_R as k,HTML_CHAR_CODE_R as A,HTML_COMMENT_R as j,HTML_CUSTOM_ATTR_R as M,HTML_LEFT_TRIM_AMOUNT_R as N,HTML_SELF_CLOSING_ELEMENT_R as P,INLINE_SKIP_R as F,INTERPOLATION_R as I,LINK_AUTOLINK_BARE_URL_R as L,LINK_AUTOLINK_R as R,LIST_LOOKBEHIND_R as z,LOOKAHEAD as B,NAMED_CODES_TO_UNICODE as V,NP_TABLE_R as H,ORDERED as U,ORDERED_LIST_BULLET as W,ORDERED_LIST_ITEM_PREFIX as G,ORDERED_LIST_ITEM_PREFIX_R as K,ORDERED_LIST_ITEM_R as q,ORDERED_LIST_R as J,PARAGRAPH_R as Y,Priority as X,REFERENCE_IMAGE_OR_LINK as Z,REFERENCE_IMAGE_R as Q,REFERENCE_LINK_R as $,RuleType as ee,SHORTCODE_R as te,SHOULD_RENDER_AS_BLOCK_R as ne,TABLE_CENTER_ALIGN as re,TABLE_LEFT_ALIGN as ie,TABLE_RIGHT_ALIGN as ae,TABLE_TRIM_PIPES as oe,TAB_R as se,TEXT_BOLD_R as ce,TEXT_EMPHASIZED_R as le,TEXT_ESCAPED_R as ue,TEXT_MARKED_R as de,TEXT_PLAIN_R as fe,TEXT_STRIKETHROUGHED_R as pe,TRIM_STARTING_NEWLINES as me,UNESCAPE_R as he,UNORDERED as ge,UNORDERED_LIST_BULLET as _e,UNORDERED_LIST_ITEM_PREFIX as ve,UNORDERED_LIST_ITEM_PREFIX_R as ye,UNORDERED_LIST_ITEM_R as be,UNORDERED_LIST_R as xe,generateListItemPrefix as Se,generateListItemPrefixRegex as Ce,generateListItemRegex as we,generateListRegex as Te}from"./constants.mjs";import{allowInline as Ee,anyScopeRegex as De,attributeValueToNodePropValue as Oe,blockRegex as ke,captureNothing as Ae,cx as je,get as Me,inlineRegex as Ne,normalizeAttributeKey as Pe,normalizeWhitespace as Fe,parseBlock as Ie,parseCaptureInline as Le,parseInline as Re,parseSimpleInline as ze,parseStyleAttribute as Be,parseTableAlign as Ve,parseTableAlignCapture as He,parseTableCells as Ue,parseTableRow as We,qualifies as Ge,renderNothing as Ke,sanitizer as qe,simpleInlineRegex as Je,slugify as Ye,some as Xe,startsWith as Ze,trimEnd as Qe,trimLeadingWhitespaceOutsideFences as $e,unescapeString as et,unquote as tt}from"./utils.mjs";import{parserFor as nt}from"./parser.mjs";import{createRenderer as rt,renderFor as it}from"./renderer.mjs";import{compile as at,compileWithOptions as ot,createCompiler as st}from"./compiler.mjs";export{r as ATTRIBUTES_TO_SANITIZE,i as ATTRIBUTE_TO_NODE_PROP_MAP,a as ATTR_EXTRACTOR_R,o as BLOCKQUOTE_ALERT_R,s as BLOCKQUOTE_R,c as BLOCKQUOTE_TRIM_LEFT_MULTILINE_R,l as BLOCK_END_R,u as BREAK_LINE_R,d as BREAK_THEMATIC_R,f as CAPTURE_LETTER_AFTER_HYPHEN,p as CODE_BLOCK_FENCED_R,m as CODE_BLOCK_R,h as CODE_INLINE_R,g as CONSECUTIVE_NEWLINE_R,_ as CR_NEWLINE_R,v as CUSTOM_COMPONENT_R,y as DO_NOT_PROCESS_HTML_ELEMENTS,b as DURATION_DELAY_TRIGGER,x as FOOTNOTE_R,S as FOOTNOTE_REFERENCE_R,C as FORMFEED_R,w as FRONT_MATTER_R,T as GFM_TASK_R,E as HEADING_ATX_COMPLIANT_R,D as HEADING_R,O as HEADING_SETEXT_R,k as HTML_BLOCK_ELEMENT_R,A as HTML_CHAR_CODE_R,j as HTML_COMMENT_R,M as HTML_CUSTOM_ATTR_R,N as HTML_LEFT_TRIM_AMOUNT_R,P as HTML_SELF_CLOSING_ELEMENT_R,F as INLINE_SKIP_R,I as INTERPOLATION_R,L as LINK_AUTOLINK_BARE_URL_R,R as LINK_AUTOLINK_R,z as LIST_LOOKBEHIND_R,B as LOOKAHEAD,V as NAMED_CODES_TO_UNICODE,H as NP_TABLE_R,U as ORDERED,W as ORDERED_LIST_BULLET,G as ORDERED_LIST_ITEM_PREFIX,K as ORDERED_LIST_ITEM_PREFIX_R,q as ORDERED_LIST_ITEM_R,J as ORDERED_LIST_R,Y as PARAGRAPH_R,X as Priority,Z as REFERENCE_IMAGE_OR_LINK,Q as REFERENCE_IMAGE_R,$ as REFERENCE_LINK_R,ee as RuleType,te as SHORTCODE_R,ne as SHOULD_RENDER_AS_BLOCK_R,re as TABLE_CENTER_ALIGN,ie as TABLE_LEFT_ALIGN,ae as TABLE_RIGHT_ALIGN,oe as TABLE_TRIM_PIPES,se as TAB_R,ce as TEXT_BOLD_R,le as TEXT_EMPHASIZED_R,ue as TEXT_ESCAPED_R,de as TEXT_MARKED_R,fe as TEXT_PLAIN_R,pe as TEXT_STRIKETHROUGHED_R,me as TRIM_STARTING_NEWLINES,he as UNESCAPE_R,ge as UNORDERED,_e as UNORDERED_LIST_BULLET,ve as UNORDERED_LIST_ITEM_PREFIX,ye as UNORDERED_LIST_ITEM_PREFIX_R,be as UNORDERED_LIST_ITEM_R,xe as UNORDERED_LIST_R,Ee as allowInline,De as anyScopeRegex,Oe as attributeValueToNodePropValue,ke as blockRegex,Ae as captureNothing,at as compile,ot as compileWithOptions,st as createCompiler,rt as createRenderer,je as cx,Se as generateListItemPrefix,Ce as generateListItemPrefixRegex,we as generateListItemRegex,Te as generateListRegex,Me as get,e as getMarkdownMetadata,Ne as inlineRegex,n as md,Pe as normalizeAttributeKey,Fe as normalizeWhitespace,Ie as parseBlock,Le as parseCaptureInline,Re as parseInline,ze as parseSimpleInline,Be as parseStyleAttribute,Ve as parseTableAlign,He as parseTableAlignCapture,Ue as parseTableCells,We as parseTableRow,nt as parserFor,Ge as qualifies,it as renderFor,Ke as renderNothing,qe as sanitizer,Je as simpleInlineRegex,Ye as slugify,Xe as some,Ze as startsWith,Qe as trimEnd,$e as trimLeadingWhitespaceOutsideFences,et as unescapeString,tt as unquote,t as validateMarkdown};
+import { getMarkdownMetadata } from "../transpiler/markdown/getMarkdownMetadata.mjs";
+import { validateMarkdown } from "../transpiler/markdown/validateMarkdown.mjs";
+import { md as markdown } from "../transpiler/markdown/markdown.mjs";
+import { ATTRIBUTES_TO_SANITIZE, ATTRIBUTE_TO_NODE_PROP_MAP, ATTR_EXTRACTOR_R, BLOCKQUOTE_ALERT_R, BLOCKQUOTE_R, BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, BLOCK_END_R, BREAK_LINE_R, BREAK_THEMATIC_R, CAPTURE_LETTER_AFTER_HYPHEN, CODE_BLOCK_FENCED_R, CODE_BLOCK_R, CODE_INLINE_R, CONSECUTIVE_NEWLINE_R, CR_NEWLINE_R, CUSTOM_COMPONENT_R, DO_NOT_PROCESS_HTML_ELEMENTS, DURATION_DELAY_TRIGGER, FOOTNOTE_R, FOOTNOTE_REFERENCE_R, FORMFEED_R, FRONT_MATTER_R, GFM_TASK_R, HEADING_ATX_COMPLIANT_R, HEADING_R, HEADING_SETEXT_R, HTML_BLOCK_ELEMENT_R, HTML_CHAR_CODE_R, HTML_COMMENT_R, HTML_CUSTOM_ATTR_R, HTML_LEFT_TRIM_AMOUNT_R, HTML_SELF_CLOSING_ELEMENT_R, INLINE_SKIP_R, INTERPOLATION_R, LINK_AUTOLINK_BARE_URL_R, LINK_AUTOLINK_R, LIST_LOOKBEHIND_R, LOOKAHEAD, 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, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleType, SHORTCODE_R, SHOULD_RENDER_AS_BLOCK_R, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, TEXT_BOLD_R, TEXT_EMPHASIZED_R, TEXT_ESCAPED_R, TEXT_MARKED_R, TEXT_PLAIN_R, TEXT_STRIKETHROUGHED_R, TRIM_STARTING_NEWLINES, UNESCAPE_R, UNORDERED, UNORDERED_LIST_BULLET, UNORDERED_LIST_ITEM_PREFIX, UNORDERED_LIST_ITEM_PREFIX_R, UNORDERED_LIST_ITEM_R, UNORDERED_LIST_R, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex } from "./constants.mjs";
+import { allowInline, anyScopeRegex, attributeValueToNodePropValue, blockRegex, captureNothing, cx, get, inlineRegex, normalizeAttributeKey, normalizeWhitespace, parseBlock, parseCaptureInline, parseInline, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, qualifies, renderNothing, sanitizer, simpleInlineRegex, slugify, some, startsWith, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, unquote } from "./utils.mjs";
+import { parserFor } from "./parser.mjs";
+import { createRenderer, renderFor } from "./renderer.mjs";
+import { compile, compileWithOptions, createCompiler } from "./compiler.mjs";
+
+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, 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, REFERENCE_IMAGE_OR_LINK, REFERENCE_IMAGE_R, REFERENCE_LINK_R, RuleType, 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, allowInline, anyScopeRegex, attributeValueToNodePropValue, blockRegex, captureNothing, compile, compileWithOptions, createCompiler, createRenderer, cx, generateListItemPrefix, generateListItemPrefixRegex, generateListItemRegex, generateListRegex, get, getMarkdownMetadata, inlineRegex, markdown as md, normalizeAttributeKey, normalizeWhitespace, parseBlock, parseCaptureInline, parseInline, parseSimpleInline, parseStyleAttribute, parseTableAlign, parseTableAlignCapture, parseTableCells, parseTableRow, parserFor, qualifies, renderFor, renderNothing, sanitizer, simpleInlineRegex, slugify, some, startsWith, trimEnd, trimLeadingWhitespaceOutsideFences, unescapeString, unquote, validateMarkdown };

package/dist/esm/markdown/parser.mjs

@@ -1,2 +1,66 @@
-import"./constants.mjs";import{normalizeWhitespace as e,qualifies as t}from"./utils.mjs";const n=n=>{let r=performance.now(),i=Object.keys(n);i.sort((e,t)=>n[e]._order-n[t]._order||(e<t?-1:1));let a=(e,r={})=>{let o=performance.now(),s=[];if(r.prevCapture=r.prevCapture||``,e.trim())for(;e;){let o=0;for(;o<i.length;){let c=i[o],l=n[c];if(l._qualify&&!t(e,r,l._qualify)){o++;continue}let u=performance.now(),d=l._match(e,r),f=performance.now()-u;if(f>1&&console.log(`${c}._match: ${f.toFixed(3)}ms, source length: ${e.length}`),d?.[0]){e=e.substring(d[0].length);let t=performance.now(),n=l._parse(d,a,r),i=performance.now()-t;i>1&&console.log(`${c}._parse: ${i.toFixed(3)}ms, capture length: ${d[0].length}`),r.prevCapture=(r.prevCapture||``)+d[0],n.type||=c,s.push(n);break}o++}}let c=performance.now()-o;return c>1&&console.log(`nestedParse: ${c.toFixed(3)}ms, source length: ${e.length}, result count: ${s.length}`),s},o=performance.now()-r;return o>20&&console.log(`parserFor: ${o.toFixed(3)}ms, rules count: ${i.length}`),(t,n)=>a(e(t),n)};export{n as parserFor};
+import { DURATION_DELAY_TRIGGER } from "./constants.mjs";
+import { normalizeWhitespace, qualifies } from "./utils.mjs";
+
+//#region src/markdown/parser.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
+*/
+const parserFor = (rules) => {
+	const start = performance.now();
+	const ruleList = Object.keys(rules);
+	ruleList.forEach((type) => {
+		const order = rules[type]._order;
+		if (typeof order !== "number" || !Number.isFinite(order)) console.warn(`intlayer: Invalid order for rule \`${type}\`: ${order}`);
+	});
+	ruleList.sort((a, b) => {
+		return rules[a]._order - rules[b]._order || (a < b ? -1 : 1);
+	});
+	const nestedParse = (source, state = {}) => {
+		const parseStart = performance.now();
+		const result = [];
+		state.prevCapture = state.prevCapture || "";
+		if (source.trim()) while (source) {
+			let i = 0;
+			while (i < ruleList.length) {
+				const ruleType = ruleList[i];
+				const rule = rules[ruleType];
+				if (rule._qualify && !qualifies(source, state, rule._qualify)) {
+					i++;
+					continue;
+				}
+				const matchStart = performance.now();
+				const capture = rule._match(source, state);
+				const matchDuration = performance.now() - matchStart;
+				if (matchDuration > 1) console.log(`${ruleType}._match: ${matchDuration.toFixed(3)}ms, source length: ${source.length}`);
+				if (capture?.[0]) {
+					source = source.substring(capture[0].length);
+					const ruleParseStart = performance.now();
+					const parsedAny = rule._parse(capture, nestedParse, state);
+					const ruleParseDuration = performance.now() - ruleParseStart;
+					if (ruleParseDuration > 1) console.log(`${ruleType}._parse: ${ruleParseDuration.toFixed(3)}ms, capture length: ${capture[0].length}`);
+					state.prevCapture = (state.prevCapture || "") + capture[0];
+					if (!parsedAny.type) parsedAny.type = ruleType;
+					result.push(parsedAny);
+					break;
+				}
+				i++;
+			}
+		}
+		const parseDuration = performance.now() - parseStart;
+		if (parseDuration > 1) console.log(`nestedParse: ${parseDuration.toFixed(3)}ms, source length: ${source.length}, result count: ${result.length}`);
+		return result;
+	};
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`parserFor: ${duration.toFixed(3)}ms, rules count: ${ruleList.length}`);
+	return (source, state) => nestedParse(normalizeWhitespace(source), state);
+};
+
+//#endregion
+export { parserFor };
 //# sourceMappingURL=parser.mjs.map

package/dist/esm/markdown/parser.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"parser.mjs","names":[],"sources":["../../../src/markdown/parser.ts"],"sourcesContent":["import { DURATION_DELAY_TRIGGER } from './constants';\nimport type { NestedParser, ParserResult, ParseState, Rules } from './types';\nimport { normalizeWhitespace, qualifies } from './utils';\n\n/**\n * Creates a parser for a given set of rules, with the precedence\n * specified as a list of rules.\n *\n * @param rules - An object containing rule type -> {match, order, parse} objects\n *                (lower order is higher precedence)\n *\n * @returns The resulting parse function\n */\nexport const parserFor = (\n  rules: Rules\n): ((source: string, state: ParseState) => ParserResult[]) => {\n  const start = performance.now();\n  const ruleList = Object.keys(rules);\n\n  if (process.env.NODE_ENV !== 'production') {\n    ruleList.forEach((type) => {\n      const order = rules[type]._order;\n      if (typeof order !== 'number' || !Number.isFinite(order)) {\n        console.warn(`intlayer: Invalid order for rule \\`${type}\\`: ${order}`);\n      }\n    });\n  }\n\n  // Sorts rules in order of increasing order, then\n  // ascending rule name in case of ties.\n  ruleList.sort((a, b) => {\n    return rules[a]._order - rules[b]._order || (a < b ? -1 : 1);\n  });\n\n  const nestedParse: NestedParser = (\n    source: string,\n    state: ParseState = {}\n  ): ParserResult[] => {\n    const parseStart = performance.now();\n    const result: ParserResult[] = [];\n    state.prevCapture = state.prevCapture || '';\n\n    if (source.trim()) {\n      while (source) {\n        let i = 0;\n        while (i < ruleList.length) {\n          const ruleType = ruleList[i];\n          const rule = rules[ruleType];\n\n          if (rule._qualify && !qualifies(source, state, rule._qualify)) {\n            i++;\n            continue;\n          }\n\n          const matchStart = performance.now();\n          const capture = rule._match(source, state);\n          const matchDuration = performance.now() - matchStart;\n\n          if (matchDuration > 1) {\n            console.log(\n              `${ruleType}._match: ${matchDuration.toFixed(3)}ms, source length: ${source.length}`\n            );\n          }\n\n          if (capture?.[0]) {\n            source = source.substring(capture[0].length);\n\n            const ruleParseStart = performance.now();\n            const parsedAny: any = rule._parse(capture, nestedParse, state);\n            const ruleParseDuration = performance.now() - ruleParseStart;\n\n            if (ruleParseDuration > 1) {\n              console.log(\n                `${ruleType}._parse: ${ruleParseDuration.toFixed(3)}ms, capture length: ${capture[0].length}`\n              );\n            }\n\n            state.prevCapture = (state.prevCapture || '') + capture[0];\n\n            if (!parsedAny.type) {\n              parsedAny.type = ruleType;\n            }\n            result.push(parsedAny as ParserResult);\n            break;\n          }\n          i++;\n        }\n      }\n    }\n\n    const parseDuration = performance.now() - parseStart;\n    if (parseDuration > 1) {\n      console.log(\n        `nestedParse: ${parseDuration.toFixed(3)}ms, source length: ${source.length}, result count: ${result.length}`\n      );\n    }\n\n    return result;\n  };\n\n  const duration = performance.now() - start;\n  if (duration > DURATION_DELAY_TRIGGER) {\n    console.log(\n      `parserFor: ${duration.toFixed(3)}ms, rules count: ${ruleList.length}`\n    );\n  }\n\n  return (source: string, state: ParseState) =>\n    nestedParse(normalizeWhitespace(source), state);\n};\n"],"mappings":"yFAaA,MAAa,EACX,GAC4D,CAC5D,IAAM,EAAQ,YAAY,KAAK,CACzB,EAAW,OAAO,KAAK,EAAM,CAanC,EAAS,MAAM,EAAG,IACT,EAAM,GAAG,OAAS,EAAM,GAAG,SAAW,EAAI,EAAI,GAAK,GAC1D,CAEF,IAAM,GACJ,EACA,EAAoB,EAAE,GACH,CACnB,IAAM,EAAa,YAAY,KAAK,CAC9B,EAAyB,EAAE,CAGjC,GAFA,EAAM,YAAc,EAAM,aAAe,GAErC,EAAO,MAAM,CACf,KAAO,GAAQ,CACb,IAAI,EAAI,EACR,KAAO,EAAI,EAAS,QAAQ,CAC1B,IAAM,EAAW,EAAS,GACpB,EAAO,EAAM,GAEnB,GAAI,EAAK,UAAY,CAAC,EAAU,EAAQ,EAAO,EAAK,SAAS,CAAE,CAC7D,IACA,SAGF,IAAM,EAAa,YAAY,KAAK,CAC9B,EAAU,EAAK,OAAO,EAAQ,EAAM,CACpC,EAAgB,YAAY,KAAK,CAAG,EAQ1C,GANI,EAAgB,GAClB,QAAQ,IACN,GAAG,EAAS,WAAW,EAAc,QAAQ,EAAE,CAAC,qBAAqB,EAAO,SAC7E,CAGC,IAAU,GAAI,CAChB,EAAS,EAAO,UAAU,EAAQ,GAAG,OAAO,CAE5C,IAAM,EAAiB,YAAY,KAAK,CAClC,EAAiB,EAAK,OAAO,EAAS,EAAa,EAAM,CACzD,EAAoB,YAAY,KAAK,CAAG,EAE1C,EAAoB,GACtB,QAAQ,IACN,GAAG,EAAS,WAAW,EAAkB,QAAQ,EAAE,CAAC,sBAAsB,EAAQ,GAAG,SACtF,CAGH,EAAM,aAAe,EAAM,aAAe,IAAM,EAAQ,GAExD,AACE,EAAU,OAAO,EAEnB,EAAO,KAAK,EAA0B,CACtC,MAEF,KAKN,IAAM,EAAgB,YAAY,KAAK,CAAG,EAO1C,OANI,EAAgB,GAClB,QAAQ,IACN,gBAAgB,EAAc,QAAQ,EAAE,CAAC,qBAAqB,EAAO,OAAO,kBAAkB,EAAO,SACtG,CAGI,GAGH,EAAW,YAAY,KAAK,CAAG,EAOrC,OANI,EAAA,IACF,QAAQ,IACN,cAAc,EAAS,QAAQ,EAAE,CAAC,mBAAmB,EAAS,SAC/D,EAGK,EAAgB,IACtB,EAAY,EAAoB,EAAO,CAAE,EAAM"}
+{"version":3,"file":"parser.mjs","names":[],"sources":["../../../src/markdown/parser.ts"],"sourcesContent":["import { DURATION_DELAY_TRIGGER } from './constants';\nimport type { NestedParser, ParserResult, ParseState, Rules } from './types';\nimport { normalizeWhitespace, qualifies } from './utils';\n\n/**\n * Creates a parser for a given set of rules, with the precedence\n * specified as a list of rules.\n *\n * @param rules - An object containing rule type -> {match, order, parse} objects\n *                (lower order is higher precedence)\n *\n * @returns The resulting parse function\n */\nexport const parserFor = (\n  rules: Rules\n): ((source: string, state: ParseState) => ParserResult[]) => {\n  const start = performance.now();\n  const ruleList = Object.keys(rules);\n\n  if (process.env.NODE_ENV !== 'production') {\n    ruleList.forEach((type) => {\n      const order = rules[type]._order;\n      if (typeof order !== 'number' || !Number.isFinite(order)) {\n        console.warn(`intlayer: Invalid order for rule \\`${type}\\`: ${order}`);\n      }\n    });\n  }\n\n  // Sorts rules in order of increasing order, then\n  // ascending rule name in case of ties.\n  ruleList.sort((a, b) => {\n    return rules[a]._order - rules[b]._order || (a < b ? -1 : 1);\n  });\n\n  const nestedParse: NestedParser = (\n    source: string,\n    state: ParseState = {}\n  ): ParserResult[] => {\n    const parseStart = performance.now();\n    const result: ParserResult[] = [];\n    state.prevCapture = state.prevCapture || '';\n\n    if (source.trim()) {\n      while (source) {\n        let i = 0;\n        while (i < ruleList.length) {\n          const ruleType = ruleList[i];\n          const rule = rules[ruleType];\n\n          if (rule._qualify && !qualifies(source, state, rule._qualify)) {\n            i++;\n            continue;\n          }\n\n          const matchStart = performance.now();\n          const capture = rule._match(source, state);\n          const matchDuration = performance.now() - matchStart;\n\n          if (matchDuration > 1) {\n            console.log(\n              `${ruleType}._match: ${matchDuration.toFixed(3)}ms, source length: ${source.length}`\n            );\n          }\n\n          if (capture?.[0]) {\n            source = source.substring(capture[0].length);\n\n            const ruleParseStart = performance.now();\n            const parsedAny: any = rule._parse(capture, nestedParse, state);\n            const ruleParseDuration = performance.now() - ruleParseStart;\n\n            if (ruleParseDuration > 1) {\n              console.log(\n                `${ruleType}._parse: ${ruleParseDuration.toFixed(3)}ms, capture length: ${capture[0].length}`\n              );\n            }\n\n            state.prevCapture = (state.prevCapture || '') + capture[0];\n\n            if (!parsedAny.type) {\n              parsedAny.type = ruleType;\n            }\n            result.push(parsedAny as ParserResult);\n            break;\n          }\n          i++;\n        }\n      }\n    }\n\n    const parseDuration = performance.now() - parseStart;\n    if (parseDuration > 1) {\n      console.log(\n        `nestedParse: ${parseDuration.toFixed(3)}ms, source length: ${source.length}, result count: ${result.length}`\n      );\n    }\n\n    return result;\n  };\n\n  const duration = performance.now() - start;\n  if (duration > DURATION_DELAY_TRIGGER) {\n    console.log(\n      `parserFor: ${duration.toFixed(3)}ms, rules count: ${ruleList.length}`\n    );\n  }\n\n  return (source: string, state: ParseState) =>\n    nestedParse(normalizeWhitespace(source), state);\n};\n"],"mappings":";;;;;;;;;;;;;AAaA,MAAa,aACX,UAC4D;CAC5D,MAAM,QAAQ,YAAY,KAAK;CAC/B,MAAM,WAAW,OAAO,KAAK,MAAM;AAGjC,UAAS,SAAS,SAAS;EACzB,MAAM,QAAQ,MAAM,MAAM;AAC1B,MAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,MAAM,CACtD,SAAQ,KAAK,sCAAsC,KAAK,MAAM,QAAQ;GAExE;AAKJ,UAAS,MAAM,GAAG,MAAM;AACtB,SAAO,MAAM,GAAG,SAAS,MAAM,GAAG,WAAW,IAAI,IAAI,KAAK;GAC1D;CAEF,MAAM,eACJ,QACA,QAAoB,EAAE,KACH;EACnB,MAAM,aAAa,YAAY,KAAK;EACpC,MAAM,SAAyB,EAAE;AACjC,QAAM,cAAc,MAAM,eAAe;AAEzC,MAAI,OAAO,MAAM,CACf,QAAO,QAAQ;GACb,IAAI,IAAI;AACR,UAAO,IAAI,SAAS,QAAQ;IAC1B,MAAM,WAAW,SAAS;IAC1B,MAAM,OAAO,MAAM;AAEnB,QAAI,KAAK,YAAY,CAAC,UAAU,QAAQ,OAAO,KAAK,SAAS,EAAE;AAC7D;AACA;;IAGF,MAAM,aAAa,YAAY,KAAK;IACpC,MAAM,UAAU,KAAK,OAAO,QAAQ,MAAM;IAC1C,MAAM,gBAAgB,YAAY,KAAK,GAAG;AAE1C,QAAI,gBAAgB,EAClB,SAAQ,IACN,GAAG,SAAS,WAAW,cAAc,QAAQ,EAAE,CAAC,qBAAqB,OAAO,SAC7E;AAGH,QAAI,UAAU,IAAI;AAChB,cAAS,OAAO,UAAU,QAAQ,GAAG,OAAO;KAE5C,MAAM,iBAAiB,YAAY,KAAK;KACxC,MAAM,YAAiB,KAAK,OAAO,SAAS,aAAa,MAAM;KAC/D,MAAM,oBAAoB,YAAY,KAAK,GAAG;AAE9C,SAAI,oBAAoB,EACtB,SAAQ,IACN,GAAG,SAAS,WAAW,kBAAkB,QAAQ,EAAE,CAAC,sBAAsB,QAAQ,GAAG,SACtF;AAGH,WAAM,eAAe,MAAM,eAAe,MAAM,QAAQ;AAExD,SAAI,CAAC,UAAU,KACb,WAAU,OAAO;AAEnB,YAAO,KAAK,UAA0B;AACtC;;AAEF;;;EAKN,MAAM,gBAAgB,YAAY,KAAK,GAAG;AAC1C,MAAI,gBAAgB,EAClB,SAAQ,IACN,gBAAgB,cAAc,QAAQ,EAAE,CAAC,qBAAqB,OAAO,OAAO,kBAAkB,OAAO,SACtG;AAGH,SAAO;;CAGT,MAAM,WAAW,YAAY,KAAK,GAAG;AACrC,KAAI,cACF,SAAQ,IACN,cAAc,SAAS,QAAQ,EAAE,CAAC,mBAAmB,SAAS,SAC/D;AAGH,SAAQ,QAAgB,UACtB,YAAY,oBAAoB,OAAO,EAAE,MAAM"}

package/dist/esm/markdown/renderer.mjs

@@ -1,2 +1,60 @@
-import"./constants.mjs";const e=t=>(n,r={})=>{let i=performance.now(),a=(n,r={})=>e(t)(n,r);if(Array.isArray(n)){let e=r.key,t=[],o=!1,s=0;for(let e=0;e<n.length;e++){let i=a(n[e],{...r,key:s}),c=typeof i==`string`;c&&o?t[t.length-1]=t[t.length-1]+i:i!==null&&(t.push(i),s++),o=c}r.key=e;let c=performance.now()-i;return c>20&&console.log(`renderFor (array): ${c.toFixed(3)}ms, ast length: ${n.length}`),t}let o=t(n,a,r),s=performance.now()-i;return s>20&&console.log(`renderFor (single): ${s.toFixed(3)}ms, ast type: ${n.type}`),o},t=(e,t)=>(n,r,i)=>{let a=performance.now(),o=e[n.type]?._render,s=t?t(()=>o?.(n,r,i),n,r,i):o?.(n,r,i),c=performance.now()-a;return c>20&&console.log(`createRenderer: ${c.toFixed(3)}ms, ast type: ${n.type}, hasUserRender: ${!!t}`),s};export{t as createRenderer,e as renderFor};
+import { DURATION_DELAY_TRIGGER } from "./constants.mjs";
+
+//#region src/markdown/renderer.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
+*/
+const renderFor = (render) => (ast, state = {}) => {
+	const start = performance.now();
+	const patchedRender = (ast, state = {}) => renderFor(render)(ast, state);
+	if (Array.isArray(ast)) {
+		const oldKey = state.key;
+		const result = [];
+		let lastWasString = false;
+		let renderedIndex = 0;
+		for (let i = 0; i < ast.length; i++) {
+			const nodeOut = patchedRender(ast[i], {
+				...state,
+				key: renderedIndex
+			});
+			const isString = typeof nodeOut === "string";
+			if (isString && lastWasString) result[result.length - 1] = result[result.length - 1] + nodeOut;
+			else if (nodeOut !== null) {
+				result.push(nodeOut);
+				renderedIndex++;
+			}
+			lastWasString = isString;
+		}
+		state.key = oldKey;
+		const duration = performance.now() - start;
+		if (duration > 20) console.log(`renderFor (array): ${duration.toFixed(3)}ms, ast length: ${ast.length}`);
+		return result;
+	}
+	const result = render(ast, patchedRender, state);
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`renderFor (single): ${duration.toFixed(3)}ms, ast type: ${ast.type}`);
+	return result;
+};
+/**
+* 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
+*/
+const createRenderer = (rules, userRender) => (ast, render, state) => {
+	const start = performance.now();
+	const renderer = rules[ast.type]?._render;
+	const result = userRender ? userRender(() => renderer?.(ast, render, state), ast, render, state) : renderer?.(ast, render, state);
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`createRenderer: ${duration.toFixed(3)}ms, ast type: ${ast.type}, hasUserRender: ${!!userRender}`);
+	return result;
+};
+
+//#endregion
+export { createRenderer, renderFor };
 //# sourceMappingURL=renderer.mjs.map

package/dist/esm/markdown/renderer.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.mjs","names":[],"sources":["../../../src/markdown/renderer.ts"],"sourcesContent":["import { DURATION_DELAY_TRIGGER } from './constants';\nimport type {\n  ParserResult,\n  ParseState,\n  RenderRuleHook,\n  RuleOutput,\n  Rules,\n} from './types';\n\n/**\n * Creates a renderer for AST nodes.\n * Renamed from `reactFor` to be framework-agnostic.\n *\n * @param render - The render function to call for each node\n * @returns A function that renders AST to output\n */\nexport const renderFor =\n  (\n    render: (\n      ast: ParserResult,\n      render: RuleOutput,\n      state: ParseState\n    ) => unknown\n  ) =>\n  (ast: ParserResult | ParserResult[], state: ParseState = {}): any => {\n    const start = performance.now();\n\n    const patchedRender = (\n      ast: ParserResult | ParserResult[],\n      state: ParseState = {}\n    ): any => renderFor(render)(ast, state);\n\n    if (Array.isArray(ast)) {\n      const oldKey = state.key;\n      const result: any[] = [];\n\n      // map nestedOutput over the ast, except group any text\n      // nodes together into a single string output.\n      let lastWasString = false;\n      let renderedIndex = 0;\n\n      for (let i = 0; i < ast.length; i++) {\n        // We clone the state to avoid side effects on other nodes in the same level\n        // while ensuring each non-null rendered node gets a unique, sequential key.\n        const nodeOut = patchedRender(ast[i], { ...state, key: renderedIndex });\n        const isString = typeof nodeOut === 'string';\n\n        if (isString && lastWasString) {\n          result[result.length - 1] =\n            (result[result.length - 1] as string) + nodeOut;\n        } else if (nodeOut !== null) {\n          result.push(nodeOut);\n          renderedIndex++;\n        }\n\n        lastWasString = isString;\n      }\n\n      state.key = oldKey;\n\n      const duration = performance.now() - start;\n      if (duration > DURATION_DELAY_TRIGGER) {\n        console.log(\n          `renderFor (array): ${duration.toFixed(3)}ms, ast length: ${ast.length}`\n        );\n      }\n\n      return result;\n    }\n\n    const result = render(ast, patchedRender as RuleOutput, state);\n\n    const duration = performance.now() - start;\n    if (duration > DURATION_DELAY_TRIGGER) {\n      console.log(\n        `renderFor (single): ${duration.toFixed(3)}ms, ast type: ${(ast as ParserResult).type}`\n      );\n    }\n\n    return result;\n  };\n\n/**\n * Creates a renderer from rules with optional custom render hook.\n *\n * @param rules - The rules object containing _render functions\n * @param userRender - Optional custom render hook for full control\n * @returns A render function for AST nodes\n */\nexport const createRenderer =\n  (rules: Rules, userRender?: RenderRuleHook) =>\n  (ast: ParserResult, render: RuleOutput, state: ParseState): unknown => {\n    const start = performance.now();\n    const renderer = rules[ast.type]?._render;\n\n    const result = userRender\n      ? userRender(() => renderer?.(ast, render, state), ast, render, state)\n      : renderer?.(ast, render, state);\n\n    const duration = performance.now() - start;\n    if (duration > DURATION_DELAY_TRIGGER) {\n      console.log(\n        `createRenderer: ${duration.toFixed(3)}ms, ast type: ${ast.type}, hasUserRender: ${!!userRender}`\n      );\n    }\n\n    return result;\n  };\n"],"mappings":"wBAgBA,MAAa,EAET,IAMD,EAAoC,EAAoB,EAAE,GAAU,CACnE,IAAM,EAAQ,YAAY,KAAK,CAEzB,GACJ,EACA,EAAoB,EAAE,GACd,EAAU,EAAO,CAAC,EAAK,EAAM,CAEvC,GAAI,MAAM,QAAQ,EAAI,CAAE,CACtB,IAAM,EAAS,EAAM,IACf,EAAgB,EAAE,CAIpB,EAAgB,GAChB,EAAgB,EAEpB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAI,OAAQ,IAAK,CAGnC,IAAM,EAAU,EAAc,EAAI,GAAI,CAAE,GAAG,EAAO,IAAK,EAAe,CAAC,CACjE,EAAW,OAAO,GAAY,SAEhC,GAAY,EACd,EAAO,EAAO,OAAS,GACpB,EAAO,EAAO,OAAS,GAAgB,EACjC,IAAY,OACrB,EAAO,KAAK,EAAQ,CACpB,KAGF,EAAgB,EAGlB,EAAM,IAAM,EAEZ,IAAM,EAAW,YAAY,KAAK,CAAG,EAOrC,OANI,EAAA,IACF,QAAQ,IACN,sBAAsB,EAAS,QAAQ,EAAE,CAAC,kBAAkB,EAAI,SACjE,CAGI,EAGT,IAAM,EAAS,EAAO,EAAK,EAA6B,EAAM,CAExD,EAAW,YAAY,KAAK,CAAG,EAOrC,OANI,EAAA,IACF,QAAQ,IACN,uBAAuB,EAAS,QAAQ,EAAE,CAAC,gBAAiB,EAAqB,OAClF,CAGI,GAUE,GACV,EAAc,KACd,EAAmB,EAAoB,IAA+B,CACrE,IAAM,EAAQ,YAAY,KAAK,CACzB,EAAW,EAAM,EAAI,OAAO,QAE5B,EAAS,EACX,MAAiB,IAAW,EAAK,EAAQ,EAAM,CAAE,EAAK,EAAQ,EAAM,CACpE,IAAW,EAAK,EAAQ,EAAM,CAE5B,EAAW,YAAY,KAAK,CAAG,EAOrC,OANI,EAAA,IACF,QAAQ,IACN,mBAAmB,EAAS,QAAQ,EAAE,CAAC,gBAAgB,EAAI,KAAK,mBAAmB,CAAC,CAAC,IACtF,CAGI"}
+{"version":3,"file":"renderer.mjs","names":[],"sources":["../../../src/markdown/renderer.ts"],"sourcesContent":["import { DURATION_DELAY_TRIGGER } from './constants';\nimport type {\n  ParserResult,\n  ParseState,\n  RenderRuleHook,\n  RuleOutput,\n  Rules,\n} from './types';\n\n/**\n * Creates a renderer for AST nodes.\n * Renamed from `reactFor` to be framework-agnostic.\n *\n * @param render - The render function to call for each node\n * @returns A function that renders AST to output\n */\nexport const renderFor =\n  (\n    render: (\n      ast: ParserResult,\n      render: RuleOutput,\n      state: ParseState\n    ) => unknown\n  ) =>\n  (ast: ParserResult | ParserResult[], state: ParseState = {}): any => {\n    const start = performance.now();\n\n    const patchedRender = (\n      ast: ParserResult | ParserResult[],\n      state: ParseState = {}\n    ): any => renderFor(render)(ast, state);\n\n    if (Array.isArray(ast)) {\n      const oldKey = state.key;\n      const result: any[] = [];\n\n      // map nestedOutput over the ast, except group any text\n      // nodes together into a single string output.\n      let lastWasString = false;\n      let renderedIndex = 0;\n\n      for (let i = 0; i < ast.length; i++) {\n        // We clone the state to avoid side effects on other nodes in the same level\n        // while ensuring each non-null rendered node gets a unique, sequential key.\n        const nodeOut = patchedRender(ast[i], { ...state, key: renderedIndex });\n        const isString = typeof nodeOut === 'string';\n\n        if (isString && lastWasString) {\n          result[result.length - 1] =\n            (result[result.length - 1] as string) + nodeOut;\n        } else if (nodeOut !== null) {\n          result.push(nodeOut);\n          renderedIndex++;\n        }\n\n        lastWasString = isString;\n      }\n\n      state.key = oldKey;\n\n      const duration = performance.now() - start;\n      if (duration > DURATION_DELAY_TRIGGER) {\n        console.log(\n          `renderFor (array): ${duration.toFixed(3)}ms, ast length: ${ast.length}`\n        );\n      }\n\n      return result;\n    }\n\n    const result = render(ast, patchedRender as RuleOutput, state);\n\n    const duration = performance.now() - start;\n    if (duration > DURATION_DELAY_TRIGGER) {\n      console.log(\n        `renderFor (single): ${duration.toFixed(3)}ms, ast type: ${(ast as ParserResult).type}`\n      );\n    }\n\n    return result;\n  };\n\n/**\n * Creates a renderer from rules with optional custom render hook.\n *\n * @param rules - The rules object containing _render functions\n * @param userRender - Optional custom render hook for full control\n * @returns A render function for AST nodes\n */\nexport const createRenderer =\n  (rules: Rules, userRender?: RenderRuleHook) =>\n  (ast: ParserResult, render: RuleOutput, state: ParseState): unknown => {\n    const start = performance.now();\n    const renderer = rules[ast.type]?._render;\n\n    const result = userRender\n      ? userRender(() => renderer?.(ast, render, state), ast, render, state)\n      : renderer?.(ast, render, state);\n\n    const duration = performance.now() - start;\n    if (duration > DURATION_DELAY_TRIGGER) {\n      console.log(\n        `createRenderer: ${duration.toFixed(3)}ms, ast type: ${ast.type}, hasUserRender: ${!!userRender}`\n      );\n    }\n\n    return result;\n  };\n"],"mappings":";;;;;;;;;;AAgBA,MAAa,aAET,YAMD,KAAoC,QAAoB,EAAE,KAAU;CACnE,MAAM,QAAQ,YAAY,KAAK;CAE/B,MAAM,iBACJ,KACA,QAAoB,EAAE,KACd,UAAU,OAAO,CAAC,KAAK,MAAM;AAEvC,KAAI,MAAM,QAAQ,IAAI,EAAE;EACtB,MAAM,SAAS,MAAM;EACrB,MAAM,SAAgB,EAAE;EAIxB,IAAI,gBAAgB;EACpB,IAAI,gBAAgB;AAEpB,OAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;GAGnC,MAAM,UAAU,cAAc,IAAI,IAAI;IAAE,GAAG;IAAO,KAAK;IAAe,CAAC;GACvE,MAAM,WAAW,OAAO,YAAY;AAEpC,OAAI,YAAY,cACd,QAAO,OAAO,SAAS,KACpB,OAAO,OAAO,SAAS,KAAgB;YACjC,YAAY,MAAM;AAC3B,WAAO,KAAK,QAAQ;AACpB;;AAGF,mBAAgB;;AAGlB,QAAM,MAAM;EAEZ,MAAM,WAAW,YAAY,KAAK,GAAG;AACrC,MAAI,cACF,SAAQ,IACN,sBAAsB,SAAS,QAAQ,EAAE,CAAC,kBAAkB,IAAI,SACjE;AAGH,SAAO;;CAGT,MAAM,SAAS,OAAO,KAAK,eAA6B,MAAM;CAE9D,MAAM,WAAW,YAAY,KAAK,GAAG;AACrC,KAAI,cACF,SAAQ,IACN,uBAAuB,SAAS,QAAQ,EAAE,CAAC,gBAAiB,IAAqB,OAClF;AAGH,QAAO;;;;;;;;;AAUX,MAAa,kBACV,OAAc,gBACd,KAAmB,QAAoB,UAA+B;CACrE,MAAM,QAAQ,YAAY,KAAK;CAC/B,MAAM,WAAW,MAAM,IAAI,OAAO;CAElC,MAAM,SAAS,aACX,iBAAiB,WAAW,KAAK,QAAQ,MAAM,EAAE,KAAK,QAAQ,MAAM,GACpE,WAAW,KAAK,QAAQ,MAAM;CAElC,MAAM,WAAW,YAAY,KAAK,GAAG;AACrC,KAAI,cACF,SAAQ,IACN,mBAAmB,SAAS,QAAQ,EAAE,CAAC,gBAAgB,IAAI,KAAK,mBAAmB,CAAC,CAAC,aACtF;AAGH,QAAO"}

package/dist/esm/markdown/utils.mjs

@@ -1,7 +1,362 @@
-import{ATTRIBUTES_TO_SANITIZE as e,CAPTURE_LETTER_AFTER_HYPHEN as t,CR_NEWLINE_R as n,FORMFEED_R as r,HTML_CUSTOM_ATTR_R as i,INTERPOLATION_R as a,TABLE_CENTER_ALIGN as o,TABLE_LEFT_ALIGN as s,TABLE_RIGHT_ALIGN as c,TABLE_TRIM_PIPES as l,TAB_R as u,UNESCAPE_R as d}from"./constants.mjs";const f=e=>{let t=e.length;for(;t>0&&e[t-1]<=` `;)t--;return e.slice(0,t)},p=(e,t)=>e.startsWith(t),m=e=>{let t=e[0];return(t===`"`||t===`'`)&&e.length>=2&&e[e.length-1]===t?e.slice(1,-1):e},h=e=>e&&e.replace(d,`$1`),g=(...e)=>e.filter(Boolean).join(` `),_=(e,t,n)=>{let r=e,i=t.split(`.`);for(;i.length&&(r=r[i[0]],r!==void 0);)i.shift();return r??n},v=e=>e.replace(/[ÀÁÂÃÄÅàáâãäåæÆ]/g,`a`).replace(/[çÇ]/g,`c`).replace(/[ðÐ]/g,`d`).replace(/[ÈÉÊËéèêë]/g,`e`).replace(/[ÏïÎîÍíÌì]/g,`i`).replace(/[Ññ]/g,`n`).replace(/[øØœŒÕõÔôÓóÒò]/g,`o`).replace(/[ÜüÛûÚúÙù]/g,`u`).replace(/[ŸÿÝý]/g,`y`).replace(/[^a-z0-9- ]/gi,``).replace(/ /gi,`-`).toLowerCase(),y=/(javascript|vbscript|data(?!:image)):/i,b=e=>{try{let t=decodeURIComponent(e).replace(/[^A-Za-z0-9/:]/g,``);if(y.test(t))return console.warn(`Input contains an unsafe JavaScript/VBScript/data expression, it will not be rendered.`,t),null}catch{return console.warn(`Input could not be decoded due to malformed syntax or characters, it will not be rendered.`,e),null}return e},x=e=>{let t=performance.now(),i=e.replace(n,`
-`).replace(r,``).replace(u,`    `),a=performance.now()-t;return a>20&&console.log(`normalizeWhitespace: ${a.toFixed(3)}ms, source length: ${e.length}`),i},S=(e,t)=>{let n=performance.now();if(!t)return e;let r=e.split(`
-`),i=!1,a=null,o=e=>e.match(/^\s*(`{3,}|~{3,})/),s=e=>{let t=o(e);if(!t)return;let n=t[1];i?a&&e.includes(a)&&(i=!1,a=null):(i=!0,a=n)},c=r.map(e=>{if(o(e)){let n=e.startsWith(t)?e.slice(t.length):e;return s(e),n}return i?e:e.startsWith(t)?e.slice(t.length):e}).join(`
-`),l=performance.now()-n;return l>20&&console.log(`trimLeadingWhitespaceOutsideFences: ${l.toFixed(3)}ms, text length: ${e.length}, lines count: ${r.length}`),c},C=e=>(e.indexOf(`-`)!==-1&&e.match(i)===null&&(e=e.replace(t,(e,t)=>t.toUpperCase())),e),w=e=>{let t=performance.now(),n=[],r=``,i=!1,a=!1,o=``;if(!e)return n;for(let t=0;t<e.length;t++){let s=e[t];if((s===`"`||s===`'`)&&!i&&(a?s===o&&(a=!1,o=``):(a=!0,o=s)),s===`(`&&r.endsWith(`url`)?i=!0:s===`)`&&i&&(i=!1),s===`;`&&!a&&!i){let e=r.trim();if(e){let t=e.indexOf(`:`);if(t>0){let r=e.slice(0,t).trim(),i=e.slice(t+1).trim();n.push([r,i])}}r=``}else r+=s}let s=r.trim();if(s){let e=s.indexOf(`:`);if(e>0){let t=s.slice(0,e).trim(),r=s.slice(e+1).trim();n.push([t,r])}}let c=performance.now()-t;return c>20&&console.log(`parseStyleAttribute: ${c.toFixed(3)}ms, styleString length: ${e.length}, styles count: ${n.length}`),n},T=(t,n,r,i)=>n===`style`?w(r).reduce((e,[n,r])=>{let a=n.replace(/(-[a-z])/g,e=>e[1].toUpperCase());return e[a]=i(r,t,n),e},{}):e.indexOf(n)===-1?(r.match(a)&&(r=h(r.slice(1,r.length-1))),r===`true`?!0:r===`false`?!1:r):i(h(r),t,n),E=e=>c.test(e)?`right`:o.test(e)?`center`:(s.test(e),`left`),D=e=>e.replace(l,``).split(`|`).map(E),O=(e,t,n,r)=>{let i=performance.now(),a=n.inTable;n.inTable=!0;let o=[[]],s=``,c=()=>{if(!s)return;let e=o[o.length-1];e.push.apply(e,t(s,n)),s=``};e.trim().split(/(`[^`]*`|\\\||\|)/).filter(Boolean).forEach((e,t,n)=>{if(e.trim()===`|`&&(c(),r)){t!==0&&t!==n.length-1&&o.push([]);return}s+=e}),c(),n.inTable=a;let l=performance.now()-i;return l>20&&console.log(`parseTableRow: ${l.toFixed(3)}ms, source length: ${e.length}, cells count: ${o.length}`),o},k=(e,t,n)=>{let r=performance.now(),i=e.trim().split(`
-`),a=i.map(e=>O(e,t,n,!0)),o=performance.now()-r;return o>20&&console.log(`parseTableCells: ${o.toFixed(3)}ms, source length: ${e.length}, rows count: ${i.length}`),a},A=(e,t,n)=>{if(Array.isArray(n)){for(let t=0;t<n.length;t++)if(p(e,n[t]))return!0;return!1}return n(e,t)},j=e=>(e.inline=1,e),M=e=>j((t,n)=>n.inline?e.exec(t):null),N=e=>j((t,n)=>n.inline||n.simple?e.exec(t):null),P=e=>(t,n)=>n.inline||n.simple?null:e.exec(t),F=e=>j((t,n)=>typeof e==`function`?e(t,n):e.exec(t)),I=(e,t,n)=>{let r=performance.now(),i=n.inline??!1,a=n.simple??!1;n.inline=!0,n.simple=!0;let o=e(t,n);n.inline=i,n.simple=a;let s=performance.now()-r;return s>20&&console.log(`parseInline: ${s.toFixed(3)}ms, children length: ${t.length}, result count: ${o.length}`),o},L=(e,t,n)=>{let r=performance.now(),i=n.inline??!1,a=n.simple??!1;n.inline=!1,n.simple=!0;let o=e(t,n);n.inline=i,n.simple=a;let s=performance.now()-r;return s>20&&console.log(`parseSimpleInline: ${s.toFixed(3)}ms, children length: ${t.length}, result count: ${o.length}`),o},R=(e,t,n={})=>{let r=performance.now(),i=n.inline||!1;n.inline=!1;let a=f(t),o=e(/\n\n$/.test(a)===!1?a.endsWith(`
-`)?`${a}\n`:`${a}\n\n`:a,n);n.inline=i;let s=performance.now()-r;return s>20&&console.log(`parseBlock: ${s.toFixed(3)}ms, children length: ${t.length}, result count: ${o.length}`),o},z=(e,t,n)=>({children:I(t,e[2],n)}),B=()=>({}),V=()=>null,H=(e,t)=>{for(let n=0;n<e.length;n++)if(e[n].test(t))return!0;return!1};export{j as allowInline,F as anyScopeRegex,T as attributeValueToNodePropValue,P as blockRegex,B as captureNothing,g as cx,_ as get,M as inlineRegex,C as normalizeAttributeKey,x as normalizeWhitespace,R as parseBlock,z as parseCaptureInline,I as parseInline,L as parseSimpleInline,w as parseStyleAttribute,D as parseTableAlign,E as parseTableAlignCapture,k as parseTableCells,O as parseTableRow,A as qualifies,V as renderNothing,b as sanitizer,N as simpleInlineRegex,v as slugify,H as some,p as startsWith,f as trimEnd,S as trimLeadingWhitespaceOutsideFences,h as unescapeString,m as unquote};
+import { ATTRIBUTES_TO_SANITIZE, CAPTURE_LETTER_AFTER_HYPHEN, CR_NEWLINE_R, DURATION_DELAY_TRIGGER, FORMFEED_R, HTML_CUSTOM_ATTR_R, INTERPOLATION_R, TABLE_CENTER_ALIGN, TABLE_LEFT_ALIGN, TABLE_RIGHT_ALIGN, TABLE_TRIM_PIPES, TAB_R, UNESCAPE_R } from "./constants.mjs";
+
+//#region src/markdown/utils.ts
+/**
+* Trim trailing whitespace from a string.
+*/
+const trimEnd = (str) => {
+	let end = str.length;
+	while (end > 0 && str[end - 1] <= " ") end--;
+	return str.slice(0, end);
+};
+/**
+* Check if string starts with prefix.
+*/
+const startsWith = (str, prefix) => {
+	return str.startsWith(prefix);
+};
+/**
+* Remove symmetrical leading and trailing quotes.
+*/
+const unquote = (str) => {
+	const first = str[0];
+	if ((first === "\"" || first === "'") && str.length >= 2 && str[str.length - 1] === first) return str.slice(1, -1);
+	return str;
+};
+/**
+* Unescape backslash-escaped characters.
+*/
+const unescapeString = (rawString) => rawString ? rawString.replace(UNESCAPE_R, "$1") : rawString;
+/**
+* Join class names, filtering out falsy values.
+*/
+const cx = (...args) => args.filter(Boolean).join(" ");
+/**
+* Get a nested property from an object using dot notation.
+*/
+const get = (src, path, fb) => {
+	let ptr = src;
+	const frags = path.split(".");
+	while (frags.length) {
+		ptr = ptr[frags[0]];
+		if (ptr === void 0) break;
+		else frags.shift();
+	}
+	return ptr ?? fb;
+};
+/**
+* Convert a string to a URL-safe slug.
+* Based on https://stackoverflow.com/a/18123682/1141611
+*/
+const slugify = (str) => str.replace(/[ÀÁÂÃÄÅàáâãäåæÆ]/g, "a").replace(/[çÇ]/g, "c").replace(/[ðÐ]/g, "d").replace(/[ÈÉÊËéèêë]/g, "e").replace(/[ÏïÎîÍíÌì]/g, "i").replace(/[Ññ]/g, "n").replace(/[øØœŒÕõÔôÓóÒò]/g, "o").replace(/[ÜüÛûÚúÙù]/g, "u").replace(/[ŸÿÝý]/g, "y").replace(/[^a-z0-9- ]/gi, "").replace(/ /gi, "-").toLowerCase();
+const SANITIZE_R = /(javascript|vbscript|data(?!:image)):/i;
+/**
+* Sanitize URLs to prevent XSS attacks.
+* Returns null if the URL is unsafe.
+*/
+const sanitizer = (input) => {
+	try {
+		const decoded = decodeURIComponent(input).replace(/[^A-Za-z0-9/:]/g, "");
+		if (SANITIZE_R.test(decoded)) {
+			console.warn("Input contains an unsafe JavaScript/VBScript/data expression, it will not be rendered.", decoded);
+			return null;
+		}
+	} catch (_e) {
+		console.warn("Input could not be decoded due to malformed syntax or characters, it will not be rendered.", input);
+		return null;
+	}
+	return input;
+};
+/**
+* Normalize whitespace in source string.
+*/
+const normalizeWhitespace = (source) => {
+	const start = performance.now();
+	const result = source.replace(CR_NEWLINE_R, "\n").replace(FORMFEED_R, "").replace(TAB_R, "    ");
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`normalizeWhitespace: ${duration.toFixed(3)}ms, source length: ${source.length}`);
+	return result;
+};
+/**
+* Safely remove a uniform leading indentation from lines, but do NOT touch
+* the content inside fenced code blocks (``` or ~~~).
+*/
+const trimLeadingWhitespaceOutsideFences = (text, whitespace) => {
+	const start = performance.now();
+	if (!whitespace) return text;
+	const lines = text.split("\n");
+	let inFence = false;
+	let fenceToken = null;
+	const isFenceLine = (line) => line.match(/^\s*(`{3,}|~{3,})/);
+	const maybeToggleFence = (line) => {
+		const m = isFenceLine(line);
+		if (!m) return;
+		const token = m[1];
+		if (!inFence) {
+			inFence = true;
+			fenceToken = token;
+		} else if (fenceToken && line.includes(fenceToken)) {
+			inFence = false;
+			fenceToken = null;
+		}
+	};
+	const result = lines.map((line) => {
+		if (isFenceLine(line)) {
+			const trimmedFenceLine = line.startsWith(whitespace) ? line.slice(whitespace.length) : line;
+			maybeToggleFence(line);
+			return trimmedFenceLine;
+		}
+		if (inFence) return line;
+		return line.startsWith(whitespace) ? line.slice(whitespace.length) : line;
+	}).join("\n");
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`trimLeadingWhitespaceOutsideFences: ${duration.toFixed(3)}ms, text length: ${text.length}, lines count: ${lines.length}`);
+	return result;
+};
+/**
+* Normalize HTML attribute key to JSX prop name.
+*/
+const normalizeAttributeKey = (key) => {
+	if (key.indexOf("-") !== -1 && key.match(HTML_CUSTOM_ATTR_R) === null) key = key.replace(CAPTURE_LETTER_AFTER_HYPHEN, (_, letter) => {
+		return letter.toUpperCase();
+	});
+	return key;
+};
+/**
+* Parse a CSS style string into an array of [key, value] tuples.
+*/
+const parseStyleAttribute = (styleString) => {
+	const start = performance.now();
+	const styles = [];
+	let buffer = "";
+	let inUrl = false;
+	let inQuotes = false;
+	let quoteChar = "";
+	if (!styleString) return styles;
+	for (let i = 0; i < styleString.length; i++) {
+		const char = styleString[i];
+		if ((char === "\"" || char === "'") && !inUrl) {
+			if (!inQuotes) {
+				inQuotes = true;
+				quoteChar = char;
+			} else if (char === quoteChar) {
+				inQuotes = false;
+				quoteChar = "";
+			}
+		}
+		if (char === "(" && buffer.endsWith("url")) inUrl = true;
+		else if (char === ")" && inUrl) inUrl = false;
+		if (char === ";" && !inQuotes && !inUrl) {
+			const declaration = buffer.trim();
+			if (declaration) {
+				const colonIndex = declaration.indexOf(":");
+				if (colonIndex > 0) {
+					const key = declaration.slice(0, colonIndex).trim();
+					const value = declaration.slice(colonIndex + 1).trim();
+					styles.push([key, value]);
+				}
+			}
+			buffer = "";
+		} else buffer += char;
+	}
+	const declaration = buffer.trim();
+	if (declaration) {
+		const colonIndex = declaration.indexOf(":");
+		if (colonIndex > 0) {
+			const key = declaration.slice(0, colonIndex).trim();
+			const value = declaration.slice(colonIndex + 1).trim();
+			styles.push([key, value]);
+		}
+	}
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`parseStyleAttribute: ${duration.toFixed(3)}ms, styleString length: ${styleString.length}, styles count: ${styles.length}`);
+	return styles;
+};
+/**
+* Convert an attribute value to a Node prop value.
+*/
+const attributeValueToNodePropValue = (tag, key, value, sanitizeUrlFn) => {
+	if (key === "style") return parseStyleAttribute(value).reduce((styles, [styleKey, styleValue]) => {
+		const camelCasedKey = styleKey.replace(/(-[a-z])/g, (substr) => substr[1].toUpperCase());
+		styles[camelCasedKey] = sanitizeUrlFn(styleValue, tag, styleKey);
+		return styles;
+	}, {});
+	else if (ATTRIBUTES_TO_SANITIZE.indexOf(key) !== -1) return sanitizeUrlFn(unescapeString(value), tag, key);
+	else if (value.match(INTERPOLATION_R)) value = unescapeString(value.slice(1, value.length - 1));
+	if (value === "true") return true;
+	else if (value === "false") return false;
+	return value;
+};
+/**
+* Parse table alignment from a separator row.
+*/
+const parseTableAlignCapture = (alignCapture) => {
+	if (TABLE_RIGHT_ALIGN.test(alignCapture)) return "right";
+	else if (TABLE_CENTER_ALIGN.test(alignCapture)) return "center";
+	else if (TABLE_LEFT_ALIGN.test(alignCapture)) return "left";
+	return "left";
+};
+/**
+* Parse table alignment row.
+*/
+const parseTableAlign = (source) => {
+	return source.replace(TABLE_TRIM_PIPES, "").split("|").map(parseTableAlignCapture);
+};
+/**
+* Parse a single table row.
+*/
+const parseTableRow = (source, parse, state, tableOutput) => {
+	const start = performance.now();
+	const prevInTable = state.inTable;
+	state.inTable = true;
+	const cells = [[]];
+	let acc = "";
+	const flush = () => {
+		if (!acc) return;
+		const cell = cells[cells.length - 1];
+		cell.push.apply(cell, parse(acc, state));
+		acc = "";
+	};
+	source.trim().split(/(`[^`]*`|\\\||\|)/).filter(Boolean).forEach((fragment, i, arr) => {
+		if (fragment.trim() === "|") {
+			flush();
+			if (tableOutput) {
+				if (i !== 0 && i !== arr.length - 1) cells.push([]);
+				return;
+			}
+		}
+		acc += fragment;
+	});
+	flush();
+	state.inTable = prevInTable;
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`parseTableRow: ${duration.toFixed(3)}ms, source length: ${source.length}, cells count: ${cells.length}`);
+	return cells;
+};
+/**
+* Parse table cells (multiple rows).
+*/
+const parseTableCells = (source, parse, state) => {
+	const start = performance.now();
+	const rowsText = source.trim().split("\n");
+	const result = rowsText.map((rowText) => parseTableRow(rowText, parse, state, true));
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`parseTableCells: ${duration.toFixed(3)}ms, source length: ${source.length}, rows count: ${rowsText.length}`);
+	return result;
+};
+/**
+* Check if a rule qualifies for the current source and state.
+*/
+const qualifies = (source, state, qualify) => {
+	if (Array.isArray(qualify)) {
+		for (let i = 0; i < qualify.length; i++) if (startsWith(source, qualify[i])) return true;
+		return false;
+	}
+	return qualify(source, state);
+};
+/**
+* Marks a matcher function as eligible for being run inside an inline context.
+*/
+const allowInline = (fn) => {
+	fn.inline = 1;
+	return fn;
+};
+/**
+* Creates a match function for an inline scoped element from a regex.
+*/
+const inlineRegex = (regex) => allowInline((source, state) => {
+	if (state.inline) return regex.exec(source);
+	else return null;
+});
+/**
+* Creates a match function for inline elements except links.
+*/
+const simpleInlineRegex = (regex) => allowInline((source, state) => {
+	if (state.inline || state.simple) return regex.exec(source);
+	else return null;
+});
+/**
+* Creates a match function for a block scoped element from a regex.
+*/
+const blockRegex = (regex) => (source, state) => {
+	if (state.inline || state.simple) return null;
+	else return regex.exec(source);
+};
+/**
+* Creates a match function from a regex, ignoring block/inline scope.
+*/
+const anyScopeRegex = (fn) => allowInline((source, state) => {
+	if (typeof fn === "function") return fn(source, state);
+	return fn.exec(source);
+});
+/**
+* Parse inline content (including links).
+*/
+const parseInline = (parse, children, state) => {
+	const start = performance.now();
+	const isCurrentlyInline = state.inline ?? false;
+	const isCurrentlySimple = state.simple ?? false;
+	state.inline = true;
+	state.simple = true;
+	const result = parse(children, state);
+	state.inline = isCurrentlyInline;
+	state.simple = isCurrentlySimple;
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`parseInline: ${duration.toFixed(3)}ms, children length: ${children.length}, result count: ${result.length}`);
+	return result;
+};
+/**
+* Parse simple inline content (no links).
+*/
+const parseSimpleInline = (parse, children, state) => {
+	const start = performance.now();
+	const isCurrentlyInline = state.inline ?? false;
+	const isCurrentlySimple = state.simple ?? false;
+	state.inline = false;
+	state.simple = true;
+	const result = parse(children, state);
+	state.inline = isCurrentlyInline;
+	state.simple = isCurrentlySimple;
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`parseSimpleInline: ${duration.toFixed(3)}ms, children length: ${children.length}, result count: ${result.length}`);
+	return result;
+};
+/**
+* Parse block content.
+*/
+const parseBlock = (parse, children, state = {}) => {
+	const start = performance.now();
+	const isCurrentlyInline = state.inline || false;
+	state.inline = false;
+	const normalizedChildren = trimEnd(children);
+	const result = parse(/\n\n$/.test(normalizedChildren) === false ? normalizedChildren.endsWith("\n") ? `${normalizedChildren}\n` : `${normalizedChildren}\n\n` : normalizedChildren, state);
+	state.inline = isCurrentlyInline;
+	const duration = performance.now() - start;
+	if (duration > 20) console.log(`parseBlock: ${duration.toFixed(3)}ms, children length: ${children.length}, result count: ${result.length}`);
+	return result;
+};
+/**
+* Helper to parse capture group 2 as inline content.
+*/
+const parseCaptureInline = (capture, parse, state) => {
+	return { children: parseInline(parse, capture[2], state) };
+};
+/**
+* Helper that captures nothing (empty object).
+*/
+const captureNothing = () => ({});
+/**
+* Helper that renders nothing (null).
+*/
+const renderNothing = () => null;
+/**
+* Check if any regex in a list matches the input.
+*/
+const some = (regexes, input) => {
+	for (let i = 0; i < regexes.length; i++) if (regexes[i].test(input)) return true;
+	return false;
+};
+
+//#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.mjs.map