@intlayer/core 9.4.4 → 9.5.1

package/dist/cjs/markdown/compiler.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_markdown_constants = require('./constants.cjs');
+const require_markdown_elementScanner = require('./elementScanner.cjs');
 const require_markdown_utils = require('./utils.cjs');
 const require_markdown_parser = require('./parser.cjs');
 const require_markdown_renderer = require('./renderer.cjs');
@@ -14,14 +15,6 @@ const LINK_R = new RegExp(`^\\[((?:\\[[^\\[\\]]*(?:\\[[^\\[\\]]*\\][^\\[\\]]*)*\
 * lowercase the whole remaining document to look its closing tag up — copying
 * the rest of the file on each probe.
 */
-const closingTagRegexCache = /* @__PURE__ */ new Map();
-const getClosingTagRegex = (tag) => {
-	const cached = closingTagRegexCache.get(tag);
-	if (cached) return cached;
-	const regex = new RegExp(`</${tag}>`, "i");
-	closingTagRegexCache.set(tag, regex);
-	return regex;
-};
 /**
 * Builds a tag -> component resolver for one set of overrides.
 *
@@ -30,10 +23,17 @@ const getClosingTagRegex = (tag) => {
 */
 const createTagResolver = (components) => {
 	let lowercaseKeys = null;
+	if (Object.keys(components).length === 0) return (tag) => tag;
+	const resolved = /* @__PURE__ */ new Map();
 	return (tag) => {
 		if (typeof tag !== "string") return tag;
+		const memoized = resolved.get(tag);
+		if (memoized !== void 0) return memoized;
 		const override = require_markdown_utils.get(components, tag);
-		if (override) return override;
+		if (override) {
+			resolved.set(tag, override);
+			return override;
+		}
 		if (!lowercaseKeys) {
 			lowercaseKeys = /* @__PURE__ */ new Map();
 			for (const key of Object.keys(components)) {
@@ -42,7 +42,9 @@ const createTagResolver = (components) => {
 			}
 		}
 		const key = lowercaseKeys.get(tag.toLowerCase());
-		return (key ? require_markdown_utils.get(components, key) : void 0) || tag;
+		const result = (key ? require_markdown_utils.get(components, key) : void 0) || tag;
+		resolved.set(tag, result);
+		return result;
 	};
 };
 /** Resolves the slugifier for a context, falling back to the built-in one. */
@@ -50,7 +52,7 @@ const createSlugger = (ctx) => (input) => ctx.slugify ? ctx.slugify(input, requi
 const createElementFactory = (ctx, options) => {
 	const { runtime, components = {} } = ctx;
 	const resolveTag = createTagResolver(components);
-	const filteredTags = options.tagfilter ? [
+	const filteredTags = options.tagfilter ? /* @__PURE__ */ new Set([
 		"title",
 		"textarea",
 		"style",
@@ -60,59 +62,211 @@ const createElementFactory = (ctx, options) => {
 		"noframes",
 		"script",
 		"plaintext"
-	] : [];
+	]) : null;
+	/**
+	* True when `props` can be handed to the runtime untouched: no `class`
+	* alias to fold into `className`, and no empty value to drop. Rules build a
+	* fresh literal for every element, so reusing it is safe, and it saves an
+	* object per element — the single largest allocation in the render phase.
+	*/
+	const needsPropsRewrite = (props) => {
+		if ("class" in props) return true;
+		for (const key in props) {
+			const value = props[key];
+			if (value === void 0 || value === null) return true;
+		}
+		return false;
+	};
 	return (tag, props, ...children) => {
-		if (typeof tag === "string" && filteredTags.includes(tag.toLowerCase())) return null;
 		const isStringTag = typeof tag === "string";
-		const className = require_markdown_utils.cx(props?.className, props?.class);
-		const mergedProps = {};
-		let classNameHandled = false;
-		if (props) for (const key in props) {
-			const value = props[key];
-			if (value === void 0 || value === null) continue;
-			if (key === "className" || key === "class") {
-				if (!classNameHandled) {
-					if (className) mergedProps.className = className;
-					classNameHandled = true;
-				}
-			} else mergedProps[key] = value;
+		if (filteredTags && isStringTag && (filteredTags.has(tag) || filteredTags.has(tag.toLowerCase()))) return null;
+		let finalProps;
+		if (!props) finalProps = {};
+		else if (!needsPropsRewrite(props)) finalProps = props;
+		else {
+			const className = require_markdown_utils.cx(props.className, props.class);
+			const mergedProps = {};
+			let classNameHandled = false;
+			for (const key in props) {
+				const value = props[key];
+				if (value === void 0 || value === null) continue;
+				if (key === "className" || key === "class") {
+					if (!classNameHandled) {
+						if (className) mergedProps.className = className;
+						classNameHandled = true;
+					}
+				} else mergedProps[key] = value;
+			}
+			if (!classNameHandled && className) mergedProps.className = className;
+			finalProps = mergedProps;
 		}
-		if (!classNameHandled && className) mergedProps.className = className;
-		let finalProps = mergedProps;
-		if (runtime.normalizeProps && isStringTag) finalProps = runtime.normalizeProps(tag, mergedProps);
+		if (runtime.normalizeProps && isStringTag) finalProps = runtime.normalizeProps(tag, finalProps);
 		const component = resolveTag(tag);
-		return runtime.createElement(component, finalProps, ...children.length === 1 ? [children[0]] : children);
+		return runtime.createElement(component, finalProps, ...children);
+	};
+};
+const createDocumentScope = () => ({
+	footnotes: [],
+	references: {}
+});
+/**
+* Small enough to scan linearly, large enough that an app mixing a few option
+* sets — say prose and a dictionary rendered with different components — keeps
+* hitting it.
+*/
+const RULE_SET_CACHE_LIMIT = 8;
+const ruleSetCache = [];
+/**
+* Every input that changes how rules are built. Compared directly rather than
+* through a signature array, which would allocate on every compile.
+*/
+const builtFromSame = (entry, ctx, options, parseOnly) => entry.parseOnly === parseOnly && entry.ctx.runtime === ctx.runtime && entry.ctx.components === ctx.components && entry.ctx.namedCodesToUnicode === ctx.namedCodesToUnicode && entry.ctx.sanitizer === ctx.sanitizer && entry.ctx.slugify === ctx.slugify && entry.options.disableAutoLink === options.disableAutoLink && entry.options.disableParsingRawHTML === options.disableParsingRawHTML && entry.options.enforceAtxHeadings === options.enforceAtxHeadings && entry.options.tagfilter === options.tagfilter && entry.options.renderRule === options.renderRule;
+/**
+* Returns the rule set for these options, building it only when no cached set
+* was made from the same inputs.
+*/
+const getRuleSet = (ctx, options, parseOnly) => {
+	for (let index = 0; index < ruleSetCache.length; index++) {
+		const entry = ruleSetCache[index];
+		if (!builtFromSame(entry, ctx, options, parseOnly)) continue;
+		if (index > 0) {
+			ruleSetCache.splice(index, 1);
+			ruleSetCache.unshift(entry);
+		}
+		return entry;
+	}
+	const scope = { current: createDocumentScope() };
+	const createElement = parseOnly ? noopCreateElement : createElementFactory(ctx, options);
+	const rules = createDocumentRules(createElement, ctx, options, scope);
+	const entry = {
+		ctx,
+		options,
+		parseOnly,
+		createElement,
+		scope,
+		parse: require_markdown_parser.parserFor(rules),
+		emit: require_markdown_renderer.renderFor(require_markdown_renderer.createRenderer(rules, options.renderRule))
 	};
+	ruleSetCache.unshift(entry);
+	if (ruleSetCache.length > RULE_SET_CACHE_LIMIT) ruleSetCache.pop();
+	return entry;
 };
-const createRules = (createElement, ctx, options, footnotes, refs, attrStringToMap, containsBlockSyntax, nonParagraphBlockSyntaxes) => {
+/**
+* Runs `operation` with `scope` installed as the current document, restoring
+* whatever was there before. The save/restore keeps a nested compile — a custom
+* component that renders markdown of its own — from clobbering its caller.
+*/
+const withDocumentScope = (ref, scope, operation) => {
+	const previous = ref.current;
+	ref.current = scope;
+	try {
+		return operation();
+	} finally {
+		ref.current = previous;
+	}
+};
+const createRules = (createElement, ctx, options, scope, attrStringToMap, containsBlockSyntax, nonParagraphBlockSyntaxes) => {
 	const slug = createSlugger(ctx);
 	const sanitize = ctx.sanitizer ?? require_markdown_utils.sanitizer;
 	const namedCodesToUnicode = ctx.namedCodesToUnicode ? {
 		...require_markdown_constants.NAMED_CODES_TO_UNICODE,
 		...ctx.namedCodesToUnicode
 	} : require_markdown_constants.NAMED_CODES_TO_UNICODE;
+	/**
+	* Raw HTML blocks and custom components differ only in how their tag is
+	* spelled: both trim the captured content, decide block or inline parsing
+	* from it, and render the tag with its attributes. `rawHtml` adds the two
+	* things only real HTML needs — the never-parse element list, and tracking
+	* whether we are inside an anchor.
+	*/
+	const pairedElementRule = (match, order, rawHtml, scope = require_markdown_constants.SCOPE_BOTH) => ({
+		_scope: scope,
+		_qualify: ["<"],
+		_match: require_markdown_utils.anyScopeRegex(match),
+		_order: order,
+		_parse(capture, parse, state) {
+			const content = capture[3] ?? "";
+			const whitespace = content.match(require_markdown_constants.HTML_LEFT_TRIM_AMOUNT_R)?.[1] ?? "";
+			const trimmed = require_markdown_utils.trimLeadingWhitespaceOutsideFences(content, whitespace);
+			const parseFunc = containsBlockSyntax(trimmed) ? require_markdown_utils.parseBlock : require_markdown_utils.parseInline;
+			const tagName = (capture[1] ?? "").trim();
+			const lowercased = tagName.toLowerCase();
+			const noInnerParse = rawHtml && require_markdown_constants.DO_NOT_PROCESS_HTML_ELEMENTS.indexOf(lowercased) !== -1;
+			const tag = noInnerParse ? lowercased : tagName;
+			const ast = {
+				attrs: attrStringToMap(tag, capture[2] ?? ""),
+				noInnerParse,
+				tag
+			};
+			if (rawHtml) state.inAnchor = state.inAnchor || lowercased === "a";
+			if (noInnerParse) ast.text = content;
+			else {
+				const prevInHTML = state.inHTML;
+				state.inHTML = true;
+				ast.children = parseFunc(parse, trimmed, state);
+				state.inHTML = prevInHTML;
+			}
+			if (rawHtml) state.inAnchor = false;
+			return ast;
+		},
+		_render(node, output, state = {}) {
+			return createElement(node.tag, {
+				key: state.key,
+				...node.attrs ?? {}
+			}, node.text ?? (node.children ? output(node.children, state) : ""));
+		}
+	});
 	const generateListRule = (type) => {
 		const ordered = type === 1;
 		const LIST_R = ordered ? require_markdown_constants.ORDERED_LIST_R : require_markdown_constants.UNORDERED_LIST_R;
 		const LIST_ITEM_R = ordered ? require_markdown_constants.ORDERED_LIST_ITEM_R : require_markdown_constants.UNORDERED_LIST_ITEM_R;
 		const LIST_ITEM_PREFIX_R = ordered ? require_markdown_constants.ORDERED_LIST_ITEM_PREFIX_R : require_markdown_constants.UNORDERED_LIST_ITEM_PREFIX_R;
 		return {
-			_qualify: (source) => LIST_ITEM_PREFIX_R.test(source),
+			_scope: require_markdown_constants.SCOPE_BOTH,
+			_firstChars: ordered ? [
+				32,
+				9,
+				48,
+				49,
+				50,
+				51,
+				52,
+				53,
+				54,
+				55,
+				56,
+				57
+			] : [
+				32,
+				9,
+				42,
+				43,
+				45
+			],
+			_qualify: (source, state) => state.prevCaptureIndent !== void 0 && Boolean(state.list ?? (!state.inline && !state.simple)) && LIST_ITEM_PREFIX_R.test(source),
 			_match: require_markdown_utils.allowInline((source, state) => {
 				const lineIndent = state.prevCaptureIndent;
 				const isStartOfLine = lineIndent !== void 0;
 				const isListAllowed = state.list ?? (!state.inline && !state.simple);
 				if (isStartOfLine && isListAllowed) {
 					const matchSource = lineIndent ? lineIndent + source : source;
-					return LIST_R.exec(matchSource);
+					const match = LIST_R.exec(matchSource);
+					if (!match) return null;
+					if (lineIndent && match[0].startsWith(lineIndent)) {
+						const adjusted = [...match];
+						adjusted[0] = match[0].slice(lineIndent.length);
+						adjusted.fullMatch = match[0];
+						return adjusted;
+					}
+					return match;
 				}
 				return null;
 			}),
 			_order: require_markdown_constants.Priority.HIGH,
 			_parse(capture, parse, state) {
-				const bullet = capture[2];
+				const bullet = capture[2] ?? "";
 				const startValue = ordered ? +bullet.slice(0, -1) : void 0;
-				const items = capture[0].replace(require_markdown_constants.BLOCK_END_R, "\n").match(LIST_ITEM_R);
+				const items = (capture.fullMatch ?? capture[0] ?? "").replace(require_markdown_constants.BLOCK_END_R, "\n").match(LIST_ITEM_R);
 				if (!items) return {
 					items: [],
 					ordered,
@@ -123,8 +277,8 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 					items: items.map((item, i) => {
 						const prefixCapture = LIST_ITEM_PREFIX_R.exec(item);
 						const space = prefixCapture ? prefixCapture[0].length : 0;
-						const spaceRegex = new RegExp(`^ {1,${space}}`, "gm");
-						const content = item.replace(spaceRegex, "").replace(LIST_ITEM_PREFIX_R, "");
+						const spaceRegex = space <= 8 ? STRIP_INDENT_REGEXES[space] : new RegExp(`^ {1,${space}}`, "gm");
+						const content = item.slice(space).replace(spaceRegex, "");
 						const isLastItem = i === items.length - 1;
 						const thisItemIsAParagraph = content.indexOf("\n\n") !== -1 || isLastItem && lastItemWasAParagraph;
 						lastItemWasAParagraph = thisItemIsAParagraph;
@@ -149,21 +303,33 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 				};
 			},
 			_render(node, output, state = {}) {
-				const Tag = node.ordered ? "ol" : "ul";
-				const props = { key: state.key };
-				if (node.ordered && node.start != null) props.start = node.start;
-				return createElement(Tag, props, ...node.items.map((item, i) => createElement("li", { key: i }, output(item, state))));
+				return createElement(ordered ? "ol" : "ul", {
+					key: state.key,
+					start: node.start
+				}, ...node.items.map((item, i) => createElement("li", { key: i }, output(item, state))));
 			}
 		};
 	};
 	const matchParagraph = (source, state) => {
 		if (state.inline || state.simple || state.inHTML && source.indexOf("\n\n") === -1 && !state.prevCaptureHasBlankLine) return null;
 		let start = 0;
-		while (true) {
+		const srcLen = source.length;
+		while (start < srcLen) {
 			const newlineIndex = source.indexOf("\n", start);
-			const line = source.slice(start, newlineIndex === -1 ? void 0 : newlineIndex + 1);
-			if (require_markdown_utils.some(nonParagraphBlockSyntaxes, line)) break;
-			if (newlineIndex === -1 || !line.trim()) break;
+			const lineEnd = newlineIndex === -1 ? srcLen : newlineIndex;
+			let p = start;
+			while (p < lineEnd && (source.charCodeAt(p) === 32 || source.charCodeAt(p) === 9)) p++;
+			if (p >= lineEnd) break;
+			if (p - start >= 4 || source.charCodeAt(start) === 9) break;
+			const ch = source.charCodeAt(p);
+			if (ch === 62 || ch === 96 || ch === 126 || ch === 35 || ch === 124 || ch === 42 || ch === 43 || ch === 45 || ch === 61 || ch === 60 || ch >= 48 && ch <= 57) {
+				const line = source.slice(start, newlineIndex === -1 ? void 0 : newlineIndex + 1);
+				if (require_markdown_utils.some(nonParagraphBlockSyntaxes, line)) break;
+			}
+			if (newlineIndex === -1) {
+				start = srcLen;
+				break;
+			}
 			start = newlineIndex + 1;
 		}
 		const match = source.slice(0, start);
@@ -178,11 +344,12 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 	};
 	return {
 		[require_markdown_constants.RuleType.blockQuote]: {
+			_scope: require_markdown_constants.SCOPE_BLOCK,
 			_qualify: [">"],
 			_match: require_markdown_utils.blockRegex(require_markdown_constants.BLOCKQUOTE_R),
 			_order: require_markdown_constants.Priority.HIGH,
 			_parse(capture, parse, state) {
-				const matchAlert = capture[0].replace(require_markdown_constants.BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, "").match(require_markdown_constants.BLOCKQUOTE_ALERT_R);
+				const matchAlert = (capture[0] ?? "").replace(require_markdown_constants.BLOCKQUOTE_TRIM_LEFT_MULTILINE_R, "").match(require_markdown_constants.BLOCKQUOTE_ALERT_R);
 				const alert = matchAlert?.[1];
 				const content = matchAlert?.[2] ?? "";
 				return {
@@ -209,6 +376,7 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			}
 		},
 		[require_markdown_constants.RuleType.breakLine]: {
+			_scope: require_markdown_constants.SCOPE_BOTH,
 			_qualify: ["  "],
 			_match: require_markdown_utils.anyScopeRegex(require_markdown_constants.BREAK_LINE_R),
 			_order: require_markdown_constants.Priority.HIGH,
@@ -218,6 +386,7 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			}
 		},
 		[require_markdown_constants.RuleType.breakThematic]: {
+			_scope: require_markdown_constants.SCOPE_BLOCK,
 			_qualify: [
 				"--",
 				"__",
@@ -234,6 +403,7 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			}
 		},
 		[require_markdown_constants.RuleType.codeBlock]: {
+			_scope: require_markdown_constants.SCOPE_BLOCK,
 			_qualify: ["    "],
 			_match: require_markdown_utils.blockRegex(require_markdown_constants.CODE_BLOCK_R),
 			_order: require_markdown_constants.Priority.MAX,
@@ -241,7 +411,7 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 				return {
 					type: require_markdown_constants.RuleType.codeBlock,
 					lang: void 0,
-					text: require_markdown_utils.unescapeString(require_markdown_utils.trimEnd(capture[0].replace(/^ {4}/gm, "")))
+					text: require_markdown_utils.unescapeString(require_markdown_utils.trimEnd((capture[0] ?? "").replace(/^ {4}/gm, "")))
 				};
 			},
 			_render(node, _, state = {}) {
@@ -252,6 +422,7 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			}
 		},
 		[require_markdown_constants.RuleType.codeFenced]: {
+			_scope: require_markdown_constants.SCOPE_BLOCK,
 			_qualify: ["```", "~~~"],
 			_match: require_markdown_utils.blockRegex(require_markdown_constants.CODE_BLOCK_FENCED_R),
 			_order: require_markdown_constants.Priority.MAX,
@@ -259,43 +430,48 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 				return {
 					attrs: attrStringToMap("code", capture[3] ?? ""),
 					lang: capture[2] || void 0,
-					text: capture[4],
+					text: capture[4] ?? "",
 					type: require_markdown_constants.RuleType.codeBlock
 				};
 			}
 		},
 		[require_markdown_constants.RuleType.codeInline]: {
-			_qualify: ["`"],
+			_scope: require_markdown_constants.SCOPE_INLINE,
+			_firstChars: [96],
+			_qualify: (source) => source.charCodeAt(0) === 96 && source.indexOf("`", 1) !== -1,
 			_match: require_markdown_utils.simpleInlineRegex(require_markdown_constants.CODE_INLINE_R),
 			_order: require_markdown_constants.Priority.LOW,
 			_parse(capture) {
-				return { text: require_markdown_utils.unescapeString(capture[2]) };
+				return { text: require_markdown_utils.unescapeString(capture[2] ?? "") };
 			},
 			_render(node, _, state = {}) {
 				return createElement("code", { key: state.key }, node.text);
 			}
 		},
 		[require_markdown_constants.RuleType.footnote]: {
+			_scope: require_markdown_constants.SCOPE_INLINE,
 			_qualify: ["[^"],
 			_match: require_markdown_utils.blockRegex(require_markdown_constants.FOOTNOTE_R),
 			_order: require_markdown_constants.Priority.MAX,
 			_parse(capture) {
-				footnotes.push({
-					footnote: capture[2],
-					identifier: capture[1]
+				scope.current.footnotes.push({
+					footnote: capture[2] ?? "",
+					identifier: capture[1] ?? ""
 				});
 				return {};
 			},
 			_render: require_markdown_utils.renderNothing
 		},
 		[require_markdown_constants.RuleType.footnoteReference]: {
+			_scope: require_markdown_constants.SCOPE_INLINE,
 			_qualify: ["[^"],
 			_match: require_markdown_utils.inlineRegex(require_markdown_constants.FOOTNOTE_REFERENCE_R),
 			_order: require_markdown_constants.Priority.HIGH,
 			_parse(capture) {
+				const text = capture[1] ?? "";
 				return {
-					target: `#${slug(capture[1])}`,
-					text: capture[1]
+					target: `#${slug(text)}`,
+					text
 				};
 			},
 			_render(node, _, state = {}) {
@@ -306,11 +482,12 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			}
 		},
 		[require_markdown_constants.RuleType.gfmTask]: {
+			_scope: require_markdown_constants.SCOPE_INLINE,
 			_qualify: ["[ ]", "[x]"],
 			_match: require_markdown_utils.inlineRegex(require_markdown_constants.GFM_TASK_R),
 			_order: require_markdown_constants.Priority.HIGH,
 			_parse(capture) {
-				return { completed: capture[1].toLowerCase() === "x" };
+				return { completed: (capture[1] ?? "").toLowerCase() === "x" };
 			},
 			_render(node, _, state = {}) {
 				return createElement("input", {
@@ -322,14 +499,16 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			}
 		},
 		[require_markdown_constants.RuleType.heading]: {
+			_scope: require_markdown_constants.SCOPE_BLOCK,
 			_qualify: ["#"],
 			_match: require_markdown_utils.blockRegex(options.enforceAtxHeadings ? require_markdown_constants.HEADING_ATX_COMPLIANT_R : require_markdown_constants.HEADING_R),
 			_order: require_markdown_constants.Priority.HIGH,
 			_parse(capture, parse, state) {
+				const text = capture[2] ?? "";
 				return {
-					children: require_markdown_utils.parseInline(parse, capture[2], state),
-					id: slug(capture[2]),
-					level: capture[1].length
+					children: require_markdown_utils.parseInline(parse, text, state),
+					id: slug(text),
+					level: capture[1]?.length ?? 1
 				};
 			},
 			_render(node, output, state = {}) {
@@ -340,7 +519,9 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			}
 		},
 		[require_markdown_constants.RuleType.headingSetext]: {
-			_qualify: (source) => {
+			_scope: require_markdown_constants.SCOPE_BLOCK,
+			_qualify: (source, state) => {
+				if (state.prevCaptureIndent === void 0 || state.inline || state.simple) return false;
 				const nlIndex = source.indexOf("\n");
 				return nlIndex > 0 && nlIndex < source.length - 1 && (source[nlIndex + 1] === "=" || source[nlIndex + 1] === "-");
 			},
@@ -348,52 +529,15 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			_order: require_markdown_constants.Priority.MAX,
 			_parse(capture, parse, state) {
 				return {
-					children: require_markdown_utils.parseInline(parse, capture[1], state),
+					children: require_markdown_utils.parseInline(parse, capture[1] ?? "", state),
 					level: capture[2] === "=" ? 1 : 2,
 					type: require_markdown_constants.RuleType.heading
 				};
 			}
 		},
-		[require_markdown_constants.RuleType.htmlBlock]: {
-			_qualify: (source) => {
-				if (options.disableParsingRawHTML) return false;
-				const match = require_markdown_constants.HTML_BLOCK_OPENING_TAG_R.exec(source);
-				if (!match) return false;
-				return getClosingTagRegex(match[1]).test(source);
-			},
-			_match: require_markdown_utils.anyScopeRegex(require_markdown_constants.HTML_BLOCK_ELEMENT_R),
-			_order: require_markdown_constants.Priority.HIGH,
-			_parse(capture, parse, state) {
-				const whitespace = capture[3].match(require_markdown_constants.HTML_LEFT_TRIM_AMOUNT_R)?.[1] ?? "";
-				const trimmed = require_markdown_utils.trimLeadingWhitespaceOutsideFences(capture[3], whitespace);
-				const parseFunc = containsBlockSyntax(trimmed) ? require_markdown_utils.parseBlock : require_markdown_utils.parseInline;
-				const tagName = capture[1].trim();
-				const noInnerParse = require_markdown_constants.DO_NOT_PROCESS_HTML_ELEMENTS.indexOf(tagName.toLowerCase()) !== -1;
-				const tag = noInnerParse ? tagName.toLowerCase() : tagName;
-				const ast = {
-					attrs: attrStringToMap(tag, capture[2] ?? ""),
-					noInnerParse,
-					tag
-				};
-				state.inAnchor = state.inAnchor || tagName.toLowerCase() === "a";
-				if (noInnerParse) ast.text = capture[3];
-				else {
-					const prevInHTML = state.inHTML;
-					state.inHTML = true;
-					ast.children = parseFunc(parse, trimmed, state);
-					state.inHTML = prevInHTML;
-				}
-				state.inAnchor = false;
-				return ast;
-			},
-			_render(node, output, state = {}) {
-				return createElement(node.tag, {
-					key: state.key,
-					...node.attrs ?? {}
-				}, node.text ?? (node.children ? output(node.children, state) : ""));
-			}
-		},
+		[require_markdown_constants.RuleType.htmlBlock]: pairedElementRule(require_markdown_elementScanner.matchHtmlBlockElement, require_markdown_constants.Priority.HIGH, true, require_markdown_constants.SCOPE_BOTH),
 		[require_markdown_constants.RuleType.htmlComment]: {
+			_scope: require_markdown_constants.SCOPE_BOTH,
 			_qualify: ["<!"],
 			_match: require_markdown_utils.anyScopeRegex(require_markdown_constants.HTML_COMMENT_R),
 			_order: require_markdown_constants.Priority.HIGH,
@@ -401,14 +545,12 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			_render: require_markdown_utils.renderNothing
 		},
 		[require_markdown_constants.RuleType.htmlSelfClosing]: {
-			_qualify: (source) => {
-				if (options.disableParsingRawHTML) return false;
-				return require_markdown_constants.HTML_SELF_CLOSING_OPENING_TAG_R.test(source);
-			},
-			_match: require_markdown_utils.anyScopeRegex(require_markdown_constants.HTML_SELF_CLOSING_ELEMENT_R),
+			_scope: require_markdown_constants.SCOPE_BOTH,
+			_qualify: ["<"],
+			_match: require_markdown_utils.anyScopeRegex(require_markdown_elementScanner.matchSelfClosingElement),
 			_order: require_markdown_constants.Priority.HIGH,
 			_parse(capture) {
-				const tag = capture[1].trim();
+				const tag = (capture[1] ?? "").trim();
 				return {
 					attrs: attrStringToMap(tag, capture[2] || ""),
 					tag
@@ -421,34 +563,10 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 				});
 			}
 		},
-		[require_markdown_constants.RuleType.customComponent]: {
-			_qualify: (source) => require_markdown_constants.CUSTOM_COMPONENT_OPENING_TAG_R.test(source),
-			_match: require_markdown_utils.anyScopeRegex(require_markdown_constants.CUSTOM_COMPONENT_R),
-			_order: require_markdown_constants.Priority.MAX,
-			_parse(capture, parse, state) {
-				const whitespace = capture[3].match(require_markdown_constants.HTML_LEFT_TRIM_AMOUNT_R)?.[1] ?? "";
-				const trimmed = require_markdown_utils.trimLeadingWhitespaceOutsideFences(capture[3], whitespace);
-				const parseFunc = containsBlockSyntax(trimmed) ? require_markdown_utils.parseBlock : require_markdown_utils.parseInline;
-				const tag = capture[1].trim();
-				const ast = {
-					attrs: attrStringToMap(tag, capture[2] ?? ""),
-					noInnerParse: false,
-					tag
-				};
-				const prevInHTML = state.inHTML;
-				state.inHTML = true;
-				ast.children = parseFunc(parse, trimmed, state);
-				state.inHTML = prevInHTML;
-				return ast;
-			},
-			_render(node, output, state = {}) {
-				return createElement(node.tag, {
-					key: state.key,
-					...node.attrs ?? {}
-				}, node.text ?? (node.children ? output(node.children, state) : ""));
-			}
-		},
+		[require_markdown_constants.RuleType.customComponent]: pairedElementRule(require_markdown_elementScanner.matchCustomComponent, require_markdown_constants.Priority.MAX, false, require_markdown_constants.SCOPE_BOTH),
 		[require_markdown_constants.RuleType.paragraph]: {
+			_scope: require_markdown_constants.SCOPE_BLOCK,
+			_qualify: (_source, state) => !state.inline && !state.simple,
 			_match: matchParagraph,
 			_order: require_markdown_constants.Priority.LOW,
 			_parse: require_markdown_utils.parseCaptureInline,
@@ -457,14 +575,16 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			}
 		},
 		[require_markdown_constants.RuleType.image]: {
-			_qualify: ["!["],
+			_scope: require_markdown_constants.SCOPE_INLINE,
+			_firstChars: [33],
+			_qualify: (source) => source.startsWith("![") && source.indexOf("](") !== -1,
 			_match: require_markdown_utils.simpleInlineRegex(IMAGE_R),
 			_order: require_markdown_constants.Priority.HIGH,
 			_parse(capture) {
 				return {
-					alt: require_markdown_utils.unescapeString(capture[1]),
-					target: require_markdown_utils.unescapeString(capture[2]),
-					title: require_markdown_utils.unescapeString(capture[3])
+					alt: require_markdown_utils.unescapeString(capture[1] ?? ""),
+					target: require_markdown_utils.unescapeString(capture[2] ?? ""),
+					title: capture[3] ? require_markdown_utils.unescapeString(capture[3]) : void 0
 				};
 			},
 			_render(node, _, state = {}) {
@@ -477,14 +597,16 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			}
 		},
 		[require_markdown_constants.RuleType.link]: {
-			_qualify: ["["],
+			_scope: require_markdown_constants.SCOPE_INLINE,
+			_firstChars: [91],
+			_qualify: (source) => source.charCodeAt(0) === 91 && source.indexOf("](") !== -1,
 			_match: require_markdown_utils.inlineRegex(LINK_R),
 			_order: require_markdown_constants.Priority.LOW,
 			_parse(capture, parse, state) {
 				return {
-					children: require_markdown_utils.parseSimpleInline(parse, capture[1], state),
-					target: require_markdown_utils.unescapeString(capture[2]),
-					title: require_markdown_utils.unescapeString(capture[3])
+					children: require_markdown_utils.parseSimpleInline(parse, capture[1] ?? "", state),
+					target: require_markdown_utils.unescapeString(capture[2] ?? ""),
+					title: capture[3] ? require_markdown_utils.unescapeString(capture[3]) : void 0
 				};
 			},
 			_render(node, output, state = {}) {
@@ -497,11 +619,12 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			}
 		},
 		[require_markdown_constants.RuleType.linkAngleBraceStyleDetector]: {
+			_scope: require_markdown_constants.SCOPE_INLINE,
 			_qualify: ["<"],
 			_match: require_markdown_utils.inlineRegex(require_markdown_constants.LINK_AUTOLINK_R),
 			_order: require_markdown_constants.Priority.MAX,
 			_parse(capture) {
-				let target = capture[1];
+				let target = capture[1] ?? "";
 				let isEmail = false;
 				if (target.indexOf("@") !== -1 && target.indexOf("//") === -1) {
 					isEmail = true;
@@ -518,21 +641,26 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			}
 		},
 		[require_markdown_constants.RuleType.linkBareUrlDetector]: {
-			_qualify: (source, state) => !!(state.inline && !state.inAnchor && !options.disableAutoLink && (require_markdown_utils.startsWith(source, "http://") || require_markdown_utils.startsWith(source, "https://"))),
+			_scope: require_markdown_constants.SCOPE_INLINE,
+			_firstChars: [104],
+			_qualify: (source, state) => Boolean(state.inline && !state.inAnchor && !options.disableAutoLink && (require_markdown_utils.startsWith(source, "http://") || require_markdown_utils.startsWith(source, "https://"))),
 			_match: require_markdown_utils.inlineRegex(require_markdown_constants.LINK_AUTOLINK_BARE_URL_R),
 			_order: require_markdown_constants.Priority.MAX,
 			_parse(capture) {
+				const url = capture[1] ?? "";
 				return {
 					children: [{
-						text: capture[1],
+						text: url,
 						type: require_markdown_constants.RuleType.text
 					}],
-					target: capture[1],
+					target: url,
 					type: require_markdown_constants.RuleType.link
 				};
 			}
 		},
 		[require_markdown_constants.RuleType.newlineCoalescer]: {
+			_scope: require_markdown_constants.SCOPE_BOTH,
+			_qualify: ["\n"],
 			_match: require_markdown_utils.blockRegex(require_markdown_constants.CONSECUTIVE_NEWLINE_R),
 			_order: require_markdown_constants.Priority.LOW,
 			_parse: require_markdown_utils.captureNothing,
@@ -543,12 +671,14 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 		[require_markdown_constants.RuleType.orderedList]: generateListRule(1),
 		[require_markdown_constants.RuleType.unorderedList]: generateListRule(2),
 		[require_markdown_constants.RuleType.ref]: {
+			_scope: require_markdown_constants.SCOPE_BOTH,
 			_qualify: ["["],
 			_match: require_markdown_utils.anyScopeRegex(require_markdown_constants.REFERENCE_IMAGE_OR_LINK),
 			_order: require_markdown_constants.Priority.MAX,
 			_parse(capture) {
-				refs[capture[1]] = {
-					target: capture[2],
+				const identifier = capture[1];
+				if (identifier !== void 0) scope.current.references[identifier] = {
+					target: capture[2] ?? "",
 					title: capture[4]
 				};
 				return {};
@@ -556,17 +686,19 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			_render: require_markdown_utils.renderNothing
 		},
 		[require_markdown_constants.RuleType.refImage]: {
-			_qualify: ["!["],
+			_scope: require_markdown_constants.SCOPE_INLINE,
+			_firstChars: [33],
+			_qualify: (source) => source.startsWith("![") && source.indexOf("](") === -1,
 			_match: require_markdown_utils.simpleInlineRegex(require_markdown_constants.REFERENCE_IMAGE_R),
 			_order: require_markdown_constants.Priority.MAX,
 			_parse(capture) {
 				return {
 					alt: capture[1] ? require_markdown_utils.unescapeString(capture[1]) : void 0,
-					ref: capture[2]
+					ref: capture[2] ?? ""
 				};
 			},
 			_render(node, _, state = {}) {
-				const ref = refs[node.ref];
+				const ref = scope.current.references[node.ref];
 				if (!ref) return null;
 				return createElement("img", {
 					key: state.key,
@@ -577,18 +709,20 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			}
 		},
 		[require_markdown_constants.RuleType.refLink]: {
-			_qualify: (source) => source[0] === "[" && source.indexOf("](") === -1,
+			_scope: require_markdown_constants.SCOPE_INLINE,
+			_firstChars: [91],
+			_qualify: (source) => source.indexOf("](") === -1,
 			_match: require_markdown_utils.inlineRegex(require_markdown_constants.REFERENCE_LINK_R),
 			_order: require_markdown_constants.Priority.MAX,
 			_parse(capture, parse, state) {
 				return {
-					children: require_markdown_utils.parseSimpleInline(parse, capture[1], state),
-					fallbackChildren: capture[0],
-					ref: capture[2]
+					children: require_markdown_utils.parseSimpleInline(parse, capture[1] ?? "", state),
+					fallbackChildren: capture[0] ?? "",
+					ref: capture[2] ?? ""
 				};
 			},
 			_render(node, output, state = {}) {
-				const ref = refs[node.ref];
+				const ref = scope.current.references[node.ref];
 				if (!ref) return createElement("span", { key: state.key }, node.fallbackChildren);
 				return createElement("a", {
 					key: state.key,
@@ -598,6 +732,7 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			}
 		},
 		[require_markdown_constants.RuleType.table]: {
+			_scope: require_markdown_constants.SCOPE_BLOCK,
 			_qualify: ["|"],
 			_match: require_markdown_utils.blockRegex(require_markdown_constants.NP_TABLE_R),
 			_order: require_markdown_constants.Priority.HIGH,
@@ -605,7 +740,7 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 				state.inline = true;
 				const align = capture[2] ? require_markdown_utils.parseTableAlign(capture[2]) : [];
 				const cells = capture[3] ? require_markdown_utils.parseTableCells(capture[3], parse, state) : [];
-				const header = require_markdown_utils.parseTableRow(capture[1], parse, state, !!cells.length);
+				const header = require_markdown_utils.parseTableRow(capture[1] ?? "", parse, state, !!cells.length);
 				state.inline = false;
 				return cells.length ? {
 					align,
@@ -620,17 +755,19 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			_render(node, output, state = {}) {
 				const table = node;
 				const getStyle = (i) => table.align[i] && table.align[i] !== "left" ? { textAlign: table.align[i] } : {};
-				return createElement("table", { key: state.key }, createElement("thead", null, createElement("tr", null, ...table.header.map((c, i) => createElement("th", {
+				return createElement("table", { key: state.key }, createElement("thead", { key: "thead" }, createElement("tr", null, ...table.header.map((c, i) => createElement("th", {
 					key: i,
 					style: getStyle(i)
-				}, output(c, state))))), createElement("tbody", null, ...table.cells.map((row, i) => createElement("tr", { key: i }, ...row.map((c, j) => createElement("td", {
+				}, output(c, state))))), createElement("tbody", { key: "tbody" }, ...table.cells.map((row, i) => createElement("tr", { key: i }, ...row.map((c, j) => createElement("td", {
 					key: j,
 					style: getStyle(j)
 				}, output(c, state)))))));
 			}
 		},
 		[require_markdown_constants.RuleType.tableSeparator]: {
-			_match: (source, state) => state.inTable && source[0] === "|" ? /^\|/.exec(source) : null,
+			_scope: require_markdown_constants.SCOPE_INLINE,
+			_qualify: ["|"],
+			_match: (source, state) => state.inTable ? /^\|/.exec(source) : null,
 			_order: require_markdown_constants.Priority.HIGH,
 			_parse() {
 				return { type: require_markdown_constants.RuleType.tableSeparator };
@@ -640,90 +777,180 @@ const createRules = (createElement, ctx, options, footnotes, refs, attrStringToM
 			}
 		},
 		[require_markdown_constants.RuleType.text]: {
+			_scope: require_markdown_constants.SCOPE_INLINE,
 			_match: require_markdown_utils.allowInline((source, _state) => {
-				const shortMatch = require_markdown_constants.SHORTCODE_R.exec(source);
-				if (shortMatch) return shortMatch;
-				return require_markdown_constants.TEXT_PLAIN_R.exec(source) || /^[\s\S]/.exec(source);
+				const len = source.length;
+				if (source.charCodeAt(0) === 10) {
+					let j = 1;
+					while (j < len && source.charCodeAt(j) === 32) j++;
+					if (j < len && (source.charCodeAt(j) === 42 || source.charCodeAt(j) === 43 || source.charCodeAt(j) === 45 || source.charCodeAt(j) >= 48 && source.charCodeAt(j) <= 57)) return [source.slice(0, j)];
+					return ["\n"];
+				}
+				if (source.charCodeAt(0) === 58) {
+					const shortMatch = require_markdown_constants.SHORTCODE_R.exec(source);
+					if (shortMatch) return shortMatch;
+				}
+				TEXT_RUN_R.lastIndex = 1;
+				TEXT_RUN_R.test(source);
+				TEXT_CAPTURE[0] = source.slice(0, trimHardBreak(source, TEXT_RUN_R.lastIndex));
+				return TEXT_CAPTURE;
 			}),
 			_order: require_markdown_constants.Priority.MIN,
 			_parse(capture) {
-				const text = capture[0];
-				return { text: text.indexOf("&") === -1 ? text : text.replace(require_markdown_constants.HTML_CHAR_CODE_R, (f, i) => {
-					if (i.startsWith("#x")) return String.fromCharCode(parseInt(i.slice(2), 16));
-					if (i.startsWith("#")) return String.fromCharCode(parseInt(i.slice(1), 10));
-					return namedCodesToUnicode[i] || f;
-				}) };
+				const text = capture[0] ?? "";
+				return {
+					type: require_markdown_constants.RuleType.text,
+					text: text.charCodeAt(0) !== 38 ? text : text.replace(require_markdown_constants.HTML_CHAR_CODE_R, (f, i) => {
+						if (i.startsWith("#x")) return String.fromCharCode(parseInt(i.slice(2), 16));
+						if (i.startsWith("#")) return String.fromCharCode(parseInt(i.slice(1), 10));
+						return namedCodesToUnicode[i] || f;
+					})
+				};
 			},
 			_render(node) {
 				return node.text;
 			}
 		},
 		[require_markdown_constants.RuleType.textBolded]: {
-			_qualify: ["**", "__"],
+			_scope: require_markdown_constants.SCOPE_INLINE,
+			_firstChars: [42, 95],
+			_qualify: (source) => {
+				const c = source.charCodeAt(0);
+				if (c === 42) {
+					const next = source.charCodeAt(2);
+					if (next === 32 || next === 10 || next === 9) return false;
+					return source.charCodeAt(1) === 42 && source.indexOf("**", 2) !== -1;
+				}
+				if (c === 95) {
+					const next = source.charCodeAt(2);
+					if (next === 32 || next === 10 || next === 9) return false;
+					return source.charCodeAt(1) === 95 && source.indexOf("__", 2) !== -1;
+				}
+				return false;
+			},
 			_match: require_markdown_utils.simpleInlineRegex(require_markdown_constants.TEXT_BOLD_R),
 			_order: require_markdown_constants.Priority.MED,
 			_parse(capture, parse, state) {
-				return { children: parse(capture[2], state) };
+				return { children: parse(capture[2] ?? "", state) };
 			},
 			_render(node, output, state = {}) {
 				return createElement("strong", { key: state.key }, output(node.children, state));
 			}
 		},
 		[require_markdown_constants.RuleType.textEmphasized]: {
-			_qualify: ["*", "_"],
+			_scope: require_markdown_constants.SCOPE_INLINE,
+			_firstChars: [42, 95],
+			_qualify: (source) => {
+				const c = source.charCodeAt(0);
+				const next = source.charCodeAt(1);
+				if (next === 32 || next === 10 || next === 9) return false;
+				return c === 42 && source.indexOf("*", 1) !== -1 || c === 95 && source.indexOf("_", 1) !== -1;
+			},
 			_match: require_markdown_utils.simpleInlineRegex(require_markdown_constants.TEXT_EMPHASIZED_R),
 			_order: require_markdown_constants.Priority.LOW,
 			_parse(capture, parse, state) {
-				return { children: parse(capture[2], state) };
+				return { children: parse(capture[2] ?? "", state) };
 			},
 			_render(node, output, state = {}) {
 				return createElement("em", { key: state.key }, output(node.children, state));
 			}
 		},
 		[require_markdown_constants.RuleType.textEscaped]: {
+			_scope: require_markdown_constants.SCOPE_INLINE,
 			_qualify: ["\\"],
 			_match: require_markdown_utils.simpleInlineRegex(require_markdown_constants.TEXT_ESCAPED_R),
 			_order: require_markdown_constants.Priority.HIGH,
 			_parse(capture) {
 				return {
-					text: capture[1],
+					text: capture[1] ?? "",
 					type: require_markdown_constants.RuleType.text
 				};
 			}
 		},
 		[require_markdown_constants.RuleType.textMarked]: {
-			_qualify: ["=="],
+			_scope: require_markdown_constants.SCOPE_INLINE,
+			_firstChars: [61],
+			_qualify: (source) => {
+				const next = source.charCodeAt(2);
+				if (next === 32 || next === 10 || next === 9) return false;
+				return source.charCodeAt(1) === 61 && source.indexOf("==", 2) !== -1;
+			},
 			_match: require_markdown_utils.simpleInlineRegex(require_markdown_constants.TEXT_MARKED_R),
 			_order: require_markdown_constants.Priority.LOW,
-			_parse: require_markdown_utils.parseCaptureInline,
+			_parse(capture, parse, state) {
+				return { children: require_markdown_utils.parseCaptureInline(capture, parse, state).children };
+			},
 			_render(node, output, state = {}) {
 				return createElement("mark", { key: state.key }, output(node.children, state));
 			}
 		},
 		[require_markdown_constants.RuleType.textStrikethroughed]: {
-			_qualify: ["~~"],
+			_scope: require_markdown_constants.SCOPE_INLINE,
+			_firstChars: [126],
+			_qualify: (source) => {
+				const next = source.charCodeAt(2);
+				if (next === 32 || next === 10 || next === 9) return false;
+				return source.charCodeAt(1) === 126 && source.indexOf("~~", 2) !== -1;
+			},
 			_match: require_markdown_utils.simpleInlineRegex(require_markdown_constants.TEXT_STRIKETHROUGHED_R),
 			_order: require_markdown_constants.Priority.LOW,
-			_parse: require_markdown_utils.parseCaptureInline,
+			_parse(capture, parse, state) {
+				return { children: require_markdown_utils.parseCaptureInline(capture, parse, state).children };
+			},
 			_render(node, output, state = {}) {
 				return createElement("del", { key: state.key }, output(node.children, state));
 			}
 		}
 	};
 };
+const STRIP_INDENT_REGEXES = [
+	null,
+	/^ {1,1}/gm,
+	/^ {1,2}/gm,
+	/^ {1,3}/gm,
+	/^ {1,4}/gm,
+	/^ {1,5}/gm,
+	/^ {1,6}/gm,
+	/^ {1,7}/gm,
+	/^ {1,8}/gm
+];
+/** Scratch capture reused by the text rule; see its `_match`. */
+const TEXT_CAPTURE = [""];
 /**
-* `createElement` is only ever reached from a rule's `_render`, so a parse-only
-* caller can hand over this stub instead of building an element factory.
+* Consumes a run of plain text, stopping before the next character that could
+* open another inline rule or a bare URL. Anchored so `test` leaves the stop
+* offset in `lastIndex` without allocating a match array, and so the scan
+* itself runs in the regex engine.
+*
+* The bare-URL guard is an alternation branch rather than a per-character
+* lookahead, because a lookahead is re-evaluated at every offset while this
+* branch is only reached on an `h`. `&` stops a run purely so that an HTML
+* entity can only ever sit at offset 0 of a text node; adjacent text nodes are
+* merged by the parser, so the tree is unchanged.
 */
-const noopCreateElement = () => null;
+const TEXT_RUN_R = /(?:[^\n&h!*:<=[\\_`~]+|h(?!ttp))*/y;
+/**
+* Pull a run's stop offset back before a hard line break it just swallowed.
+*
+* A run never contains a newline, so `  \n` can only sit immediately before the
+* stop offset — which makes this O(1) check equivalent to the per-character
+* `(?! {2}\n)` lookahead the run scanner used to carry.
+*/
+const trimHardBreak = (source, end) => end >= 3 && source.charCodeAt(end) === 10 && source.charCodeAt(end - 1) === 32 && source.charCodeAt(end - 2) === 32 ? end - 2 : end;
+const noopCreateElement = (type, props, ...children) => ({
+	children,
+	props,
+	type
+});
 /**
 * Builds the rule set backing one document.
 *
-* Rules close over the document's footnote and reference tables, so they cannot
-* be shared across documents — but a single document's parse and render phases
-* can share one set, which is what `compile` does.
+* Rules read the document's footnote and reference tables through `scope`
+* rather than closing over them, so one set serves every document sharing the
+* same options. Building this graph dominated the cost of compiling the many
+* short strings a dictionary holds; `getRuleSet` caches it.
 */
-const createDocumentRules = (createElement, ctx, options, footnotes, refs) => {
+const createDocumentRules = (createElement, ctx, options, scope) => {
 	const attrStringToMap = (tag, str) => {
 		if (!str?.trim()) return null;
 		const attributes = str.match(require_markdown_constants.ATTR_EXTRACTOR_R);
@@ -736,7 +963,7 @@ const createDocumentRules = (createElement, ctx, options, footnotes, refs) => {
 				const mappedKey = require_markdown_constants.ATTRIBUTE_TO_NODE_PROP_MAP[key] ?? key;
 				if (mappedKey === "ref") return map;
 				map[mappedKey] = require_markdown_utils.attributeValueToNodePropValue(tag, key, value, ctx.sanitizer ?? require_markdown_utils.sanitizer);
-				if (typeof map[mappedKey] === "string" && (require_markdown_constants.HTML_BLOCK_ELEMENT_R.test(map[mappedKey]) || require_markdown_constants.HTML_SELF_CLOSING_ELEMENT_R.test(map[mappedKey]))) map[mappedKey] = parseMarkdown(map[mappedKey].trim(), ctx, options).ast;
+				if (typeof map[mappedKey] === "string" && require_markdown_elementScanner.startsWithElement(map[mappedKey])) map[mappedKey] = parseMarkdown(map[mappedKey].trim(), ctx, options).ast;
 			} else if (raw !== "style") map[require_markdown_constants.ATTRIBUTE_TO_NODE_PROP_MAP[raw] ?? raw] = true;
 			return map;
 		}, {});
@@ -746,19 +973,18 @@ const createDocumentRules = (createElement, ctx, options, footnotes, refs) => {
 		require_markdown_constants.CODE_BLOCK_FENCED_R,
 		require_markdown_constants.CODE_BLOCK_R,
 		options.enforceAtxHeadings ? require_markdown_constants.HEADING_ATX_COMPLIANT_R : require_markdown_constants.HEADING_R,
-		require_markdown_constants.HEADING_SETEXT_R,
 		require_markdown_constants.NP_TABLE_R,
 		require_markdown_constants.ORDERED_LIST_R,
 		require_markdown_constants.UNORDERED_LIST_R,
-		require_markdown_constants.CUSTOM_COMPONENT_R
+		require_markdown_elementScanner.startsWithCustomComponent
 	];
 	const blockSyntaxes = options.disableParsingRawHTML ? nonParagraphBlockSyntaxes : [
 		...nonParagraphBlockSyntaxes,
 		require_markdown_constants.PARAGRAPH_R,
-		require_markdown_constants.HTML_BLOCK_ELEMENT_R,
+		require_markdown_elementScanner.startsWithHtmlBlockElement,
 		require_markdown_constants.HTML_COMMENT_R,
-		require_markdown_constants.HTML_SELF_CLOSING_ELEMENT_R,
-		require_markdown_constants.CUSTOM_COMPONENT_R
+		require_markdown_elementScanner.startsWithSelfClosingElement,
+		require_markdown_elementScanner.startsWithCustomComponent
 	];
 	const containsBlockSyntax = (input) => {
 		const cleaned = input.replace(require_markdown_constants.TRIM_STARTING_NEWLINES, "");
@@ -766,17 +992,16 @@ const createDocumentRules = (createElement, ctx, options, footnotes, refs) => {
 		if (slice.indexOf("\n\n") !== -1) return true;
 		return require_markdown_utils.some(blockSyntaxes, slice);
 	};
-	const baseRules = createRules(createElement, ctx, options, footnotes, refs, attrStringToMap, containsBlockSyntax, nonParagraphBlockSyntaxes);
+	const baseRules = createRules(createElement, ctx, options, scope, attrStringToMap, containsBlockSyntax, nonParagraphBlockSyntaxes);
 	return options.disableParsingRawHTML ? Object.keys(baseRules).reduce((acc, key) => {
 		if (key !== require_markdown_constants.RuleType.htmlBlock && key !== require_markdown_constants.RuleType.htmlSelfClosing) acc[key] = baseRules[key];
 		return acc;
 	}, {}) : baseRules;
 };
 /** Runs the parse phase against an already-built rule set. */
-const parseWithRules = (markdown, options, rules, footnotes, refs) => {
-	const parser = require_markdown_parser.parserFor(rules);
-	const result = options.preserveFrontmatter ? markdown : markdown.replace(require_markdown_constants.FRONT_MATTER_R, "");
-	const trimmedStart = result.replace(require_markdown_constants.TRIM_STARTING_NEWLINES, "");
+const parseWithRules = (markdown, options, parser, footnotes, refs) => {
+	const result = !options.preserveFrontmatter && markdown.charCodeAt(0) === 45 ? markdown.replace(require_markdown_constants.FRONT_MATTER_R, "") : markdown;
+	const trimmedStart = result.charCodeAt(0) === 10 ? result.replace(require_markdown_constants.TRIM_STARTING_NEWLINES, "") : result;
 	const inline = options.forceInline || !options.forceBlock && require_markdown_constants.SHOULD_RENDER_AS_BLOCK_R.test(trimmedStart) === false;
 	const ast = parser(inline ? result : `${require_markdown_utils.trimEnd(trimmedStart)}\n\n`, { inline });
 	if (footnotes.length > 0) for (const def of footnotes) def.parsedAst = parser(def.footnote, { inline: true });
@@ -788,11 +1013,10 @@ const parseWithRules = (markdown, options, rules, footnotes, refs) => {
 	};
 };
 /** Runs the render phase against an already-built rule set. */
-const renderWithRules = (parsed, ctx, options, rules, createElement) => {
+const renderWithRules = (parsed, ctx, options, emitter, createElement) => {
 	const components = ctx.components ?? {};
 	const slug = createSlugger(ctx);
 	const footnotes = parsed.footnotes || [];
-	const emitter = require_markdown_renderer.renderFor(require_markdown_renderer.createRenderer(rules, options.renderRule));
 	const inline = parsed.inline;
 	const arr = emitter(parsed.ast, { inline });
 	while (typeof arr[arr.length - 1] === "string" && !arr[arr.length - 1].trim()) arr.pop();
@@ -802,6 +1026,7 @@ const renderWithRules = (parsed, ctx, options, rules, createElement) => {
 		if (arr.length > 1 || options.forceWrapper) return createElement(wrapper, { key: "outer" }, arr);
 		if (arr.length === 1) {
 			const node = arr[0];
+			if (Array.isArray(node)) return createElement(wrapper, { key: "outer" }, node);
 			if (typeof node === "string") {
 				const spanProps = { key: "outer" };
 				if (!inline && components) {
@@ -827,27 +1052,29 @@ const renderWithRules = (parsed, ctx, options, rules, createElement) => {
 	}, def.identifier, emitter(def.parsedAst || def.footnote, { inline: true }))))) : node;
 };
 const parseMarkdown = (markdown = "", ctx, options = {}) => {
-	const footnotes = [];
-	const refs = {};
-	const rules = createDocumentRules(noopCreateElement, ctx, options, footnotes, refs);
-	return parseWithRules(markdown, options, rules, footnotes, refs);
+	const { parse, scope } = getRuleSet(ctx, options, true);
+	const documentScope = createDocumentScope();
+	return withDocumentScope(scope, documentScope, () => parseWithRules(markdown, options, parse, documentScope.footnotes, documentScope.references));
 };
 const renderMarkdownAst = (parsed, ctx, options = {}) => {
-	const createElement = createElementFactory(ctx, options);
-	const rules = createDocumentRules(createElement, ctx, options, parsed.footnotes ?? [], parsed.references ?? {});
-	return renderWithRules(parsed, ctx, options, rules, createElement);
+	const { emit, createElement, scope } = getRuleSet(ctx, options, false);
+	const documentScope = {
+		footnotes: parsed.footnotes ?? [],
+		references: parsed.references ?? {}
+	};
+	return withDocumentScope(scope, documentScope, () => renderWithRules(parsed, ctx, options, emit, createElement));
 };
 const compile = (markdown = "", ctx, options = {}) => {
 	if (typeof markdown !== "string") {
 		if (process.env.NODE_ENV !== "production") console.error("intlayer: the first argument must be a string. Received", typeof markdown);
 		throw new Error("intlayer: the first argument must be a string");
 	}
-	const footnotes = [];
-	const refs = {};
-	const createElement = createElementFactory(ctx, options);
-	const rules = createDocumentRules(createElement, ctx, options, footnotes, refs);
-	const parsed = parseWithRules(markdown, options, rules, footnotes, refs);
-	return renderWithRules(parsed, ctx, options, rules, createElement);
+	const { parse, emit, createElement, scope } = getRuleSet(ctx, options, false);
+	const documentScope = createDocumentScope();
+	return withDocumentScope(scope, documentScope, () => {
+		const parsed = parseWithRules(markdown, options, parse, documentScope.footnotes, documentScope.references);
+		return renderWithRules(parsed, ctx, options, emit, createElement);
+	});
 };
 const createCompiler = (ctx) => (markdown, options) => compile(markdown, ctx, options);
 const compileWithOptions = (markdown, runtime, options = {}) => {
@@ -865,6 +1092,7 @@ const compileWithOptions = (markdown, runtime, options = {}) => {
 exports.compile = compile;
 exports.compileWithOptions = compileWithOptions;
 exports.createCompiler = createCompiler;
+exports.getRuleSet = getRuleSet;
 exports.parseMarkdown = parseMarkdown;
 exports.renderMarkdownAst = renderMarkdownAst;
 //# sourceMappingURL=compiler.cjs.map