markdown-codec 11.1.12 → 11.1.14

package/dist/block-C3ftt8qO.js

@@ -0,0 +1,610 @@
+import { BlockNode, canContain, suppressesBlockStarts } from "./block/node.js";
+import { MarkdownDiagnosticCodes, MarkdownNestingLimitExceededError, NOOP_MARKDOWN_DIAGNOSTIC_SINK } from "./diagnostics/diagnostics.js";
+import { matchHtmlBlockStart, matchesHtmlBlockEnd } from "./html/html.js";
+import { unescapeString } from "./inline/entity.js";
+import { matchFootnoteDefinitionMarker } from "./inline/footnote.js";
+import { parseInlines } from "./inline/inline.js";
+import { LINE_ENDING_PATTERN } from "./shared/line-ending.js";
+import "./defaults/defaults.js";
+import { LineCursor } from "./block/line.js";
+import { finalizeListTightness, listsMatch, parseListMarker } from "./block/list.js";
+import { fitRowToColumns, parseTableDelimiterRow, splitTableRow } from "./block/table.js";
+import { extractDefinitions } from "./block/definitions.js";
+//#region src/block/parser.ts
+var BlockParser = class {
+	references = /* @__PURE__ */ new Map();
+	footnotes = /* @__PURE__ */ new Set();
+	document = new BlockNode("document", 1);
+	tables;
+	footnotesEnabled;
+	sink;
+	maxNesting;
+	tip = this.document;
+	oldTip = this.document;
+	lastMatchedContainer = this.document;
+	line;
+	lineNumber = 0;
+	nestingDepth = 0;
+	constructor(options) {
+		this.tables = options.gfmTables ?? true;
+		this.footnotesEnabled = options.footnotes ?? true;
+		this.sink = options.sink ?? NOOP_MARKDOWN_DIAGNOSTIC_SINK;
+		this.maxNesting = options.maxNesting ?? 250;
+	}
+	parse(source) {
+		const lines = source.split(LINE_ENDING_PATTERN);
+		const count = source.endsWith("\n") || source.endsWith("\r") ? lines.length - 1 : lines.length;
+		for (let index = 0; index < count; index += 1) {
+			const text = lines[index];
+			if (text !== void 0) this.incorporateLine(text);
+		}
+		while (this.tip !== this.document) {
+			this.reportUnterminatedAtEof(this.tip);
+			this.finalize(this.tip);
+		}
+		return this.document;
+	}
+	reportUnterminatedAtEof(node) {
+		if (node.fenced) {
+			this.sink({
+				code: MarkdownDiagnosticCodes.UNCLOSED_FENCE,
+				severity: "warning",
+				message: `fenced code block starting at line ${String(node.startLine)} was never closed by a matching closing fence before the end of the document`,
+				line: node.startLine
+			});
+			return;
+		}
+		if (node.kind === "htmlBlock" && !HTML_BLOCK_BLANK_LINE_END_TYPES.includes(node.htmlBlockType)) {
+			this.sink({
+				code: MarkdownDiagnosticCodes.UNTERMINATED_HTML_BLOCK,
+				severity: "warning",
+				message: `HTML block (type ${String(node.htmlBlockType)}) starting at line ${String(node.startLine)} never met its own end condition before the end of the document`,
+				line: node.startLine
+			});
+			return;
+		}
+		if (node.kind === "mathBlock") this.sink({
+			code: MarkdownDiagnosticCodes.UNCLOSED_MATH_BLOCK,
+			severity: "warning",
+			message: `math block starting at line ${String(node.startLine)} was never closed by a matching closing $$ before the end of the document`,
+			line: node.startLine
+		});
+	}
+	incorporateLine(rawText) {
+		this.lineNumber += 1;
+		this.line = new LineCursor(rawText.replace(NUL_PATTERN, "�"));
+		this.oldTip = this.tip;
+		const matched = this.walkOpenBlocks();
+		if (matched === void 0) return;
+		this.lastMatchedContainer = matched;
+		this.addTextToContainer(this.openNewBlocks(matched));
+	}
+	walkOpenBlocks() {
+		let container = this.document;
+		for (;;) {
+			const lastChild = container.lastChild;
+			if (lastChild?.open !== true) return container;
+			this.line.findNextNonspace();
+			const result = this.continueBlock(lastChild);
+			if (result !== "matched") return result === "finished" ? void 0 : container;
+			container = lastChild;
+		}
+	}
+	continueBlock(node) {
+		switch (node.kind) {
+			case "document":
+			case "list": return "matched";
+			case "blockquote": return this.continueBlockquote();
+			case "listItem": return this.continueListItem(node);
+			case "footnoteDefinition": return this.continueFootnoteDefinition(node);
+			case "codeBlock": return this.continueCodeBlock(node);
+			case "mathBlock": return this.continueMathBlock(node);
+			case "htmlBlock": return this.line.blank && HTML_BLOCK_BLANK_LINE_END_TYPES.includes(node.htmlBlockType) ? "not-matched" : "matched";
+			case "paragraph":
+			case "table": return this.line.blank ? "not-matched" : "matched";
+			case "heading":
+			case "thematicBreak": return "not-matched";
+		}
+		return assertNeverBlockKind(node.kind);
+	}
+	continueBlockquote() {
+		if (!this.consumeBlockquoteMarker()) return "not-matched";
+		return "matched";
+	}
+	consumeBlockquoteMarker() {
+		if (this.line.indented || this.line.peekNextNonspace() !== ">") return false;
+		this.line.advanceToNextNonspace();
+		this.line.advance(1);
+		if (this.line.peek() === " ") this.line.advance(1);
+		return true;
+	}
+	continueListItem(node) {
+		const listData = node.listData;
+		if (listData === void 0) return "not-matched";
+		if (this.line.blank) {
+			if (node.children.length === 0) return "not-matched";
+			this.line.advanceToNextNonspace();
+			return "matched";
+		}
+		if (this.line.indent >= listData.markerOffset + listData.padding) {
+			this.line.advance(listData.markerOffset + listData.padding);
+			return "matched";
+		}
+		return "not-matched";
+	}
+	continueFootnoteDefinition(node) {
+		if (this.line.blank) {
+			if (node.children.length === 0) return "not-matched";
+			this.line.advanceToNextNonspace();
+			return "matched";
+		}
+		if (this.line.indent >= 4) {
+			this.line.advance(4);
+			return "matched";
+		}
+		return "not-matched";
+	}
+	continueCodeBlock(node) {
+		if (!node.fenced) {
+			if (this.line.indent >= 4) {
+				this.line.advance(4);
+				return "matched";
+			}
+			if (this.line.blank) {
+				this.line.advanceToNextNonspace();
+				return "matched";
+			}
+			return "not-matched";
+		}
+		const rest = this.line.restFromNextNonspace();
+		const closing = this.line.indented || !rest.startsWith(node.fenceChar) ? null : CLOSING_CODE_FENCE_PATTERN.exec(rest);
+		if (closing !== null && closing[0].length >= node.fenceLength) {
+			this.finalize(node);
+			return "finished";
+		}
+		for (let remaining = node.fenceOffset; remaining > 0 && this.line.peek() === " "; remaining -= 1) this.line.advance(1);
+		return "matched";
+	}
+	continueMathBlock(node) {
+		if (!this.line.indented && MATH_BLOCK_MARKER_PATTERN.test(this.line.restFromNextNonspace())) {
+			this.finalize(node);
+			return "finished";
+		}
+		return "matched";
+	}
+	openNewBlocks(matchedContainer) {
+		let container = matchedContainer;
+		let matchedLeaf = suppressesBlockStarts(container.kind);
+		while (!matchedLeaf) {
+			this.line.findNextNonspace();
+			const result = this.tryBlockStart(container);
+			if (result === "none") {
+				this.line.advanceToNextNonspace();
+				break;
+			}
+			container = this.tip;
+			matchedLeaf = result === "leaf";
+		}
+		return container;
+	}
+	tryBlockStart(container) {
+		const starts = [
+			() => this.tryBlockquoteStart(),
+			() => this.tryAtxHeadingStart(),
+			() => this.tryCodeFenceStart(),
+			() => this.tryMathBlockStart(),
+			() => this.tryFootnoteDefinitionStart(container),
+			() => this.tryHtmlBlockStart(),
+			() => this.tryPromoteParagraph(container),
+			() => this.tryThematicBreakStart(),
+			() => this.tryListItemStart(container),
+			() => this.tryIndentedCodeStart()
+		];
+		for (const start of starts) {
+			const result = start();
+			if (result !== "none") return result;
+		}
+		return "none";
+	}
+	tryBlockquoteStart() {
+		if (!this.consumeBlockquoteMarker()) return "none";
+		this.closeUnmatchedBlocks();
+		this.addChild("blockquote");
+		return "container";
+	}
+	tryAtxHeadingStart() {
+		if (this.line.indented) return "none";
+		const rest = this.line.restFromNextNonspace();
+		const match = ATX_MARKER_PATTERN.exec(rest);
+		if (match === null) return "none";
+		this.closeUnmatchedBlocks();
+		const heading = this.addChild("heading");
+		heading.level = headingLevelOf(match[0].trim().length);
+		heading.content = rest.slice(match[0].length).replace(ATX_ONLY_CLOSING_SEQUENCE_PATTERN, "").replace(ATX_TRAILING_CLOSING_SEQUENCE_PATTERN, "");
+		this.line.advanceToEndOfLine();
+		return "leaf";
+	}
+	tryCodeFenceStart() {
+		if (this.line.indented) return "none";
+		const match = CODE_FENCE_PATTERN.exec(this.line.restFromNextNonspace());
+		if (match === null) return "none";
+		const fence = match[0];
+		const fenceChar = fence.charAt(0);
+		if (fenceChar !== "`" && fenceChar !== "~") return "none";
+		this.closeUnmatchedBlocks();
+		const block = this.addChild("codeBlock");
+		block.fenced = true;
+		block.fenceChar = fenceChar;
+		block.fenceLength = fence.length;
+		block.fenceOffset = this.line.indent;
+		this.line.advanceToNextNonspace();
+		this.line.advance(fence.length);
+		return "leaf";
+	}
+	tryMathBlockStart() {
+		if (this.line.indented) return "none";
+		if (!MATH_BLOCK_MARKER_PATTERN.test(this.line.restFromNextNonspace())) return "none";
+		this.closeUnmatchedBlocks();
+		this.addChild("mathBlock");
+		this.line.advanceToEndOfLine();
+		return "leaf";
+	}
+	tryFootnoteDefinitionStart(container) {
+		if (!this.footnotesEnabled || this.line.indented || !this.footnoteDefinitionMayOpenIn(container)) return "none";
+		const marker = matchFootnoteDefinitionMarker(this.line.restFromNextNonspace());
+		if (marker === void 0) return "none";
+		if (this.footnotes.has(marker.label)) this.sink({
+			code: MarkdownDiagnosticCodes.DUPLICATE_FOOTNOTE_DEFINITION,
+			severity: "warning",
+			message: `footnote "${marker.label}" was already defined earlier in the document; every reference resolves to the first definition, and both definitions are kept as written`,
+			line: this.lineNumber
+		});
+		this.footnotes.add(marker.label);
+		this.line.advanceToNextNonspace();
+		this.closeUnmatchedBlocks();
+		const node = this.addChild("footnoteDefinition");
+		node.footnoteLabel = marker.label;
+		this.line.advance(marker.markerLength);
+		return "container";
+	}
+	footnoteDefinitionMayOpenIn(container) {
+		let node = container;
+		while (node?.kind === "list") node = node.parent;
+		return node?.kind === "document" || node?.kind === "blockquote" || node?.kind === "listItem";
+	}
+	tryHtmlBlockStart() {
+		if (this.line.indented) return "none";
+		const interruptsParagraph = this.tip.kind === "paragraph";
+		const type = matchHtmlBlockStart(this.line.restFromNextNonspace(), interruptsParagraph);
+		if (type === void 0) return "none";
+		this.closeUnmatchedBlocks();
+		this.addChild("htmlBlock").htmlBlockType = type;
+		return "leaf";
+	}
+	tryPromoteParagraph(container) {
+		if (this.line.indented || container.kind !== "paragraph") return "none";
+		const setext = this.trySetextHeading(container);
+		return setext === "none" ? this.tryTableHeader(container) : setext;
+	}
+	trySetextHeading(paragraph) {
+		const match = SETEXT_UNDERLINE_PATTERN.exec(this.line.restFromNextNonspace());
+		if (match === null) return "none";
+		paragraph.content = extractDefinitions(paragraph.content, this.references, this.sink, paragraph.startLine);
+		if (isBlankContent(paragraph.content)) return "none";
+		const heading = new BlockNode("heading", paragraph.startLine);
+		heading.level = match[0].startsWith("=") ? 1 : 2;
+		heading.setext = true;
+		heading.content = paragraph.content;
+		paragraph.replaceWith(heading);
+		this.tip = heading;
+		this.line.advanceToEndOfLine();
+		return "leaf";
+	}
+	tryTableHeader(paragraph) {
+		if (!this.tables) return "none";
+		const alignments = parseTableDelimiterRow(this.line.restFromNextNonspace());
+		if (alignments === void 0) return "none";
+		const lines = paragraph.content.split("\n");
+		const secondToLastLineOffset = -2;
+		const headerLine = lines.at(secondToLastLineOffset);
+		if (headerLine === void 0 || splitTableRow(headerLine).length !== alignments.length) return "none";
+		paragraph.content = lines.slice(0, secondToLastLineOffset).map((text) => `${text}\n`).join("");
+		const table = this.addChild("table");
+		table.alignments = alignments;
+		table.headerLine = headerLine;
+		this.line.advanceToEndOfLine();
+		return "leaf";
+	}
+	tryThematicBreakStart() {
+		if (this.line.indented || !THEMATIC_BREAK_PATTERN.test(this.line.restFromNextNonspace())) return "none";
+		this.closeUnmatchedBlocks();
+		this.addChild("thematicBreak");
+		this.line.advanceToEndOfLine();
+		return "leaf";
+	}
+	tryListItemStart(container) {
+		const data = parseListMarker(this.line, container.kind === "paragraph");
+		if (data === void 0) return "none";
+		this.closeUnmatchedBlocks();
+		const openList = this.tip.listData;
+		if (this.tip.kind !== "list" || openList === void 0 || !listsMatch(openList, data)) this.addChild("list").listData = data;
+		this.addChild("listItem").listData = data;
+		return "container";
+	}
+	tryIndentedCodeStart() {
+		if (!this.line.indented || this.tip.kind === "paragraph" || this.line.blank) return "none";
+		this.line.advance(4);
+		this.closeUnmatchedBlocks();
+		this.addChild("codeBlock");
+		return "leaf";
+	}
+	addTextToContainer(container) {
+		if (this.tip.kind === "paragraph" && !this.line.blank) {
+			this.addLine();
+			return;
+		}
+		this.closeUnmatchedBlocks();
+		const lastChild = container.lastChild;
+		if (this.line.blank && lastChild !== void 0) lastChild.lastLineBlank = true;
+		this.recordBlankLineForTightness(container);
+		if (suppressesBlockStarts(container.kind) || container.kind === "table") {
+			this.addLine();
+			if (container.kind === "htmlBlock" && matchesHtmlBlockEnd(this.line.rest(), container.htmlBlockType)) this.finalize(container);
+			return;
+		}
+		if (!this.line.atEnd && !this.line.blank) {
+			this.addChild("paragraph");
+			this.addLine();
+		}
+	}
+	recordBlankLineForTightness(container) {
+		const blank = this.line.blank && !(container.kind === "blockquote" || container.fenced || container.kind === "listItem");
+		for (let node = container; node !== void 0; node = node.parent) node.lastLineBlank = blank;
+	}
+	addLine() {
+		this.tip.content += `${this.line.rest()}
+`;
+	}
+	addChild(kind) {
+		while (!canContain(this.tip.kind, kind)) this.finalize(this.tip);
+		if (this.nestingDepth >= this.maxNesting) throw new MarkdownNestingLimitExceededError(this.maxNesting);
+		const node = new BlockNode(kind, this.lineNumber);
+		this.tip.appendChild(node);
+		this.tip = node;
+		this.nestingDepth += 1;
+		return node;
+	}
+	closeUnmatchedBlocks() {
+		while (this.oldTip !== this.lastMatchedContainer) {
+			const parent = this.oldTip.parent;
+			this.finalize(this.oldTip);
+			if (parent === void 0) break;
+			this.oldTip = parent;
+		}
+	}
+	finalize(node) {
+		const above = node.parent;
+		node.open = false;
+		this.finalizeContent(node);
+		this.nestingDepth -= 1;
+		this.tip = above ?? this.document;
+	}
+	finalizeContent(node) {
+		switch (node.kind) {
+			case "paragraph":
+				node.content = extractDefinitions(node.content, this.references, this.sink, node.startLine);
+				if (isBlankContent(node.content)) node.unlink();
+				return;
+			case "codeBlock":
+				this.finalizeCodeBlock(node);
+				return;
+			case "mathBlock":
+				this.finalizeMathBlock(node);
+				return;
+			case "htmlBlock":
+				node.literal = node.content.replace(TRAILING_HTML_BLANK_LINES_PATTERN, "");
+				return;
+			case "list":
+				finalizeListTightness(node);
+				return;
+			default: return;
+		}
+	}
+	finalizeCodeBlock(node) {
+		if (!node.fenced) {
+			node.literal = node.content.replace(TRAILING_BLANK_LINES_PATTERN, "\n");
+			return;
+		}
+		const breakIndex = node.content.indexOf("\n");
+		node.infoString = unescapeString(node.content.slice(0, breakIndex).trim());
+		node.literal = node.content.slice(breakIndex + 1);
+	}
+	finalizeMathBlock(node) {
+		node.literal = node.content.slice(1);
+	}
+};
+//#endregion
+//#region src/block/block.ts
+const TASK_LIST_MARKER_PATTERN = /^\[([ xX])\][ \t]/;
+const NUL_REPLACEMENT = "�";
+const NUL_PATTERN = /\0/g;
+const ATX_MARKER_PATTERN = /^#{1,6}(?:[ \t]+|$)/;
+const ATX_ONLY_CLOSING_SEQUENCE_PATTERN = /^[ \t]*#+[ \t]*$/;
+const ATX_TRAILING_CLOSING_SEQUENCE_PATTERN = /[ \t]+#+[ \t]*$/;
+const CODE_FENCE_PATTERN = /^`{3,}(?!.*`)|^~{3,}/;
+const CLOSING_CODE_FENCE_PATTERN = /^(?:`{3,}|~{3,})(?=[ \t]*$)/;
+const MATH_BLOCK_MARKER_PATTERN = /^\$\$[ \t]*$/;
+const ACCUMULATED_LINE_ENDING = "\n";
+const SETEXT_UNDERLINE_PATTERN = /^(?:=+|-+)[ \t]*$/;
+const THEMATIC_BREAK_PATTERN = /^(?:\*[ \t]*){3,}$|^(?:_[ \t]*){3,}$|^(?:-[ \t]*){3,}$/;
+const BLANK_CONTENT_PATTERN = /^[ \t\n]*$/;
+const TRAILING_BLANK_LINES_PATTERN = /(?:\n[ \t]*)+$/;
+const TRAILING_HTML_BLANK_LINES_PATTERN = /(?:\n *)+$/;
+const MAX_HEADING_LEVEL = 6;
+const SETEXT_LEVEL_1 = 1;
+const SETEXT_LEVEL_2 = 2;
+const HTML_BLOCK_BLANK_LINE_END_TYPES = [6, 7];
+function isBlankContent(content) {
+	return BLANK_CONTENT_PATTERN.test(content);
+}
+function headingLevelOf(hashes) {
+	if (hashes >= 1 && hashes < MAX_HEADING_LEVEL) return hashes;
+	return MAX_HEADING_LEVEL;
+}
+const BLOCK_EDGE_SPACE_OR_TAB_PATTERN = /^[ \t]+|[ \t]+$/g;
+function trimBlockContent(text) {
+	return (text.endsWith("\n") ? text.slice(0, -1) : text).replace(BLOCK_EDGE_SPACE_OR_TAB_PATTERN, "");
+}
+function toInlineChildren(content, context) {
+	return parseInlines(trimBlockContent(content), context.references, context.footnotes, context.options);
+}
+function toHeadingNode(node, context) {
+	return {
+		type: "heading",
+		level: node.level,
+		style: node.setext ? "setext" : "atx",
+		children: toInlineChildren(node.content, context)
+	};
+}
+function extractTaskListMarker(itemChildren) {
+	const first = itemChildren[0];
+	if (first?.kind !== "paragraph") return;
+	const match = TASK_LIST_MARKER_PATTERN.exec(first.content);
+	if (match === null) return;
+	first.content = first.content.slice(match[0].length);
+	return match[1] !== " ";
+}
+function toListItemNode(item, context) {
+	const checked = context.options.gfmTaskLists ?? true ? extractTaskListMarker(item.children) : void 0;
+	return checked === void 0 ? {
+		type: "listItem",
+		children: toAstBlocks(item.children, context)
+	} : {
+		type: "listItem",
+		checked,
+		children: toAstBlocks(item.children, context)
+	};
+}
+function toListNode(node, context) {
+	const children = node.children.map((item) => toListItemNode(item, context));
+	const data = node.listData;
+	if (data?.type === "ordered") return {
+		type: "list",
+		markerType: "ordered",
+		orderedDelimiter: data.delimiter,
+		start: data.start,
+		tight: node.tight,
+		children
+	};
+	return {
+		type: "list",
+		markerType: "bullet",
+		bulletMarker: data?.bulletChar,
+		tight: node.tight,
+		children
+	};
+}
+function toTableRow(cells, header, context) {
+	return {
+		type: "tableRow",
+		header,
+		children: cells.map((cell) => ({
+			type: "tableCell",
+			children: toInlineChildren(cell, context)
+		}))
+	};
+}
+function toTableNode(node, context) {
+	const sink = context.options.sink ?? NOOP_MARKDOWN_DIAGNOSTIC_SINK;
+	const columnCount = node.alignments.length;
+	const rows = [toTableRow(fitRowToColumns(splitTableRow(node.headerLine), columnCount), true, context)];
+	for (const rowLine of node.content.split("\n")) {
+		if (rowLine.length === 0) continue;
+		const cells = splitTableRow(rowLine);
+		if (cells.length !== columnCount) sink({
+			code: MarkdownDiagnosticCodes.TABLE_CELL_COUNT_MISMATCH,
+			severity: "warning",
+			message: `table row has ${String(cells.length)} cell(s), but the header row declares ${String(columnCount)}; the row is padded with empty cells or truncated to fit`,
+			line: node.startLine
+		});
+		rows.push(toTableRow(fitRowToColumns(cells, columnCount), false, context));
+	}
+	return {
+		type: "table",
+		alignments: node.alignments,
+		children: rows
+	};
+}
+function toAstBlock(node, context) {
+	switch (node.kind) {
+		case "paragraph": return {
+			type: "paragraph",
+			children: toInlineChildren(node.content, context)
+		};
+		case "heading": return toHeadingNode(node, context);
+		case "blockquote": return {
+			type: "blockquote",
+			children: toAstBlocks(node.children, context)
+		};
+		case "list": return toListNode(node, context);
+		case "footnoteDefinition": return {
+			type: "footnoteDefinition",
+			label: node.footnoteLabel,
+			children: toAstBlocks(node.children, context)
+		};
+		case "codeBlock": return node.fenced ? {
+			type: "codeBlock",
+			fenced: true,
+			fenceChar: node.fenceChar,
+			infoString: node.infoString,
+			literal: node.literal
+		} : {
+			type: "codeBlock",
+			fenced: false,
+			literal: node.literal
+		};
+		case "htmlBlock": return {
+			type: "htmlBlock",
+			literal: node.literal
+		};
+		case "thematicBreak": return { type: "thematicBreak" };
+		case "mathBlock": return {
+			type: "mathBlock",
+			literal: node.literal
+		};
+		case "table": return toTableNode(node, context);
+		case "document":
+		case "listItem": return;
+	}
+	return assertNeverBlockKind(node.kind);
+}
+function toAstBlocks(nodes, context) {
+	const blocks = [];
+	for (const node of nodes) {
+		const converted = toAstBlock(node, context);
+		if (converted !== void 0) blocks.push(converted);
+	}
+	return blocks;
+}
+function parseMarkdown(source, options = {}) {
+	const parser = new BlockParser(options);
+	const root = parser.parse(source);
+	const context = {
+		references: parser.references,
+		footnotes: parser.footnotes,
+		options
+	};
+	return {
+		document: {
+			type: "document",
+			children: toAstBlocks(root.children, context)
+		},
+		references: context.references,
+		footnotes: context.footnotes
+	};
+}
+function assertNeverBlockKind(kind) {
+	throw new Error(`markdown-codec: unhandled block kind ${JSON.stringify(kind)}`);
+}
+//#endregion
+export { BlockParser as C, trimBlockContent as S, TRAILING_HTML_BLANK_LINES_PATTERN as _, CLOSING_CODE_FENCE_PATTERN as a, isBlankContent as b, MATH_BLOCK_MARKER_PATTERN as c, SETEXT_LEVEL_1 as d, SETEXT_LEVEL_2 as f, TRAILING_BLANK_LINES_PATTERN as g, THEMATIC_BREAK_PATTERN as h, ATX_TRAILING_CLOSING_SEQUENCE_PATTERN as i, NUL_PATTERN as l, TASK_LIST_MARKER_PATTERN as m, ATX_MARKER_PATTERN as n, CODE_FENCE_PATTERN as o, SETEXT_UNDERLINE_PATTERN as p, ATX_ONLY_CLOSING_SEQUENCE_PATTERN as r, HTML_BLOCK_BLANK_LINE_END_TYPES as s, ACCUMULATED_LINE_ENDING as t, NUL_REPLACEMENT as u, assertNeverBlockKind as v, parseMarkdown as x, headingLevelOf as y };