stream-markdown-parser 0.0.42 → 0.0.44

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.2/node_modules/markdown-it-ts/dist/chunk-Bp6m_JJh.js
+//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.3/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.2/node_modules/markdown-it-ts/dist/index.js
+//#region ../../node_modules/.pnpm/markdown-it-ts@0.0.3/node_modules/markdown-it-ts/dist/index.js
 var import_punycode = /* @__PURE__ */ __toESM(require_punycode(), 1);
 var utils_exports = /* @__PURE__ */ __export({
 	arrayReplaceAt: () => arrayReplaceAt,
@@ -5302,35 +5302,20 @@ var StateInline = class {
 		const { src, posMax } = this;
 		const marker = src.charCodeAt(start);
 		let pos = start;
-		let count = 0;
-		while (pos < posMax && src.charCodeAt(pos) === marker) {
-			count++;
-			pos++;
-		}
+		while (pos < posMax && src.charCodeAt(pos) === marker) pos++;
+		const count = pos - start;
 		if (count < 1) return null;
 		const lastChar = start > 0 ? src.charCodeAt(start - 1) : 32;
 		const nextChar = pos < posMax ? src.charCodeAt(pos) : 32;
-		const isLastPunctChar = lastChar === 32 || lastChar === 10;
-		const isNextPunctChar = nextChar === 32 || nextChar === 10;
-		const isLastWhiteSpace = lastChar === 32;
-		const isNextWhiteSpace = nextChar === 32;
-		let can_open = true;
-		let can_close = true;
-		if (isNextWhiteSpace) can_open = false;
-		else if (isNextPunctChar) {
-			if (!(isLastWhiteSpace || isLastPunctChar)) can_open = false;
-		}
-		if (isLastWhiteSpace) can_close = false;
-		else if (isLastPunctChar) {
-			if (!(isNextWhiteSpace || isNextPunctChar)) can_close = false;
-		}
-		if (!canSplitWord) {
-			can_open = can_open && (!isLastPunctChar || isLastWhiteSpace);
-			can_close = can_close && (!isNextPunctChar || isNextWhiteSpace);
-		}
+		const isLastPunctChar = isMdAsciiPunct(lastChar) || isPunctChar(String.fromCharCode(lastChar));
+		const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar));
+		const isLastWhiteSpace = isWhiteSpace(lastChar);
+		const isNextWhiteSpace = isWhiteSpace(nextChar);
+		const left_flanking = !isNextWhiteSpace && (!isNextPunctChar || isLastWhiteSpace || isLastPunctChar);
+		const right_flanking = !isLastWhiteSpace && (!isLastPunctChar || isNextWhiteSpace || isNextPunctChar);
 		return {
-			can_open,
-			can_close,
+			can_open: left_flanking && (canSplitWord || !right_flanking || isLastPunctChar),
+			can_close: right_flanking && (canSplitWord || !left_flanking || isNextPunctChar),
 			length: count
 		};
 	}
