stream-markdown-parser 0.0.73 → 0.0.74

package/dist/index.js

@@ -601,7 +601,7 @@ var require_markdown_it_task_checkbox = /* @__PURE__ */ __commonJS({ "../../node
 }) });
 
 //#endregion
-//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.7/node_modules/markdown-it-ts/dist/chunk-Bp6m_JJh.js
+//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.9/node_modules/markdown-it-ts/dist/chunk-Bp6m_JJh.js
 var import_markdown_it_task_checkbox = /* @__PURE__ */ __toESM(require_markdown_it_task_checkbox(), 1);
 var __defProp = Object.defineProperty;
 var __export = (all) => {
@@ -2187,7 +2187,7 @@ var require_punycode = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/pu
 }) });
 
 //#endregion
-//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.7/node_modules/markdown-it-ts/dist/index.js
+//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.9/node_modules/markdown-it-ts/dist/index.js
 var import_punycode = /* @__PURE__ */ __toESM(require_punycode(), 1);
 var utils_exports = /* @__PURE__ */ __export({
 	arrayReplaceAt: () => arrayReplaceAt,
@@ -2445,10 +2445,23 @@ function parseLinkDestination(str, start, max) {
 	return result;
 }
 var parse_link_destination_default = parseLinkDestination;
-/**
-* Parse link label: returns the end position of label or -1 if not found
-* Assumes first character ([) already matches
-*/
+const FALLBACK_TO_INLINE_SCAN = -2;
+function scanPlainLinkLabel(src, start, max) {
+	let pos = start + 1;
+	while (pos < max) {
+		const marker = src.charCodeAt(pos);
+		if (marker === 93) return pos;
+		if (marker === 92) {
+			pos += 2;
+			continue;
+		}
+		if (marker === 96 || marker === 60) return FALLBACK_TO_INLINE_SCAN;
+		if (marker === 33 && pos + 1 < max && src.charCodeAt(pos + 1) === 91) return FALLBACK_TO_INLINE_SCAN;
+		if (marker === 91) return FALLBACK_TO_INLINE_SCAN;
+		pos++;
+	}
+	return -1;
+}
 function parseLinkLabel(state, start, disableNested) {
 	let level = 1;
 	let found = false;
@@ -2457,7 +2470,15 @@ function parseLinkLabel(state, start, disableNested) {
 	const src = state.src;
 	const max = state.posMax;
 	const oldPos = state.pos;
-	const inline$1 = state.md.inline;
+	const noCloseFrom = state.__mdtsLinkLabelNoCloseFrom;
+	if (typeof noCloseFrom === "number" && start + 1 >= noCloseFrom) return -1;
+	const nextClose = src.indexOf("]", start + 1);
+	if (nextClose < 0 || nextClose >= max) {
+		state.__mdtsLinkLabelNoCloseFrom = start + 1;
+		return -1;
+	}
+	const fastLabelEnd = scanPlainLinkLabel(src, start, max);
+	if (fastLabelEnd !== FALLBACK_TO_INLINE_SCAN) return fastLabelEnd;
 	state.pos = start + 1;
 	while (state.pos < max) {
 		marker = src.charCodeAt(state.pos);
@@ -2469,7 +2490,7 @@ function parseLinkLabel(state, start, disableNested) {
 			}
 		}
 		prevPos = state.pos;
-		inline$1.skipToken(state);
+		state.md.inline.skipToken(state);
 		if (marker === 91) {
 			if (prevPos === state.pos - 1) level++;
 			else if (disableNested) {
@@ -2600,6 +2621,12 @@ function normalizeLinkText(url) {
 	}
 	return decode_default(format(parsed), `${decode_default.defaultChars}%`);
 }
+function setStrategyDiagnostics(env, info) {
+	if (!env) return;
+	try {
+		env.__mdtsStrategyInfo = info;
+	} catch {}
+}
 /**
 * class Token
 *
@@ -2787,42 +2814,22 @@ function block(state) {
 /**
 * Process autolinks '<protocol:...>'
 */
-const EMAIL_RE = /^[\w.!#$%&'*+/=?^`{|}~-]+@[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$/i;
-function isAsciiLetter$2(ch) {
-	const lc = ch | 32;
-	return lc >= 97 && lc <= 122;
-}
-function isAutolinkScheme(src, start, end) {
-	const len = end - start;
-	if (len < 2 || len > 32 || !isAsciiLetter$2(src.charCodeAt(start))) return false;
-	for (let pos = start + 1; pos < end; pos++) {
-		const ch = src.charCodeAt(pos);
-		if (ch >= 48 && ch <= 57 || ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || ch === 43 || ch === 45 || ch === 46) continue;
-		return false;
-	}
-	return true;
-}
+const EMAIL_RE = /^([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/;
+const AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.-]{1,31}):([^<>\x00-\x20]*)$/;
 function autolink(state, silent) {
 	let pos = state.pos;
 	const src = state.src;
 	if (src.charCodeAt(pos) !== 60) return false;
 	const start = pos;
 	const max = state.posMax;
-	let colonPos = -1;
-	let hasAt = false;
 	for (;;) {
 		if (++pos >= max) return false;
 		const ch = src.charCodeAt(pos);
 		if (ch === 60) return false;
 		if (ch === 62) break;
-		if (ch <= 32) return false;
-		if (ch === 58) {
-			if (colonPos < 0) colonPos = pos;
-		} else if (ch === 64) hasAt = true;
-	}
-	if (colonPos < 0 && !hasAt) return false;
-	if (colonPos > start + 2 && isAutolinkScheme(src, start + 1, colonPos)) {
-		const url = src.slice(start + 1, pos);
+	}
+	const url = src.slice(start + 1, pos);
+	if (AUTOLINK_RE.test(url)) {
 		const fullUrl = state.md.normalizeLink(url);
 		if (!state.md.validateLink(fullUrl)) return false;
 		if (!silent) {
@@ -2830,18 +2837,16 @@ function autolink(state, silent) {
 			token_o.attrs = [["href", fullUrl]];
 			token_o.markup = "autolink";
 			token_o.info = "auto";
-			const token_t = state.pushSimple("text", "");
+			const token_t = state.push("text", "", 0);
 			token_t.content = state.md.normalizeLinkText(url);
 			const token_c = state.push("link_close", "a", -1);
 			token_c.markup = "autolink";
 			token_c.info = "auto";
 		}
-		state.pos = pos + 1;
+		state.pos += url.length + 2;
 		return true;
 	}
-	if (hasAt) {
-		const url = src.slice(start + 1, pos);
-		if (!EMAIL_RE.test(url)) return false;
+	if (EMAIL_RE.test(url)) {
 		const fullUrl = state.md.normalizeLink(`mailto:${url}`);
 		if (!state.md.validateLink(fullUrl)) return false;
 		if (!silent) {
@@ -2849,13 +2854,13 @@ function autolink(state, silent) {
 			token_o.attrs = [["href", fullUrl]];
 			token_o.markup = "autolink";
 			token_o.info = "auto";
-			const token_t = state.pushSimple("text", "");
+			const token_t = state.push("text", "", 0);
 			token_t.content = state.md.normalizeLinkText(url);
 			const token_c = state.push("link_close", "a", -1);
 			token_c.markup = "autolink";
 			token_c.info = "auto";
 		}
-		state.pos = pos + 1;
+		state.pos += url.length + 2;
 		return true;
 	}
 	return false;
@@ -3641,9 +3646,11 @@ var text_default = text;
 var InlineRuler = class {
 	rules = [];
 	cache = null;
+	namedCache = null;
 	version = 0;
 	invalidateCache() {
 		this.cache = null;
+		this.namedCache = null;
 		this.version++;
 	}
 	/**
@@ -3743,6 +3750,11 @@ var InlineRuler = class {
 		if (!this.cache) this.compileCache();
 		return this.cache.get(chain) ?? [];
 	}
+	getNamedRules(chainName) {
+		const chain = chainName || "";
+		if (!this.namedCache) this.compileCache();
+		return this.namedCache.get(chain) ?? [];
+	}
 	compileCache() {
 		const chains = new Set([""]);
 		for (const rule of this.rules) {
@@ -3750,16 +3762,24 @@ var InlineRuler = class {
 			if (rule.alt) for (const alt of rule.alt) chains.add(alt);
 		}
 		const cache = /* @__PURE__ */ new Map();
+		const namedCache = /* @__PURE__ */ new Map();
 		for (const chain of chains) {
 			const bucket = [];
+			const namedBucket = [];
 			for (const rule of this.rules) {
 				if (!rule.enabled) continue;
 				if (chain !== "" && !rule.alt?.includes(chain)) continue;
 				bucket.push(rule.fn);
+				namedBucket.push({
+					name: rule.name,
+					fn: rule.fn
+				});
 			}
 			cache.set(chain, bucket);
+			namedCache.set(chain, namedBucket);
 		}
 		this.cache = cache;
+		this.namedCache = namedCache;
 	}
 };
 /**
@@ -3871,6 +3891,78 @@ var StateInline = class {
 	}
 };
 StateInline.prototype.Token = Token;
+function now() {
+	if (typeof performance !== "undefined" && typeof performance.now === "function") return performance.now();
+	return Date.now();
+}
+function median(values) {
+	if (values.length === 0) return 0;
+	const sorted = values.slice().sort((a, b) => a - b);
+	const mid = Math.floor(sorted.length / 2);
+	return sorted.length % 2 === 0 ? (sorted[mid - 1] + sorted[mid]) / 2 : sorted[mid];
+}
+function createRecord(chain, name) {
+	return {
+		chain,
+		name,
+		calls: 0,
+		hits: 0,
+		inclusiveMs: 0,
+		medianMs: 0,
+		maxMs: 0,
+		normalCalls: 0,
+		normalHits: 0,
+		silentCalls: 0,
+		silentHits: 0,
+		samples: []
+	};
+}
+function getRuleProfile(env) {
+	const carrier = env;
+	if (!carrier) return null;
+	if (carrier.__mdtsRuleProfile) return carrier.__mdtsRuleProfile;
+	if (!carrier.__mdtsProfileRules) return null;
+	const meta = carrier.__mdtsProfileRules === true ? {} : carrier.__mdtsProfileRules;
+	const session = {
+		enabled: true,
+		fixture: meta.fixture,
+		mode: meta.mode,
+		startedAt: now(),
+		records: Object.create(null)
+	};
+	carrier.__mdtsRuleProfile = session;
+	return session;
+}
+function recordRuleInvocation(env, chain, name, durationMs, hit, silent) {
+	const session = getRuleProfile(env);
+	if (!session) return;
+	const key = `${chain}:${name}`;
+	const record = session.records[key] ?? (session.records[key] = createRecord(chain, name));
+	record.calls++;
+	record.inclusiveMs += durationMs;
+	if (durationMs > record.maxMs) record.maxMs = durationMs;
+	record.samples.push(durationMs);
+	if (silent) {
+		record.silentCalls++;
+		if (hit) record.silentHits++;
+	} else {
+		record.normalCalls++;
+		if (hit) record.normalHits++;
+	}
+	if (hit) record.hits++;
+	session.completedAt = now();
+}
+function finalizeRuleProfile(env) {
+	const session = getRuleProfile(env);
+	if (!session) return null;
+	const records = Object.keys(session.records);
+	for (let i = 0; i < records.length; i++) {
+		const record = session.records[records[i]];
+		record.medianMs = median(record.samples);
+	}
+	session.completedAt = now();
+	return session;
+}
 /**
 * ParserInline - inline parser with Ruler-based rule management
 */
@@ -3939,9 +4031,11 @@ var ParserInline = class {
 	skipToken(state) {
 		const pos = state.pos;
 		const rules = this.getRules();
+		const namedRules = this.ruler.getNamedRules("");
 		const len = rules.length;
 		const cache = state.cache;
 		const cached = cache[pos];
+		const shouldProfile = !!state.env && (Object.prototype.hasOwnProperty.call(state.env, "__mdtsRuleProfile") || Object.prototype.hasOwnProperty.call(state.env, "__mdtsProfileRules"));
 		if (cached !== void 0) {
 			state.pos = cached;
 			return;
@@ -3949,7 +4043,13 @@ var ParserInline = class {
 		let ok = false;
 		if (state.level < state.maxNesting) for (let i = 0; i < len; i++) {
 			state.level++;
-			ok = rules[i](state, true);
+			if (!shouldProfile) ok = rules[i](state, true);
+			else {
+				const startedAt = typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+				ok = namedRules[i].fn(state, true);
+				const endedAt = typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+				recordRuleInvocation(state.env, "inline", namedRules[i].name, endedAt - startedAt, !!ok, true);
+			}
 			state.level--;
 			if (ok) {
 				if (pos >= state.pos) throw new Error("inline rule didn't increment state.pos");
@@ -3965,13 +4065,21 @@ var ParserInline = class {
 	*/
 	tokenize(state) {
 		const rules = this.getRules();
+		const namedRules = this.ruler.getNamedRules("");
 		const len = rules.length;
 		const end = state.posMax;
+		const shouldProfile = !!state.env && (Object.prototype.hasOwnProperty.call(state.env, "__mdtsRuleProfile") || Object.prototype.hasOwnProperty.call(state.env, "__mdtsProfileRules"));
 		while (state.pos < end) {
 			const prevPos = state.pos;
 			let ok = false;
 			if (state.level < state.maxNesting) for (let i = 0; i < len; i++) {
-				ok = rules[i](state, false);
+				if (!shouldProfile) ok = rules[i](state, false);
+				else {
+					const startedAt = typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+					ok = namedRules[i].fn(state, false);
+					const endedAt = typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+					recordRuleInvocation(state.env, "inline", namedRules[i].name, endedAt - startedAt, !!ok, false);
+				}
 				if (ok) {
 					if (prevPos >= state.pos) throw new Error("inline rule didn't increment state.pos");
 					break;
@@ -4001,8 +4109,16 @@ var ParserInline = class {
 		const state = new StateInline(src, md, env, outTokens);
 		this.tokenize(state);
 		const rules2 = this.getRules2();
+		const namedRules2 = this.ruler2.getNamedRules("");
 		const len = rules2.length;
-		for (let i = 0; i < len; i++) rules2[i](state, false);
+		const shouldProfile = !!state.env && (Object.prototype.hasOwnProperty.call(state.env, "__mdtsRuleProfile") || Object.prototype.hasOwnProperty.call(state.env, "__mdtsProfileRules"));
+		for (let i = 0; i < len; i++) if (!shouldProfile) rules2[i](state, false);
+		else {
+			const startedAt = typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+			namedRules2[i].fn(state, false);
+			const endedAt = typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+			recordRuleInvocation(state.env, "inline2", namedRules2[i].name, endedAt - startedAt, true, false);
+		}
 	}
 	parse(str, md, env, outTokens) {
 		this.parseSource(str, md, env, outTokens);
@@ -4199,8 +4315,10 @@ function replacements(state) {
 var CoreRuler = class {
 	rules = [];
 	cache = null;
+	namedCache = null;
 	invalidateCache() {
 		this.cache = null;
+		this.namedCache = null;
 	}
 	push(name, fn) {
 		const idx = this.rules.findIndex((r) => r.name === name);
@@ -4290,11 +4408,19 @@ var CoreRuler = class {
 	}
 	compileCache() {
 		this.cache = this.rules.filter((r) => r.enabled).map((r) => r.fn);
+		this.namedCache = this.rules.filter((r) => r.enabled).map((r) => ({
+			name: r.name,
+			fn: r.fn
+		}));
 	}
 	getRules(_chainName = "") {
 		if (!this.cache) this.compileCache();
 		return this.cache;
 	}
+	getNamedRules(_chainName = "") {
+		if (!this.namedCache) this.compileCache();
+		return this.namedCache;
+	}
 };
 const QUOTE_TEST_RE = /['"]/;
 const QUOTE_RE = /['"]/g;
@@ -4449,7 +4575,7 @@ function blockquote(state, startLine, endLine, silent) {
 	const oldBSCount = [];
 	const oldSCount = [];
 	const oldTShift = [];
-	const terminatorRules = state.md.block.ruler.getRules("blockquote");
+	const terminatorRules = state.md.block.ruler.getRulesForState(state, "blockquote");
 	const oldParentType = state.parentType;
 	state.parentType = "blockquote";
 	let lastLineEmpty = false;
@@ -4839,19 +4965,46 @@ function html_block(state, startLine, endLine, silent) {
 	token.content = state.getLines(startLine, nextLine, state.blkIndent, true);
 	return true;
 }
+function hasPipeOnLine(src, start, max) {
+	for (let pos = start; pos < max; pos++) if (src.charCodeAt(pos) === 124) return true;
+	return false;
+}
+function canUseParagraphTerminatorFastPath(state) {
+	const ruler = state?.md?.block?.ruler;
+	if (!ruler) return false;
+	return ruler.version === ruler.__mdtsDefaultVersion;
+}
+function couldTerminateParagraph(src, start, max) {
+	if (start >= max) return false;
+	const marker = src.charCodeAt(start);
+	switch (marker) {
+		case 35:
+		case 42:
+		case 43:
+		case 45:
+		case 60:
+		case 62:
+		case 95:
+		case 96:
+		case 126: return true;
+	}
+	if (marker >= 48 && marker <= 57) return true;
+	return hasPipeOnLine(src, start, max);
+}
 const HEADING_TAGS = [
 	"",
 	"h1",
 	"h2"
 ];
 function lheading(state, startLine, endLine) {
-	const terminatorRules = state.md.block.ruler.getRules("paragraph");
+	const terminatorRules = state.md.block.ruler.getRulesForState(state, "paragraph");
 	const src = state.src;
 	const bMarks = state.bMarks;
 	const tShift = state.tShift;
 	const eMarks = state.eMarks;
 	const sCount = state.sCount;
 	const blkIndent = state.blkIndent;
+	const canUseFastTerminatorHint = canUseParagraphTerminatorFastPath(state);
 	if (sCount[startLine] - blkIndent >= 4) return false;
 	const oldParentType = state.parentType;
 	state.parentType = "paragraph";
@@ -4883,6 +5036,7 @@ function lheading(state, startLine, endLine) {
 			}
 		}
 		if (sCount[nextLine] < 0) continue;
+		if (canUseFastTerminatorHint && !couldTerminateParagraph(src, lineStart, max)) continue;
 		let terminate = false;
 		for (let i = 0, l = terminatorRules.length; i < l; i++) if (terminatorRules[i](state, nextLine, endLine, true)) {
 			terminate = true;
@@ -5054,7 +5208,7 @@ function list(state, startLine, endLine, silent) {
 	state.tokens[state.tokens.length - 1].markup = markerMarkup;
 	let prevEmptyEnd = false;
 	const listTokIdx = state.tokens.length - 1;
-	const terminatorRules = state.md.block.ruler.getRules("list");
+	const terminatorRules = state.md.block.ruler.getRulesForState(state, "list");
 	const oldParentType = state.parentType;
 	state.parentType = "list";
 	while (nextLine < endLine) {
@@ -5160,7 +5314,7 @@ function isSpace$3(code$1) {
 	return code$1 === 9 || code$1 === 32;
 }
 function paragraph(state, startLine, endLine) {
-	const terminatorRules = state.md.block.ruler.getRules("paragraph");
+	const terminatorRules = state.md.block.ruler.getRulesForState(state, "paragraph");
 	const oldParentType = state.parentType;
 	const src = state.src;
 	const bMarks = state.bMarks;
@@ -5168,34 +5322,35 @@ function paragraph(state, startLine, endLine) {
 	const eMarks = state.eMarks;
 	const sCount = state.sCount;
 	const blkIndent = state.blkIndent;
+	const canUseFastTerminatorHint = canUseParagraphTerminatorFastPath(state);
 	let nextLine = startLine + 1;
 	state.parentType = "paragraph";
 	for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
 		if (sCount[nextLine] - blkIndent > 3) continue;
 		if (sCount[nextLine] < 0) continue;
 		if (oldParentType === "list" && sCount[nextLine] >= blkIndent) {
-			const start = bMarks[nextLine] + tShift[nextLine];
-			const max = eMarks[nextLine];
-			if (start < max) {
-				const marker = src.charCodeAt(start);
+			const start$1 = bMarks[nextLine] + tShift[nextLine];
+			const max$1 = eMarks[nextLine];
+			if (start$1 < max$1) {
+				const marker = src.charCodeAt(start$1);
 				if (marker === 42 || marker === 45 || marker === 43) {
-					if (start + 1 >= max || isSpace$3(src.charCodeAt(start + 1))) break;
-				} else if (marker >= 48 && marker <= 57 && start + 1 < max) {
-					let pos = start + 1;
+					if (start$1 + 1 >= max$1 || isSpace$3(src.charCodeAt(start$1 + 1))) break;
+				} else if (marker >= 48 && marker <= 57 && start$1 + 1 < max$1) {
+					let pos = start$1 + 1;
 					for (;;) {
-						if (pos >= max) {
+						if (pos >= max$1) {
 							pos = -1;
 							break;
 						}
 						const ch = src.charCodeAt(pos++);
 						if (ch >= 48 && ch <= 57) {
-							if (pos - start >= 10) {
+							if (pos - start$1 >= 10) {
 								pos = -1;
 								break;
 							}
 							continue;
 						}
-						if ((ch === 41 || ch === 46) && (pos >= max || isSpace$3(src.charCodeAt(pos)))) break;
+						if ((ch === 41 || ch === 46) && (pos >= max$1 || isSpace$3(src.charCodeAt(pos)))) break;
 						pos = -1;
 						break;
 					}
@@ -5203,6 +5358,9 @@ function paragraph(state, startLine, endLine) {
 				}
 			}
 		}
+		const start = bMarks[nextLine] + tShift[nextLine];
+		const max = eMarks[nextLine];
+		if (canUseFastTerminatorHint && !couldTerminateParagraph(src, start, max)) continue;
 		let terminate = false;
 		for (let i = 0, l = terminatorRules.length; i < l; i++) if (terminatorRules[i](state, nextLine, endLine, true)) {
 			terminate = true;
@@ -5233,7 +5391,7 @@ function reference(state, startLine, _endLine, silent) {
 	let pos = state.bMarks[startLine] + state.tShift[startLine];
 	let max = state.eMarks[startLine];
 	let nextLine = startLine + 1;
-	const terminatorRules = state.md.block.ruler.getRules("reference");
+	const terminatorRules = state.md.block.ruler.getRulesForState(state, "reference");
 	if (state.sCount[startLine] - state.blkIndent >= 4) return false;
 	if (state.src.charCodeAt(pos) !== 91) return false;
 	function getNextLine(nextLine$1) {
@@ -5444,7 +5602,7 @@ function table(state, startLine, endLine, silent) {
 	if (silent) return true;
 	const oldParentType = state.parentType;
 	state.parentType = "table";
-	const terminatorRules = state.md.block.ruler.getRules("blockquote");
+	const terminatorRules = state.md.block.ruler.getRulesForState(state, "blockquote");
 	const token_to = state.push("table_open", "table", 1);
 	const tableLines = [startLine, 0];
 	token_to.map = tableLines;
@@ -5506,15 +5664,14 @@ function table(state, startLine, endLine, silent) {
 	state.line = nextLine;
 	return true;
 }
-/**
-* Block-level rule management with Ruler pattern
-*/
 var BlockRuler = class {
 	_rules = [];
 	cache = null;
+	namedCache = null;
 	version = 0;
 	invalidateCache() {
 		this.cache = null;
+		this.namedCache = null;
 		this.version++;
 	}
 	push(name, fn, options) {
@@ -5557,6 +5714,24 @@ var BlockRuler = class {
 		if (!this.cache) this.compileCache();
 		return this.cache[chain] ?? [];
 	}
+	getNamedRules(chainName) {
+		const chain = chainName || "";
+		if (!this.namedCache) this.compileCache();
+		return this.namedCache[chain] ?? [];
+	}
+	getRulesForState(state, chainName) {
+		const env = state?.env;
+		if (!(!!env && (Object.prototype.hasOwnProperty.call(env, "__mdtsRuleProfile") || Object.prototype.hasOwnProperty.call(env, "__mdtsProfileRules")))) return this.getRules(chainName);
+		return this.getNamedRules(chainName).map(({ name, fn }) => {
+			return (currentState, startLine, endLine, silent) => {
+				const startedAt = typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+				const ok = fn(currentState, startLine, endLine, silent);
+				const endedAt = typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+				recordRuleInvocation(currentState?.env, "block", name, endedAt - startedAt, ok, !!silent);
+				return ok;
+			};
+		});
+	}
 	at(name, fn, options) {
 		const index = this._rules.findIndex((r) => r.name === name);
 		if (index === -1) throw new Error(`Parser rule not found: ${name}`);
@@ -5617,16 +5792,24 @@ var BlockRuler = class {
 			for (const alt of rule.alt) chains.add(alt);
 		}
 		const cache = Object.create(null);
+		const namedCache = Object.create(null);
 		for (const chain of chains) {
 			const bucket = [];
+			const namedBucket = [];
 			for (const rule of this._rules) {
 				if (!rule.enabled) continue;
 				if (chain !== "" && !rule.alt.includes(chain)) continue;
 				bucket.push(rule.fn);
+				namedBucket.push({
+					name: rule.name,
+					fn: rule.fn
+				});
 			}
 			cache[chain] = bucket;
+			namedCache[chain] = namedBucket;
 		}
 		this.cache = cache;
+		this.namedCache = namedCache;
 	}
 };
 function isSpace(code$1) {
@@ -5871,12 +6054,14 @@ var ParserBlock = class {
 	constructor() {
 		this.ruler = new BlockRuler();
 		for (let i = 0; i < _rules.length; i++) this.ruler.push(_rules[i][0], _rules[i][1], { alt: (_rules[i][2] || []).slice() });
+		this.ruler.__mdtsDefaultVersion = this.ruler.version;
 	}
 	/**
 	* Generate tokens for input range
 	*/
 	tokenize(state, startLine, endLine) {
 		const rules = this.getRules();
+		const namedRules = this.ruler.getNamedRules("");
 		const len = rules.length;
 		const maxNesting = state.md.options.maxNesting;
 		const bMarks = state.bMarks;
@@ -5885,6 +6070,7 @@ var ParserBlock = class {
 		const sCount = state.sCount;
 		let line = startLine;
 		let hasEmptyLines = false;
+		const shouldProfile = !!state.env && (Object.prototype.hasOwnProperty.call(state.env, "__mdtsRuleProfile") || Object.prototype.hasOwnProperty.call(state.env, "__mdtsProfileRules"));
 		while (line < endLine) {
 			while (line < endLine && bMarks[line] + tShift[line] >= eMarks[line]) line++;
 			state.line = line;
@@ -5897,7 +6083,13 @@ var ParserBlock = class {
 			const prevLine = state.line;
 			let ok = false;
 			for (let i = 0; i < len; i++) {
-				ok = rules[i](state, line, endLine, false);
+				if (!shouldProfile) ok = rules[i](state, line, endLine, false);
+				else {
+					const startedAt = typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+					ok = namedRules[i].fn(state, line, endLine, false);
+					const endedAt = typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+					recordRuleInvocation(state.env, "block", namedRules[i].name, endedAt - startedAt, ok, false);
+				}
 				if (ok) {
 					if (prevLine >= state.line) throw new Error("block rule didn't increment state.line");
 					break;
@@ -6019,7 +6211,19 @@ var ParserCore = class {
 	}
 	process(state) {
 		const rules = this.cachedCoreRules ?? (this.cachedCoreRules = this.ruler.getRules(""));
-		for (let i = 0; i < rules.length; i++) rules[i](state);
+		const namedRules = this.ruler.getNamedRules("");
+		const shouldProfile = !!state.env && (Object.prototype.hasOwnProperty.call(state.env, "__mdtsRuleProfile") || Object.prototype.hasOwnProperty.call(state.env, "__mdtsProfileRules"));
+		for (let i = 0; i < rules.length; i++) {
+			if (!shouldProfile) {
+				rules[i](state);
+				continue;
+			}
+			const startedAt = typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+			namedRules[i].fn(state);
+			const endedAt = typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+			recordRuleInvocation(state.env, "core", namedRules[i].name, endedAt - startedAt, true, false);
+		}
+		finalizeRuleProfile(state.env);
 	}
 	parseSource(src, env = {}, md) {
 		if (typeof src !== "string" && hasNormalizationChars(src)) return this.parse(sourceToString(src), env, md);
@@ -7065,8 +7269,8 @@ const FULL_DISCRETE_RECOMMENDATIONS = [
 	{
 		max: 5e5,
 		strategy: "discrete",
-		maxChunkChars: 32e3,
-		maxChunkLines: 350,
+		maxChunkChars: 64e3,
+		maxChunkLines: 700,
 		maxChunks: 16,
 		notes: "<=500k"
 	},
@@ -7091,26 +7295,34 @@ const STREAM_DISCRETE_RECOMMENDATIONS = [
 	{
 		max: 2e4,
 		strategy: "discrete",
-		maxChunkChars: 16e3,
+		maxChunkChars: 2e4,
 		maxChunkLines: 200,
-		maxChunks: 12,
+		maxChunks: 24,
 		notes: "<=20k"
 	},
 	{
-		max: 5e4,
+		max: 1e5,
 		strategy: "discrete",
-		maxChunkChars: 16e3,
-		maxChunkLines: 250,
-		maxChunks: 12,
-		notes: "<=50k"
+		maxChunkChars: 2e4,
+		maxChunkLines: 200,
+		maxChunks: 24,
+		notes: "<=100k"
 	},
 	{
 		max: 5e5,
 		strategy: "discrete",
-		maxChunkChars: 32e3,
-		maxChunkLines: 350,
-		maxChunks: 16,
+		maxChunkChars: 64e3,
+		maxChunkLines: 700,
+		maxChunks: 32,
 		notes: "<=500k"
+	},
+	{
+		max: 5e6,
+		strategy: "discrete",
+		maxChunkChars: 64e3,
+		maxChunkLines: 700,
+		maxChunks: 32,
+		notes: "<=5M"
 	}
 ];
 function toRecommendation(fenceAware, discrete) {
@@ -7166,10 +7378,10 @@ function recommendStreamChunkStrategy(sizeChars, sizeLines = Math.max(0, sizeCha
 			break;
 		}
 	}
-	if (sizeChars > 5e5) return {
+	if (sizeChars > 5e6) return {
 		strategy: "plain",
 		fenceAware,
-		notes: ">500k plain"
+		notes: ">5M plain"
 	};
 	if (adaptive) return {
 		strategy: "adaptive",
@@ -7584,6 +7796,7 @@ function makeEmptyStats() {
 		total: 0,
 		cacheHits: 0,
 		appendHits: 0,
+		unboundedAppendHits: 0,
 		tailHits: 0,
 		fullParses: 0,
 		resets: 0,
@@ -7596,12 +7809,16 @@ var StreamParser = class {
 	cache = null;
 	stats = makeEmptyStats();
 	MIN_SIZE_FOR_OPTIMIZATION = 1e3;
-	DEFAULT_SKIP_CACHE_CHARS = 6e5;
-	DEFAULT_SKIP_CACHE_LINES = 1e4;
+	DEFAULT_SKIP_CACHE_CHARS = 1e6;
+	DEFAULT_SKIP_CACHE_LINES = 1e5;
+	IMPLICIT_STREAM_CHUNK_MIN_CHARS = 16e4;
 	MIN_LIST_LINES_FOR_MERGE = 80;
 	MIN_LIST_CHARS_FOR_MERGE = 800;
 	MIN_TABLE_LINES_FOR_MERGE = 48;
 	MIN_TABLE_CHARS_FOR_MERGE = 1200;
+	MIN_UNBOUNDED_APPEND_TOTAL_CHARS = 5e5;
+	MIN_UNBOUNDED_APPEND_CHARS = 64e3;
+	MIN_UNBOUNDED_APPEND_LINES = 700;
 	constructor(core) {
 		this.core = core;
 	}
@@ -7620,7 +7837,10 @@ var StreamParser = class {
 		const cached = this.cache;
 		if (!cached || envProvided && envProvided !== cached.env) {
 			const workingEnv = envProvided ?? {};
-			const chunkedEnabled$1 = !!md.options?.streamChunkedFallback;
+			const explicitChunkFallbackSetting$1 = !!md.__explicitStreamChunkFallbackSetting;
+			const wantsChunking$1 = !!md.options?.streamChunkedFallback;
+			const allowImplicitChunk$1 = !explicitChunkFallbackSetting$1;
+			const chunkedEnabled$1 = wantsChunking$1 || allowImplicitChunk$1;
 			const chunkAdaptive$1 = md.options?.streamChunkAdaptive !== false;
 			const targetChunks$1 = md.options?.streamChunkTargetChunks ?? 8;
 			const chunkSizeCharsCfg$1 = md.options?.streamChunkSizeChars;
@@ -7642,6 +7862,12 @@ var StreamParser = class {
 				this.stats.total += 1;
 				this.stats.fullParses += 1;
 				this.stats.lastMode = "full";
+				setStrategyDiagnostics(workingEnv, {
+					area: "stream",
+					path: "stream-full",
+					reason: "skip-cache-large-one-shot",
+					unbounded: !!workingEnv.__mdtsUnboundedInfo
+				});
 				return parsed$2.tokens;
 			} else if (chunkedEnabled$1) {
 				const clamp$1 = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
@@ -7651,7 +7877,8 @@ var StreamParser = class {
 				const useLines = recommendation?.maxChunkLines ?? (chunkAdaptive$1 ? clamp$1(Math.ceil(srcLineCount / targetChunks$1), 150, 700) : chunkSizeLinesCfg$1 ?? 200);
 				const useMaxChunks = recommendation?.maxChunks ?? (chunkAdaptive$1 ? clamp$1(Math.ceil(src.length / 64e3), targetChunks$1, 32) : chunkMaxChunksCfg$1);
 				const hasTrailingNewline = src.length > 0 && src.charCodeAt(src.length - 1) === 10;
-				if (recommendation?.strategy !== "plain" && (src.length >= useChars * 2 || srcLineCount >= useLines * 2) && hasTrailingNewline) {
+				const shouldAutoChunk = allowImplicitChunk$1 && src.length >= this.IMPLICIT_STREAM_CHUNK_MIN_CHARS && recommendation?.strategy !== "plain";
+				if ((wantsChunking$1 || shouldAutoChunk) && (src.length >= useChars * 2 || srcLineCount >= useLines * 2) && hasTrailingNewline) {
 					const tokens = chunkedParse(md, src, workingEnv, {
 						maxChunkChars: useChars,
 						maxChunkLines: useLines,
@@ -7669,6 +7896,12 @@ var StreamParser = class {
 					this.stats.total += 1;
 					this.stats.chunkedParses = (this.stats.chunkedParses || 0) + 1;
 					this.stats.lastMode = "chunked";
+					setStrategyDiagnostics(workingEnv, {
+						area: "stream",
+						path: "stream-chunked",
+						chunked: true,
+						reason: wantsChunking$1 ? "explicit-initial-large-doc" : "default-initial-large-doc"
+					});
 					return tokens;
 				}
 			}
@@ -7685,12 +7918,23 @@ var StreamParser = class {
 			this.stats.total += 1;
 			this.stats.fullParses += 1;
 			this.stats.lastMode = "full";
+			setStrategyDiagnostics(workingEnv, {
+				area: "stream",
+				path: "stream-full",
+				reason: "initial-parse",
+				unbounded: !!workingEnv.__mdtsUnboundedInfo
+			});
 			return parsed$1.tokens;
 		}
 		if (src === cached.src) {
 			this.stats.total += 1;
 			this.stats.cacheHits += 1;
 			this.stats.lastMode = "cache";
+			setStrategyDiagnostics(cached.env, {
+				area: "stream",
+				path: "stream-cache",
+				reason: "same-source"
+			});
 			return cached.tokens;
 		}
 		const threshold = md.options?.streamOptimizationMinSize ?? this.MIN_SIZE_FOR_OPTIMIZATION;
@@ -7710,6 +7954,12 @@ var StreamParser = class {
 			this.stats.total += 1;
 			this.stats.fullParses += 1;
 			this.stats.lastMode = "full";
+			setStrategyDiagnostics(fallbackEnv$1, {
+				area: "stream",
+				path: "stream-full",
+				reason: "small-non-append",
+				unbounded: !!fallbackEnv$1.__mdtsUnboundedInfo
+			});
 			return nextTokens$1;
 		}
 		const appended = this.getAppendedSegment(cached.src, src);
@@ -7819,6 +8069,7 @@ var StreamParser = class {
 				return appendedLineCount;
 			};
 			const canDirectParseAppend = this.canDirectlyParseAppend(cached);
+			const useUnboundedAppend = canDirectParseAppend && this.shouldUseUnboundedAppend(src, cached, appended);
 			let shouldAttemptContext = false;
 			if (!canDirectParseAppend) switch (ctxStrategy) {
 				case "lines":
@@ -7854,10 +8105,15 @@ var StreamParser = class {
 				}
 			} else appendedState = null;
 			if (!appendedState) {
-				const simpleState = this.core.parse(appended, cached.env, md);
 				const lineOffset = cachedLineCount;
-				if (lineOffset > 0) this.shiftTokenLines(simpleState.tokens, lineOffset);
-				appendedState = simpleState;
+				if (useUnboundedAppend) {
+					appendedState = { tokens: parseStringUnbounded(md, appended, cached.env, { mode: "stream" }) };
+					if (lineOffset > 0) this.shiftTokenLines(appendedState.tokens, lineOffset);
+				} else {
+					const simpleState = this.core.parse(appended, cached.env, md);
+					if (lineOffset > 0) this.shiftTokenLines(simpleState.tokens, lineOffset);
+					appendedState = simpleState;
+				}
 			}
 			if (cached.tokens.length > 0 && appendedState.tokens.length > 0) {
 				const lastCached = cached.tokens[cached.tokens.length - 1];
@@ -7866,7 +8122,7 @@ var StreamParser = class {
 					if (lastCached.type === "inline" && firstApp.type === "inline") {
 						if (firstApp.children && firstApp.children.length > 0) {
 							if (!lastCached.children) lastCached.children = [];
-							lastCached.children.push(...firstApp.children);
+							this.appendTokens(lastCached.children, firstApp.children);
 						}
 						lastCached.content = (lastCached.content || "") + (firstApp.content || "");
 						appendedState.tokens.shift();
@@ -7901,7 +8157,7 @@ var StreamParser = class {
 					}
 				}
 				if (dup > 0) a.splice(0, dup);
-				if (a.length > 0) cached.tokens.push(...a);
+				if (a.length > 0) this.appendTokens(cached.tokens, a);
 			}
 			cached.src = src;
 			cached.lineCount = cachedLineCount + (appendedLineCount ?? countLines(appended));
@@ -7918,7 +8174,14 @@ var StreamParser = class {
 			} else cached.lastSegment = void 0;
 			this.stats.total += 1;
 			this.stats.appendHits += 1;
+			if (useUnboundedAppend) this.stats.unboundedAppendHits = (this.stats.unboundedAppendHits || 0) + 1;
 			this.stats.lastMode = "append";
+			setStrategyDiagnostics(cached.env, {
+				area: "stream",
+				path: useUnboundedAppend ? "stream-unbounded-append" : "stream-append",
+				reason: useUnboundedAppend ? "large-delta" : "safe-append",
+				unbounded: useUnboundedAppend
+			});
 			return cached.tokens;
 		}
 		const fallbackEnv = envProvided ?? cached.env;
@@ -7927,9 +8190,17 @@ var StreamParser = class {
 			this.stats.total += 1;
 			this.stats.tailHits += 1;
 			this.stats.lastMode = "tail";
+			setStrategyDiagnostics(fallbackEnv, {
+				area: "stream",
+				path: "stream-tail",
+				reason: "tail-reparse"
+			});
 			return tailReparsed;
 		}
-		const chunkedEnabled = !!md.options?.streamChunkedFallback;
+		const explicitChunkFallbackSetting = !!md.__explicitStreamChunkFallbackSetting;
+		const wantsChunking = !!md.options?.streamChunkedFallback;
+		const allowImplicitChunk = !explicitChunkFallbackSetting && !appended;
+		const chunkedEnabled = wantsChunking || allowImplicitChunk;
 		const chunkAdaptive = md.options?.streamChunkAdaptive !== false;
 		const targetChunks = md.options?.streamChunkTargetChunks ?? 8;
 		const chunkSizeCharsCfg = md.options?.streamChunkSizeChars;
@@ -7947,7 +8218,8 @@ var StreamParser = class {
 			const useLines = recommendation?.maxChunkLines ?? (chunkAdaptive ? clamp$1(Math.ceil(srcLineCount2 / targetChunks), 150, 700) : chunkSizeLinesCfg ?? 200);
 			const useMaxChunks = recommendation?.maxChunks ?? (chunkAdaptive ? clamp$1(Math.ceil(src.length / 64e3), targetChunks, 32) : chunkMaxChunksCfg);
 			const hasTrailingNewline2 = src.length > 0 && src.charCodeAt(src.length - 1) === 10;
-			if (recommendation?.strategy !== "plain" && (src.length >= useChars * 2 || srcLineCount2 >= useLines * 2) && hasTrailingNewline2) {
+			const shouldAutoChunk = allowImplicitChunk && src.length >= this.IMPLICIT_STREAM_CHUNK_MIN_CHARS && recommendation?.strategy !== "plain";
+			if ((wantsChunking || shouldAutoChunk) && (src.length >= useChars * 2 || srcLineCount2 >= useLines * 2) && hasTrailingNewline2) {
 				const tokens = chunkedParse(md, src, fallbackEnv, {
 					maxChunkChars: useChars,
 					maxChunkLines: useLines,
@@ -7965,6 +8237,12 @@ var StreamParser = class {
 				this.stats.total += 1;
 				this.stats.chunkedParses = (this.stats.chunkedParses || 0) + 1;
 				this.stats.lastMode = "chunked";
+				setStrategyDiagnostics(fallbackEnv, {
+					area: "stream",
+					path: "stream-chunked",
+					chunked: true,
+					reason: wantsChunking ? "explicit-fallback-large-doc" : "default-fallback-large-doc"
+				});
 				return tokens;
 			}
 		}
@@ -7982,21 +8260,43 @@ var StreamParser = class {
 		this.stats.total += 1;
 		this.stats.fullParses += 1;
 		this.stats.lastMode = "full";
+		setStrategyDiagnostics(fallbackEnv, {
+			area: "stream",
+			path: "stream-full",
+			reason: "fallback-full",
+			unbounded: !!fallbackEnv.__mdtsUnboundedInfo
+		});
 		return nextTokens;
 	}
 	parseFullDocument(src, env, md, knownLineCount, needLineCount = true) {
 		const autoUnboundedDecision = getAutoUnboundedDecision(md, src.length, knownLineCount);
-		if (autoUnboundedDecision === "yes") return {
-			tokens: parseStringUnbounded(md, src, env),
-			lineCount: knownLineCount ?? (needLineCount ? countLines(src) : 0)
-		};
+		if (autoUnboundedDecision === "yes") {
+			setStrategyDiagnostics(env, {
+				area: "stream",
+				path: "stream-full",
+				reason: "auto-unbounded-char-threshold",
+				unbounded: true
+			});
+			return {
+				tokens: parseStringUnbounded(md, src, env),
+				lineCount: knownLineCount ?? (needLineCount ? countLines(src) : 0)
+			};
+		}
 		let lineCount = knownLineCount;
 		if (autoUnboundedDecision === "need-lines") {
 			lineCount = countLines(src);
-			if (shouldAutoUseUnbounded(md, src.length, lineCount)) return {
-				tokens: parseStringUnbounded(md, src, env),
-				lineCount
-			};
+			if (shouldAutoUseUnbounded(md, src.length, lineCount)) {
+				setStrategyDiagnostics(env, {
+					area: "stream",
+					path: "stream-full",
+					reason: "auto-unbounded-line-threshold",
+					unbounded: true
+				});
+				return {
+					tokens: parseStringUnbounded(md, src, env),
+					lineCount
+				};
+			}
 		}
 		if (lineCount === void 0) lineCount = needLineCount ? countLines(src) : 0;
 		return {
@@ -8004,6 +8304,12 @@ var StreamParser = class {
 			lineCount
 		};
 	}
+	shouldUseUnboundedAppend(src, _cached, appended) {
+		if (!appended) return false;
+		if (src.length < this.MIN_UNBOUNDED_APPEND_TOTAL_CHARS && appended.length < this.MIN_UNBOUNDED_APPEND_CHARS) return false;
+		if (appended.length >= this.MIN_UNBOUNDED_APPEND_CHARS) return true;
+		return countLines(appended) >= this.MIN_UNBOUNDED_APPEND_LINES;
+	}
 	getAppendedSegment(prev, next) {
 		if (!next.startsWith(prev)) return null;
 		if (!prev.endsWith("\n")) return null;
@@ -8052,7 +8358,7 @@ var StreamParser = class {
 			cached.src = src;
 			cached.env = env;
 			cached.tokens.length = lastSegment.tokenStart;
-			cached.tokens.push(...tailState.tokens);
+			this.appendTokens(cached.tokens, tailState.tokens);
 			cached.lineCount = countLines(src);
 			if (localLastSegment) cached.lastSegment = {
 				tokenStart: lastSegment.tokenStart + localLastSegment.tokenStart,
@@ -8118,6 +8424,9 @@ var StreamParser = class {
 	getStats() {
 		return { ...this.stats };
 	}
+	appendTokens(target, source) {
+		for (let i = 0; i < source.length; i++) target.push(source[i]);
+	}
 	updateCacheLineCount(cache, lineCount) {
 		cache.lineCount = lineCount ?? countLines(cache.src);
 		cache.lastSegment = void 0;
@@ -8431,6 +8740,9 @@ function hasExplicitChunkOverride(presetOptions, userOptions, keys) {
 	}
 	return false;
 }
+function hasExplicitOption(presetOptions, userOptions, key) {
+	return !!userOptions && Object.prototype.hasOwnProperty.call(userOptions, key) || !!presetOptions && Object.prototype.hasOwnProperty.call(presetOptions, key);
+}
 function markdownIt(presetName, options) {
 	let opts = {
 		html: false,
@@ -8451,8 +8763,8 @@ function markdownIt(presetName, options) {
 		streamChunkAdaptive: true,
 		streamChunkTargetChunks: 8,
 		streamChunkMaxChunks: void 0,
-		streamSkipCacheAboveChars: 6e5,
-		streamSkipCacheAboveLines: 1e4,
+		streamSkipCacheAboveChars: 1e6,
+		streamSkipCacheAboveLines: 1e5,
 		fullChunkedFallback: false,
 		fullChunkThresholdChars: 2e4,
 		fullChunkThresholdLines: 400,
@@ -8511,6 +8823,8 @@ function markdownIt(presetName, options) {
 		"streamChunkSizeLines",
 		"streamChunkMaxChunks"
 	]);
+	let explicitFullChunkFallbackSetting = hasExplicitOption(preset?.options, userOptions, "fullChunkedFallback");
+	let explicitStreamChunkFallbackSetting = hasExplicitOption(preset?.options, userOptions, "streamChunkedFallback");
 	const core = new ParserCore();
 	let renderer = null;
 	const getRenderer = () => {
@@ -8552,6 +8866,8 @@ function markdownIt(presetName, options) {
 		options: opts,
 		__explicitFullChunkConfig: explicitFullChunkConfig,
 		__explicitStreamChunkConfig: explicitStreamChunkConfig,
+		__explicitFullChunkFallbackSetting: explicitFullChunkFallbackSetting,
+		__explicitStreamChunkFallbackSetting: explicitStreamChunkFallbackSetting,
 		set(newOpts) {
 			this.options = {
 				...this.options,
@@ -8565,6 +8881,14 @@ function markdownIt(presetName, options) {
 				explicitStreamChunkConfig = true;
 				this.__explicitStreamChunkConfig = true;
 			}
+			if (Object.prototype.hasOwnProperty.call(newOpts, "fullChunkedFallback")) {
+				explicitFullChunkFallbackSetting = true;
+				this.__explicitFullChunkFallbackSetting = true;
+			}
+			if (Object.prototype.hasOwnProperty.call(newOpts, "streamChunkedFallback")) {
+				explicitStreamChunkFallbackSetting = true;
+				this.__explicitStreamChunkFallbackSetting = true;
+			}
 			if (renderer) renderer.set(newOpts);
 			if (typeof newOpts.stream === "boolean") {
 				this.stream.enabled = newOpts.stream;
@@ -8657,20 +8981,38 @@ function markdownIt(presetName, options) {
 		helpers: { ...helpers_exports },
 		parse(src, env = {}) {
 			if (typeof src !== "string") throw new TypeError("Input data should be a String");
+			let countedLines;
 			if (!this.stream.enabled && !this.options.fullChunkedFallback) {
 				const autoUnboundedDecision = getAutoUnboundedDecision(this, src.length);
-				if (autoUnboundedDecision === "yes") return parseStringUnbounded(this, src, env);
-				if (autoUnboundedDecision === "need-lines" && shouldAutoUseUnbounded(this, src.length, countLines(src))) return parseStringUnbounded(this, src, env);
-				return core.parse(src, env, this).tokens;
+				if (autoUnboundedDecision === "yes") {
+					setStrategyDiagnostics(env, {
+						area: "parse",
+						path: "auto-unbounded",
+						unbounded: true,
+						reason: "char-threshold"
+					});
+					return parseStringUnbounded(this, src, env);
+				}
+				if (autoUnboundedDecision === "need-lines") countedLines = countLines(src);
 			}
 			if (!this.stream.enabled) {
 				const chars = src.length;
-				if (this.options.fullChunkedFallback) {
-					const lines = countLines(src);
-					const autoRecommendation = this.options.autoTuneChunks !== false && !explicitFullChunkConfig ? recommendFullChunkStrategy(chars, lines, this.options) : null;
-					if (chars >= (this.options.fullChunkThresholdChars ?? 2e4) || lines >= (this.options.fullChunkThresholdLines ?? 400)) {
-						if (autoRecommendation) {
-							if (autoRecommendation.strategy === "plain") return core.parse(src, env, this).tokens;
+				const lines = countedLines ?? countLines(src);
+				const auto = this.options.autoTuneChunks !== false;
+				const userForcedChunk = explicitFullChunkConfig;
+				const allowImplicitChunk = !explicitFullChunkFallbackSetting;
+				const wantsChunking = !!this.options.fullChunkedFallback;
+				const shouldAutoChunk = allowImplicitChunk && chars >= 2e5;
+				const autoRecommendation = auto && !userForcedChunk ? recommendFullChunkStrategy(chars, lines, this.options) : null;
+				if (wantsChunking || shouldAutoChunk) {
+					if (wantsChunking ? chars >= (this.options.fullChunkThresholdChars ?? 2e4) || lines >= (this.options.fullChunkThresholdLines ?? 400) : shouldAutoChunk) {
+						if (autoRecommendation && autoRecommendation.strategy !== "plain") {
+							setStrategyDiagnostics(env, {
+								area: "parse",
+								path: "full-chunk",
+								chunked: true,
+								reason: wantsChunking ? "explicit-full-chunk" : "default-large-string"
+							});
 							return chunkedParse(this, src, env, {
 								maxChunkChars: autoRecommendation.maxChunkChars,
 								maxChunkLines: autoRecommendation.maxChunkLines,
@@ -8678,23 +9020,45 @@ function markdownIt(presetName, options) {
 								maxChunks: autoRecommendation.maxChunks
 							});
 						}
-						const clamp$1 = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
-						const adaptive = this.options.fullChunkAdaptive !== false;
-						const target = this.options.fullChunkTargetChunks ?? 8;
-						const dynMaxChunkChars = clamp$1(Math.ceil(chars / target), 8e3, 64e3);
-						const dynMaxChunkLines = clamp$1(Math.ceil(lines / target), 150, 700);
-						const maxChunkChars = adaptive ? dynMaxChunkChars : this.options.fullChunkSizeChars ?? 1e4;
-						const maxChunkLines = adaptive ? dynMaxChunkLines : this.options.fullChunkSizeLines ?? 200;
-						const maxChunks = adaptive ? clamp$1(Math.ceil(chars / 64e3), target, 32) : this.options.fullChunkMaxChunks;
-						return chunkedParse(this, src, env, {
-							maxChunkChars,
-							maxChunkLines,
-							fenceAware: this.options.fullChunkFenceAware ?? true,
-							maxChunks
-						});
+						if (wantsChunking) {
+							const clamp$1 = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
+							const adaptive = this.options.fullChunkAdaptive !== false;
+							const target = this.options.fullChunkTargetChunks ?? 8;
+							const dynMaxChunkChars = clamp$1(Math.ceil(chars / target), 8e3, 64e3);
+							const dynMaxChunkLines = clamp$1(Math.ceil(lines / target), 150, 700);
+							const maxChunkChars = adaptive ? dynMaxChunkChars : this.options.fullChunkSizeChars ?? 1e4;
+							const maxChunkLines = adaptive ? dynMaxChunkLines : this.options.fullChunkSizeLines ?? 200;
+							const maxChunks = adaptive ? clamp$1(Math.ceil(chars / 64e3), target, 32) : this.options.fullChunkMaxChunks;
+							setStrategyDiagnostics(env, {
+								area: "parse",
+								path: "full-chunk",
+								chunked: true,
+								reason: "explicit-full-chunk"
+							});
+							return chunkedParse(this, src, env, {
+								maxChunkChars,
+								maxChunkLines,
+								fenceAware: this.options.fullChunkFenceAware ?? true,
+								maxChunks
+							});
+						}
 					}
 				}
+				if (countedLines !== void 0 && shouldAutoUseUnbounded(this, chars, lines)) {
+					setStrategyDiagnostics(env, {
+						area: "parse",
+						path: "auto-unbounded",
+						unbounded: true,
+						reason: "line-threshold"
+					});
+					return parseStringUnbounded(this, src, env);
+				}
 			}
+			setStrategyDiagnostics(env, {
+				area: "parse",
+				path: "plain",
+				reason: "default-plain"
+			});
 			return core.parse(src, env, this).tokens;
 		},
 		parseIterable(chunks, env = {}) {
@@ -8734,6 +9098,7 @@ function markdownIt(presetName, options) {
 				total: 0,
 				cacheHits: 0,
 				appendHits: 0,
+				unboundedAppendHits: 0,
 				tailHits: 0,
 				fullParses: 0,
 				resets: 0,
@@ -10128,7 +10493,7 @@ function fixLinkToken(tokens) {
 				tokens[i - 1].content = "";
 			}
 		}
-		if (curToken.type === "link_close" && curToken.nesting === -1 && tokens[i + 1]?.type === "text" && tokens[i - 1]?.type === "text") {
+		if (curToken.type === "link_close" && curToken.nesting === -1 && tokens[i - 2]?.type === "link_open" && tokens[i + 1]?.type === "text" && tokens[i - 1]?.type === "text") {
 			const text$1 = tokens[i - 1].content || "";
 			const attrs = tokens[i - 2].attrs || [];
 			const href = attrs.find((a) => a[0] === "href")?.[1] || "";