@@ -6834,6 +6819,7 @@ const BASE_COMMON_HTML_TAGS = new Set([
 	"del",
 	"dfn",
 	"em",
+	"font",
 	"i",
 	"img",
 	"input",
@@ -6889,7 +6875,7 @@ const BASE_COMMON_HTML_TAGS = new Set([
 const OPEN_TAG_RE = /<([A-Z][\w-]*)(?=[\s/>]|$)/gi;
 const CLOSE_TAG_RE = /<\/\s*([A-Z][\w-]*)(?=[\s/>]|$)/gi;
 const TAG_NAME_AT_START_RE = /^<\s*(?:\/\s*)?([A-Z][\w-]*)/i;
-function findTagCloseIndexOutsideQuotes(html) {
+function findTagCloseIndexOutsideQuotes$1(html) {
 	let inSingle = false;
 	let inDouble = false;
 	for (let i = 0; i < html.length; i++) {
@@ -6932,8 +6918,8 @@ function findFirstIncompleteTag(content, tagSet) {
 		const idx = m.index ?? -1;
 		if (idx < 0) continue;
 		const tag = (m[1] ?? "").toLowerCase();
-		if (!tagSet.has(tag)) continue;
-		if (findTagCloseIndexOutsideQuotes(content.slice(idx)) !== -1) continue;
+		if (!isCommonHtmlTagOrPrefix(tag, tagSet)) continue;
+		if (findTagCloseIndexOutsideQuotes$1(content.slice(idx)) !== -1) continue;
 		if (!first || idx < first.index) first = {
 			index: idx,
 			tag,
@@ -6945,7 +6931,7 @@ function findFirstIncompleteTag(content, tagSet) {
 		if (idx < 0) continue;
 		const tag = (m[1] ?? "").toLowerCase();
 		if (!isCommonHtmlTagOrPrefix(tag, tagSet)) continue;
-		if (findTagCloseIndexOutsideQuotes(content.slice(idx)) !== -1) continue;
+		if (findTagCloseIndexOutsideQuotes$1(content.slice(idx)) !== -1) continue;
 		if (!first || idx < first.index) first = {
 			index: idx,
 			tag,
@@ -7011,7 +6997,7 @@ function fixStreamingHtmlInlineChildren(children, tagSet) {
 				cursor = lt + 1;
 				continue;
 			}
-			const closeIdx = findTagCloseIndexOutsideQuotes(sub);
+			const closeIdx = findTagCloseIndexOutsideQuotes$1(sub);
 			if (closeIdx === -1) {
 				pushTextPart("<", baseToken);
 				cursor = lt + 1;
@@ -7049,7 +7035,7 @@ function fixStreamingHtmlInlineChildren(children, tagSet) {
 		if (pending) {
 			pending.buffer += tokenToRaw$1(child);
 			pendingAtEnd = pending.buffer;
-			const closeIdx = findTagCloseIndexOutsideQuotes(pending.buffer);
+			const closeIdx = findTagCloseIndexOutsideQuotes$1(pending.buffer);
 			if (closeIdx === -1) continue;
 			const tagChunk = pending.buffer.slice(0, closeIdx + 1);
 			const afterChunk = pending.buffer.slice(closeIdx + 1);
@@ -7067,7 +7053,7 @@ function fixStreamingHtmlInlineChildren(children, tagSet) {
 		if (child.type === "html_inline") {
 			const content = tokenToRaw$1(child);
 			const tagName = (content.match(TAG_NAME_AT_START_RE)?.[1] ?? "").toLowerCase();
-			if (tagName && tagSet.has(tagName) && findTagCloseIndexOutsideQuotes(content) === -1) {
+			if (tagName && tagSet.has(tagName) && findTagCloseIndexOutsideQuotes$1(content) === -1) {
 				pending = {
 					tag: tagName,
 					buffer: content,
@@ -7147,10 +7133,69 @@ function applyFixHtmlInlineTokens(md, options = {}) {
 		const tagStack = [];
 		for (let i = 0; i < toks.length; i++) {
 			const t = toks[i];
+			if (tagStack.length > 0) {
+				const [openTag, openIndex] = tagStack[tagStack.length - 1];
+				if (i !== openIndex) {
+					if (t.type === "paragraph_open" || t.type === "paragraph_close") {
+						toks.splice(i, 1);
+						i--;
+						continue;
+					}
+					const chunk = String(t.content ?? t.raw ?? "");
+					const closeRe = new RegExp(`<\\s*\\/\\s*${openTag}\\s*>`, "i");
+					const closeMatch = chunk ? closeRe.exec(chunk) : null;
+					const isClosingTag$1 = !!closeMatch;
+					if (chunk) {
+						const openToken = toks[openIndex];
+						if (closeMatch && typeof closeMatch.index === "number") {
+							const end = closeMatch.index + String(closeMatch[0] ?? "").length;
+							const before = chunk.slice(0, end);
+							const after = chunk.slice(end);
+							openToken.content = `${String(openToken.content || "")}\n${before}`;
+							openToken.loading = false;
+							const afterTrimmed = after.replace(/^\s+/, "");
+							toks.splice(i, 1);
+							tagStack.pop();
+							if (afterTrimmed) toks.splice(i, 0, afterTrimmed.startsWith("<") ? {
+								type: "html_block",
+								content: afterTrimmed
+							} : {
+								type: "inline",
+								content: afterTrimmed,
+								children: [{
+									type: "text",
+									content: afterTrimmed,
+									raw: afterTrimmed
+								}]
+							});
+							i--;
+							continue;
+						}
+						openToken.content = `${String(openToken.content || "")}\n${chunk}`;
+						if (openToken.loading !== false) openToken.loading = !isClosingTag$1;
+					}
+					toks.splice(i, 1);
+					i--;
+					if (isClosingTag$1) tagStack.pop();
+					continue;
+				}
+			}
 			if (t.type === "html_block") {
-				const tag = (t.content?.match(/<([^\s>/]+)/)?.[1] ?? "").toLowerCase();
-				if (!/<\s*\/\s*[^\s>]+\s*>/.test(t.content || "")) tagStack.push([tag, i]);
-				else if (tagStack.length > 0 && tagStack[tagStack.length - 1][0] === tag) tagStack.pop();
+				const rawContent = String(t.content || "");
+				const tag = (rawContent.match(/<\s*(?:\/\s*)?([^\s>/]+)/)?.[1] ?? "").toLowerCase();
+				if (!/^\s*<\s*\//.test(rawContent)) {
+					if (tag) {
+						if (!new RegExp(`<\\s*\\/\\s*${tag}\\s*>`, "i").test(rawContent)) tagStack.push([tag, i]);
+					}
+				} else if (tagStack.length > 0 && tag && tagStack[tagStack.length - 1][0] === tag) {
+					const [, openIndex] = tagStack[tagStack.length - 1];
+					const openToken = toks[openIndex];
+					openToken.content = `${String(openToken.content || "")}\n${rawContent}`;
+					openToken.loading = false;
+					tagStack.pop();
+					toks.splice(i, 1);
+					i--;
+				}
 				continue;
 			} else if (tagStack.length > 0) {
 				if (t.type === "paragraph_open" || t.type === "paragraph_close") {
@@ -7171,10 +7216,153 @@ function applyFixHtmlInlineTokens(md, options = {}) {
 				i--;
 			} else continue;
 		}
+		if (customTagSet.size > 0) {
+			const openReCache = /* @__PURE__ */ new Map();
+			const closeReCache = /* @__PURE__ */ new Map();
+			const getOpenRe = (tag) => {
+				let r = openReCache.get(tag);
+				if (!r) {
+					r = new RegExp(`<\\s*${tag}\\b`, "i");
+					openReCache.set(tag, r);
+				}
+				return r;
+			};
+			const getCloseRe = (tag) => {
+				let r = closeReCache.get(tag);
+				if (!r) {
+					r = new RegExp(`<\\s*\\/\\s*${tag}\\s*>`, "i");
+					closeReCache.set(tag, r);
+				}
+				return r;
+			};
+			const stack = [];
+			for (let i = 0; i < toks.length; i++) {
+				const tok = toks[i];
+				const content = String(tok.content ?? "");
+				if (stack.length > 0) {
+					const top = stack[stack.length - 1];
+					const openTok = toks[top.index];
+					if (tok.type === "html_block" && getCloseRe(top.tag).test(content)) {
+						openTok.content = `${String(openTok.content ?? "")}\n${content}`;
+						if (Array.isArray(openTok.children)) openTok.children.push({
+							type: "html_inline",
+							content: `</${top.tag}>`,
+							raw: `</${top.tag}>`
+						});
+						toks.splice(i, 1);
+						i--;
+						stack.pop();
+						continue;
+					}
+					if (tok.type !== "inline") continue;
+					const children = Array.isArray(tok.children) ? tok.children : [];
+					const closeChildIndex = children.findIndex((c) => {
+						if (!c || c.type !== "html_inline") return false;
+						const cContent = String(c.content ?? "");
+						return /^\s*<\s*\//.test(cContent) && cContent.toLowerCase().includes(top.tag);
+					});
+					if (closeChildIndex !== -1) {
+						const beforeChildren = children.slice(0, closeChildIndex + 1);
+						const afterChildren = children.slice(closeChildIndex + 1);
+						const beforeText = beforeChildren.map((c) => String(c?.content ?? c?.raw ?? "")).join("");
+						openTok.content = `${String(openTok.content ?? "")}\n${beforeText}`;
+						if (Array.isArray(openTok.children)) openTok.children.push(...beforeChildren);
+						if (afterChildren.length) {
+							const afterText = afterChildren.map((c) => String(c.content ?? c.raw ?? "")).join("");
+							if (afterText.trim()) {
+								const trimmed = afterText.replace(/^\s+/, "");
+								if (trimmed.startsWith("<")) toks.splice(i, 1, {
+									type: "html_block",
+									content: trimmed
+								});
+								else toks.splice(i, 1, {
+									type: "paragraph_open",
+									tag: "p",
+									nesting: 1
+								}, {
+									type: "inline",
+									tag: "",
+									nesting: 0,
+									content: afterText,
+									children: [{
+										type: "text",
+										content: afterText,
+										raw: afterText
+									}]
+								}, {
+									type: "paragraph_close",
+									tag: "p",
+									nesting: -1
+								});
+							} else {
+								toks.splice(i, 1);
+								i--;
+							}
+						} else {
+							toks.splice(i, 1);
+							i--;
+						}
+						stack.pop();
+						continue;
+					}
+					openTok.content = `${String(openTok.content ?? "")}\n${content}`;
+					if (Array.isArray(openTok.children)) openTok.children.push(...children);
+					toks.splice(i, 1);
+					i--;
+					continue;
+				}
+				if (tok.type !== "inline") continue;
+				for (const tag of customTagSet) if (getOpenRe(tag).test(content) && !getCloseRe(tag).test(content)) {
+					stack.push({
+						tag,
+						index: i
+					});
+					break;
+				}
+			}
+		}
+		{
+			let depth = 0;
+			for (let i = 0; i < toks.length; i++) {
+				const t = toks[i];
+				if (t.type === "paragraph_open") {
+					depth++;
+					continue;
+				}
+				if (t.type === "paragraph_close") if (depth > 0) depth--;
+				else {
+					toks.splice(i, 1);
+					i--;
+				}
+			}
+		}
 		for (let i = 0; i < toks.length; i++) {
 			const t = toks[i];
 			if (t.type === "html_block") {
 				const tag = (t.content?.match(/<([^\s>/]+)/)?.[1] ?? "").toLowerCase();
+				if (customTagSet.has(tag)) {
+					const raw$1 = String(t.content ?? "");
+					const closeRe = new RegExp(`<\\/\\s*${tag}\\s*>`, "i");
+					t.loading = closeRe.test(raw$1) ? false : t.loading !== void 0 ? t.loading : true;
+					const closeMatch = closeRe.exec(raw$1);
+					const endTagIndex = closeMatch ? closeMatch.index : -1;
+					const closeLen = closeMatch ? closeMatch[0].length : 0;
+					if (endTagIndex !== -1) {
+						const rawForNode = raw$1.slice(0, endTagIndex + closeLen);
+						t.content = rawForNode;
+						t.raw = rawForNode;
+						const afterTrimmed = (raw$1.slice(endTagIndex + closeLen) || "").replace(/^\s+/, "");
+						if (afterTrimmed) toks.splice(i + 1, 0, afterTrimmed.startsWith("<") ? {
+							type: "html_block",
+							content: afterTrimmed
+						} : {
+							type: "text",
+							content: afterTrimmed,
+							raw: afterTrimmed
+						});
+					}
+					continue;
+				}
 				if (tag.startsWith("!") || tag.startsWith("?")) {
 					t.loading = false;
 					continue;
@@ -7192,7 +7380,7 @@ function applyFixHtmlInlineTokens(md, options = {}) {
 					"li"
 				].includes(tag)) continue;
 				t.type = "inline";
-				const loading = t.content?.toLowerCase().includes(`</${tag}>`) ? false : t.loading !== void 0 ? t.loading : true;
+				const loading = new RegExp(`<\\/\\s*${tag}\\s*>`, "i").test(String(t.content ?? "")) ? false : t.loading !== void 0 ? t.loading : true;
 				const attrs = [];
 				const attrRegex = /\s([\w:-]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+)))?/g;
 				let match;
@@ -7202,24 +7390,36 @@ function applyFixHtmlInlineTokens(md, options = {}) {
 					attrs.push([attrName, attrValue]);
 				}
 				if (customTagSet.has(tag)) {
-					const contentMatch = t.content?.match(new RegExp(`<\\s*${tag}[^>]*>([\\s\\S]*)`, "i"));
-					const raw$1 = t.content;
-					const endTagRegex = new RegExp(`</\\s*${tag}\\s*>`, "i");
-					const endTagIndex = t.content?.toLowerCase().indexOf(`</${tag}>`) ?? -1;
+					const raw$1 = String(t.content ?? "");
+					const closeMatch = new RegExp(`<\\/\\s*${tag}\\s*>`, "i").exec(raw$1);
+					const endTagIndex = closeMatch ? closeMatch.index : -1;
+					const closeLen = closeMatch ? closeMatch[0].length : 0;
+					const rawForNode = endTagIndex !== -1 ? raw$1.slice(0, endTagIndex + closeLen) : raw$1;
+					let inner = "";
+					const openEnd = findTagCloseIndexOutsideQuotes$1(raw$1);
+					if (openEnd !== -1) {
+						if (endTagIndex !== -1 && openEnd < endTagIndex) inner = raw$1.slice(openEnd + 1, endTagIndex);
+						else if (endTagIndex === -1) inner = raw$1.slice(openEnd + 1).replace(/<.*$/, "");
+					}
 					t.children = [{
 						type: tag,
-						content: endTagIndex !== -1 ? contentMatch[1].split(endTagRegex)[0] ? contentMatch ? contentMatch[1] : "" : "" : contentMatch ? contentMatch[1].replace(/<.*$/, "") : "",
-						raw: raw$1,
+						content: inner,
+						raw: rawForNode,
 						attrs,
 						tag,
 						loading
 					}];
 					if (endTagIndex !== -1) {
-						const afterContent = t.content?.slice(endTagIndex + tag.length + 3) || "";
-						if (afterContent.trim()) toks.splice(i + 1, 0, {
+						t.content = rawForNode;
+						t.raw = rawForNode;
+						const afterTrimmed = (raw$1.slice(endTagIndex + closeLen) || "").replace(/^\s+/, "");
+						if (afterTrimmed) toks.splice(i + 1, 0, afterTrimmed.startsWith("<") ? {
+							type: "html_block",
+							content: afterTrimmed
+						} : {
 							type: "text",
-							content: afterContent,
-							raw: afterContent
+							content: afterTrimmed,
+							raw: afterTrimmed
 						});
 					}
 				} else t.children = [{
@@ -7976,7 +8176,7 @@ function fixTableTokens(tokens) {
 	if (token.type === "inline") {
 		const tcontent = String(token.content ?? "");
 		const childContent = String(token.children?.[0]?.content ?? "");
-		if (/^\|(?:[^|\n]+\|?)+/.test(tcontent)) {
+		if (!tcontent.includes("\n") && /^\|(?:[^|\n]+\|?)+/.test(tcontent)) {
 			const body = childContent.slice(1).split("|").map((i$1) => i$1.trim()).filter(Boolean).flatMap((i$1) => createTh(i$1));
 			const insert = [
 				...createStart(),
@@ -8923,6 +9123,7 @@ function parseHtmlInlineCodeToken(token, tokens, i, parseInlineTokens$1, raw, pP
 		tag,
 		attrs,
 		content: fragment.innerTokens.length ? stringifyTokens(fragment.innerTokens) : "",
+		children: fragment.innerTokens.length ? parseInlineTokens$1(fragment.innerTokens, raw, pPreToken, options) : [],
 		raw: content,
 		loading: token.loading || loading,
 		autoClosed
@@ -9270,7 +9471,7 @@ function parseInlineTokens(tokens, raw, pPreToken, options) {
 			i++;
 			return true;
 		}
-		if (/\*\*/.test(content) && !content.endsWith("**")) {
+		if (/\*\*/.test(content)) {
 			const openIdx = content.indexOf("**");
 			const beforeText = openIdx > -1 ? content.slice(0, openIdx) : "";
 			if (beforeText) pushText(beforeText, beforeText);
@@ -10184,7 +10385,7 @@ function parseHtmlBlock(token) {
 	const isVoid = VOID_TAGS.has(tag);
 	let closeRe = CLOSE_TAG_RE_CACHE.get(tag);
 	if (!closeRe) {
-		closeRe = new RegExp(`<\\/\\s*${tag}\\b`, "i");
+		closeRe = new RegExp(`<\\s*\\/\\s*${tag}\\s*>`, "i");
 		CLOSE_TAG_RE_CACHE.set(tag, closeRe);
 	}
 	const hasClosing = closeRe.test(raw);
@@ -10293,6 +10494,98 @@ function parseThematicBreak() {
 
 //#endregion
 //#region src/parser/node-parsers/block-token-parser.ts
+function findTagCloseIndexOutsideQuotes(input) {
+	let inSingle = false;
+	let inDouble = false;
+	for (let i = 0; i < input.length; i++) {
+		const ch = input[i];
+		if (ch === "\\") {
+			i++;
+			continue;
+		}
+		if (!inDouble && ch === "'") {
+			inSingle = !inSingle;
+			continue;
+		}
+		if (!inSingle && ch === "\"") {
+			inDouble = !inDouble;
+			continue;
+		}
+		if (!inSingle && !inDouble && ch === ">") return i;
+	}
+	return -1;
+}
+function stripWrapperNewlines(s) {
+	return s.replace(/^\r?\n/, "").replace(/\r?\n$/, "");
+}
+function stripTrailingPartialClosingTag(inner, tag) {
+	if (!inner || !tag) return inner;
+	const re = new RegExp(String.raw`[\t ]*<\s*\/\s*${tag}[^>]*$`, "i");
+	return inner.replace(re, "");
+}
+function findNextCustomHtmlBlockFromSource(source, tag, startIndex) {
+	if (!source || !tag) return null;
+	const lowerTag = tag.toLowerCase();
+	const openRe = new RegExp(String.raw`<\s*${lowerTag}(?=\s|>|/)`, "gi");
+	openRe.lastIndex = Math.max(0, startIndex || 0);
+	const openMatch = openRe.exec(source);
+	if (!openMatch || openMatch.index == null) return null;
+	const openStart = openMatch.index;
+	const openSlice = source.slice(openStart);
+	const openEndRel = findTagCloseIndexOutsideQuotes(openSlice);
+	if (openEndRel === -1) return null;
+	const openEnd = openStart + openEndRel;
+	if (/\/\s*>\s*$/.test(openSlice.slice(0, openEndRel + 1))) {
+		const end = openEnd + 1;
+		return {
+			raw: source.slice(openStart, end),
+			end
+		};
+	}
+	let depth = 1;
+	let i = openEnd + 1;
+	const isOpenAt = (pos) => {
+		const s = source.slice(pos);
+		return new RegExp(String.raw`^<\s*${lowerTag}(?=\s|>|/)`, "i").test(s);
+	};
+	const isCloseAt = (pos) => {
+		const s = source.slice(pos);
+		return new RegExp(String.raw`^<\s*\/\s*${lowerTag}(?=\s|>)`, "i").test(s);
+	};
+	while (i < source.length) {
+		const lt = source.indexOf("<", i);
+		if (lt === -1) return {
+			raw: source.slice(openStart),
+			end: source.length
+		};
+		if (isCloseAt(lt)) {
+			const gt = source.indexOf(">", lt);
+			if (gt === -1) return null;
+			depth--;
+			if (depth === 0) {
+				const end = gt + 1;
+				return {
+					raw: source.slice(openStart, end),
+					end
+				};
+			}
+			i = gt + 1;
+			continue;
+		}
+		if (isOpenAt(lt)) {
+			const rel = findTagCloseIndexOutsideQuotes(source.slice(lt));
+			if (rel === -1) return null;
+			depth++;
+			i = lt + rel + 1;
+			continue;
+		}
+		i = lt + 1;
+	}
+	return {
+		raw: source.slice(openStart),
+		end: source.length
+	};
+}
 function parseBasicBlockToken(tokens, index, options) {
 	const token = tokens[index];
 	switch (token.type) {
@@ -10306,10 +10599,37 @@ function parseBasicBlockToken(tokens, index, options) {
 				if (new Set(options.customHtmlTags.map((t) => {
 					const m = String(t ?? "").trim().match(/^[<\s/]*([A-Z][\w-]*)/i);
 					return m ? m[1].toLowerCase() : "";
-				}).filter(Boolean)).has(htmlBlockNode.tag)) return [{
-					...htmlBlockNode,
-					type: htmlBlockNode.tag
-				}, index + 1];
+				}).filter(Boolean)).has(htmlBlockNode.tag)) {
+					const tag = htmlBlockNode.tag;
+					const fromSource = findNextCustomHtmlBlockFromSource(String(options?.__sourceMarkdown ?? ""), tag, Number(options?.__customHtmlBlockCursor ?? 0));
+					if (fromSource) options.__customHtmlBlockCursor = fromSource.end;
+					const rawHtml = String(fromSource?.raw ?? htmlBlockNode.content ?? "");
+					const openEnd = findTagCloseIndexOutsideQuotes(rawHtml);
+					const closeMatch = new RegExp(`<\\s*\\/\\s*${tag}\\s*>`, "i").exec(rawHtml);
+					const closeIndex = closeMatch ? closeMatch.index : -1;
+					let inner = "";
+					if (openEnd !== -1) if (closeIndex !== -1 && openEnd < closeIndex) inner = rawHtml.slice(openEnd + 1, closeIndex);
+					else inner = rawHtml.slice(openEnd + 1);
+					if (closeIndex === -1) inner = stripTrailingPartialClosingTag(inner, tag);
+					const attrs = [];
+					const openTag = openEnd !== -1 ? rawHtml.slice(0, openEnd + 1) : rawHtml;
+					const attrRegex = /\s([\w:-]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+)))?/g;
+					let m;
+					while ((m = attrRegex.exec(openTag)) !== null) {
+						const name = m[1];
+						if (!name || name.toLowerCase() === tag) continue;
+						const value = m[2] || m[3] || m[4] || "";
+						attrs.push([name, value]);
+					}
+					return [{
+						type: tag,
+						tag,
+						content: stripWrapperNewlines(inner),
+						raw: String(fromSource?.raw ?? htmlBlockNode.raw ?? rawHtml),
+						loading: htmlBlockNode.loading,
+						attrs: attrs.length ? attrs : void 0
+					}, index + 1];
+				}
 			}
 			return [htmlBlockNode, index + 1];
 		}
@@ -10623,18 +10943,51 @@ function parseParagraph(tokens, index, options) {
 
 //#endregion
 //#region src/parser/index.ts
+function stripDanglingHtmlLikeTail(markdown) {
+	const s = String(markdown ?? "");
+	const lastLt = s.lastIndexOf("<");
+	if (lastLt === -1) return s;
+	const tail = s.slice(lastLt);
+	if (tail.includes(">")) return s;
+	if (!/^<\s*(?:\/\s*)?[A-Z!][\s\S]*$/i.test(tail)) return s;
+	return s.slice(0, lastLt);
+}
 function parseMarkdownToStructure(markdown, md, options = {}) {
 	let safeMarkdown = (markdown ?? "").toString().replace(/([^\\])\r(ight|ho)/g, "$1\\r$2").replace(/([^\\])\n(abla|eq|ot|exists)/g, "$1\\n$2");
 	if (safeMarkdown.endsWith("- *")) safeMarkdown = safeMarkdown.replace(/- \*$/, "- \\*");
-	if (/\n\s*-\s*$/.test(safeMarkdown)) safeMarkdown = safeMarkdown.replace(/\n\s*-\s*$/, "\n");
+	if (/(?:^|\n)\s*-\s*$/.test(safeMarkdown)) safeMarkdown = safeMarkdown.replace(/(?:^|\n)\s*-\s*$/, (m) => {
+		return m.startsWith("\n") ? "\n" : "";
+	});
+	else if (/(?:^|\n)\s*--\s*$/.test(safeMarkdown)) safeMarkdown = safeMarkdown.replace(/(?:^|\n)\s*--\s*$/, (m) => {
+		return m.startsWith("\n") ? "\n" : "";
+	});
+	else if (/(?:^|\n)\s*>\s*$/.test(safeMarkdown)) safeMarkdown = safeMarkdown.replace(/(?:^|\n)\s*>\s*$/, (m) => {
+		return m.startsWith("\n") ? "\n" : "";
+	});
+	else if (/\n\s*[*+]\s*$/.test(safeMarkdown)) safeMarkdown = safeMarkdown.replace(/\n\s*[*+]\s*$/, "\n");
 	else if (/\n[[(]\n*$/.test(safeMarkdown)) safeMarkdown = safeMarkdown.replace(/(\n\[|\n\()+\n*$/g, "\n");
+	if (options.customHtmlTags?.length) {
+		const tags = options.customHtmlTags.map((t) => String(t ?? "").trim()).filter(Boolean).map((t) => {
+			return (t.match(/^[<\s/]*([A-Z][\w-]*)/i)?.[1] ?? "").toLowerCase();
+		}).filter(Boolean);
+		if (tags.length) if (!safeMarkdown.includes("</")) {} else for (const tag of tags) {
+			const re = new RegExp(String.raw`(^[\t ]*<\s*\/\s*${tag}\s*>[\t ]*)(\r?\n)(?![\t ]*\r?\n|$)`, "gim");
+			safeMarkdown = safeMarkdown.replace(re, "$1$2$2");
+		}
+	}
+	safeMarkdown = stripDanglingHtmlLikeTail(safeMarkdown);
 	const tokens = md.parse(safeMarkdown, {});
 	if (!tokens || !Array.isArray(tokens)) return [];
 	const pre = options.preTransformTokens;
 	const post = options.postTransformTokens;
 	let transformedTokens = tokens;
 	if (pre && typeof pre === "function") transformedTokens = pre(transformedTokens) || transformedTokens;
-	let result = processTokens(transformedTokens, options);
+	const internalOptions = {
+		...options,
+		__sourceMarkdown: safeMarkdown,
+		__customHtmlBlockCursor: 0
+	};
+	let result = processTokens(transformedTokens, internalOptions);
 	if (post && typeof post === "function") {
 		const postResult = post(transformedTokens);
 		if (Array.isArray(postResult)) {
@@ -10692,6 +11045,20 @@ function processTokens(tokens, options) {
 				result.push(parseHardBreak());
 				i++;
 				break;
+			case "text": {
+				const content = String(token.content ?? "");
+				result.push({
+					type: "paragraph",
+					raw: content,
+					children: content ? [{
+						type: "text",
+						content,
+						raw: content
+					}] : []
+				});
+				i++;
+				break;
+			}
 			case "inline":
 				result.push(...parseInlineTokens(token.children || [], String(token.content ?? ""), void 0, {
 					requireClosingStrong: options?.requireClosingStrong,