@localix-ai/flowdown 0.0.0-stage → 0.5.1

package/dist/engine/blocks.js

@@ -0,0 +1,785 @@
+import { unescapeString } from "./entities.js";
+import { CLOSETAG, OPENTAG, normalizeLabel, parseInlines, parseReference } from "./inlines.js";
+// src/engine/blocks.ts
+/**
+* The block pass: a document read line by line into its blocks, by the algorithm in the
+* CommonMark spec. Each line is matched against the containers still open (a quote's `>`, a list
+* item's indent), then tried as the start of a new block, then added to the block it belongs to.
+* The text of paragraphs, headings and cells is kept as written; the inline pass reads it once
+* the whole document is known, since a link can refer to a definition further down.
+*/
+const C_TAB = 9;
+const C_SPACE = 32;
+const C_HASH = 35;
+const C_DOLLAR = 36;
+const C_ASTERISK = 42;
+const C_PLUS = 43;
+const C_DASH = 45;
+const C_COLON = 58;
+const C_LESSTHAN = 60;
+const C_EQUALS = 61;
+const C_GREATERTHAN = 62;
+const C_OPEN_BRACKET = 91;
+const C_BACKSLASH = 92;
+const C_UNDERSCORE = 95;
+const C_BACKTICK = 96;
+const C_PIPE = 124;
+const C_TILDE = 126;
+const reHtmlBlockOpen = [
+	/./,
+	/^<(?:script|pre|textarea|style)(?:\s|>|$)/i,
+	/^<!--/,
+	/^<[?]/,
+	/^<![A-Za-z]/,
+	/^<!\[CDATA\[/,
+	/^<[/]?(?:address|article|aside|base|basefont|blockquote|body|caption|center|col|colgroup|dd|details|dialog|dir|div|dl|dt|fieldset|figcaption|figure|footer|form|frame|frameset|h[123456]|head|header|hr|html|iframe|legend|li|link|main|menu|menuitem|nav|noframes|ol|optgroup|option|p|param|search|section|summary|table|tbody|td|tfoot|th|thead|title|tr|track|ul)(?:\s|[/]?[>]|$)/i,
+	new RegExp(`^(?:${OPENTAG}|${CLOSETAG})\\s*$`, "i")
+];
+const reHtmlBlockClose = [
+	/./,
+	/<\/(?:script|pre|textarea|style)>/i,
+	/-->/,
+	/\?>/,
+	/>/,
+	/\]\]>/
+];
+const reThematicBreak = /^(?:\*[ \t]*){3,}$|^(?:_[ \t]*){3,}$|^(?:-[ \t]*){3,}$/;
+const reOrderedListMarker = /^(\d{1,9})([.)])/;
+const reAtxHeadingMarker = /^#{1,6}(?:[ \t]+|$)/;
+const reCodeFence = /^`{3,}(?!.*`)|^~{3,}/;
+const reClosingCodeFence = /^(?:`{3,}|~{3,})(?=[ \t]*$)/;
+/** A display formula's fence, read only when an extension asks for it: `$$` alone on its line. */
+const reMathFence = /^\${2,}(?!.*\$)/;
+const reClosingMathFence = /^\${2,}(?=[ \t]*$)/;
+const reSetextHeadingLine = /^(?:=+|-+)[ \t]*$/;
+const reLineEnding = /\r\n|\n|\r/g;
+const reTableDelimiterCell = /^[ \t]*(:?)-+(:?)[ \t]*$/;
+const reFootnoteDefinition = /^\[\^([^\]\s]+)\]:[ \t]*/;
+const reTaskMarker = /^\[([ xX])\](?=[ \t\n])/;
+const isSpaceOrTab = (code) => code === C_SPACE || code === C_TAB;
+/**
+* How deep blocks may hold blocks. A quote in a quote in a list is three; a hundred is past
+* anything written to be read, and it bounds the depth of the tree every pass after this one
+* walks: without it a line of twenty thousand `>` overflowed the stack. A line that would go
+* deeper is read as text of the block it is in.
+*/
+const MAX_NESTING = 100;
+/** Whether a block holds other blocks; a list holds only items. */
+const isContainer = (type) => type === "root" || type === "blockquote" || type === "item" || type === "list" || type === "footnoteDefinition";
+/** Whether a block takes the lines after its first as they are. */
+const acceptsLines = (type) => type === "paragraph" || type === "code" || type === "html";
+/**
+* A table row cut into its cells: on each `|` that is not escaped, without the outer pipes. Each
+* cell is one cut of the row, joined from pieces only where an escaped pipe (`\\|`) is taken out.
+*/
+const splitRow = (row) => {
+	const cells = [];
+	let line = row.trim();
+	if (line.charCodeAt(0) === C_PIPE) line = line.slice(1);
+	/** The cell's text before `from`: what came before an escaped pipe, and that pipe. */
+	let cell = "";
+	let from = 0;
+	for (let pipe = line.indexOf("|"); pipe !== -1; pipe = line.indexOf("|", pipe + 1)) {
+		if (pipe > 0 && line.charCodeAt(pipe - 1) === C_BACKSLASH) cell += `${line.slice(from, pipe - 1)}|`;
+		else {
+			cells.push((cell + line.slice(from, pipe)).trim());
+			cell = "";
+		}
+		from = pipe + 1;
+	}
+	const last = (cell + line.slice(from)).trim();
+	if (last !== "" || line.charCodeAt(line.length - 1) !== C_PIPE || line === "") cells.push(last);
+	return cells;
+};
+/** The alignments a table's delimiter row (`| :-- | --: |`) gives, or null when it is not one. */
+const parseDelimiterRow = (row) => {
+	if (row.indexOf("|") === -1) return null;
+	const cells = splitRow(row);
+	const align = [];
+	for (const cell of cells) {
+		const found = reTableDelimiterCell.exec(cell);
+		if (found === null) return null;
+		align.push(found[1] ? found[2] ? "center" : "left" : found[2] ? "right" : null);
+	}
+	return align.length === 0 ? null : align;
+};
+/** Parses a whole document into its tree. */
+const parseBlocks = (input, context) => {
+	const gfm = context.gfm;
+	const starts = [];
+	const ends = [];
+	const onlyLf = input.indexOf("\r") === -1;
+	if (onlyLf) for (let at = 0;;) {
+		const ending = input.indexOf("\n", at);
+		starts.push(at);
+		if (ending === -1) {
+			ends.push(input.length);
+			break;
+		}
+		ends.push(ending);
+		at = ending + 1;
+	}
+	else for (let at = 0;;) {
+		reLineEnding.lastIndex = at;
+		const ending = reLineEnding.exec(input);
+		starts.push(at);
+		if (ending === null) {
+			ends.push(input.length);
+			break;
+		}
+		ends.push(ending.index);
+		at = ending.index + ending[0].length;
+	}
+	let count = starts.length;
+	if (count > 0 && starts[count - 1] === ends[count - 1]) count--;
+	/** No NUL in the document: a line is then the document's own text, with nothing to replace. */
+	const noNul = input.indexOf("\0") === -1;
+	const block = (type, startLine) => ({
+		type,
+		parent: null,
+		children: [],
+		open: true,
+		lastLineBlank: false,
+		text: "",
+		startLine,
+		endLine: startLine,
+		startOffset: 0,
+		depth: 0,
+		ordered: false,
+		bullet: 0,
+		start: 0,
+		delimiter: 0,
+		padding: 0,
+		markerOffset: 0,
+		tight: true,
+		fenced: false,
+		fenceChar: 0,
+		fenceLength: 0,
+		fenceOffset: 0,
+		htmlType: 0,
+		level: 0,
+		align: null,
+		rows: null,
+		label: ""
+	});
+	const doc = block("root", 1);
+	let tip = doc;
+	let oldtip = doc;
+	let lastMatchedContainer = doc;
+	let allClosed = true;
+	let line = "";
+	let lineNumber = 0;
+	let offset = 0;
+	let column = 0;
+	let nextNonspace = 0;
+	let nextNonspaceColumn = 0;
+	let indent = 0;
+	let indented = false;
+	let blank = false;
+	let partiallyConsumedTab = false;
+	const findNextNonspace = () => {
+		let index = offset;
+		let cols = column;
+		let code = line.charCodeAt(index);
+		while (code === C_SPACE || code === C_TAB) {
+			cols += code === C_SPACE ? 1 : 4 - cols % 4;
+			code = line.charCodeAt(++index);
+		}
+		blank = index >= line.length;
+		nextNonspace = index;
+		nextNonspaceColumn = cols;
+		indent = cols - column;
+		indented = indent >= 4;
+	};
+	const advanceNextNonspace = () => {
+		offset = nextNonspace;
+		column = nextNonspaceColumn;
+		partiallyConsumedTab = false;
+	};
+	/** Moves past `amount` characters, or that many columns: a tab is up to four columns wide. */
+	const advanceOffset = (amount, columns) => {
+		let left = amount;
+		while (left > 0 && offset < line.length) if (line.charCodeAt(offset) === C_TAB) {
+			const toTab = 4 - column % 4;
+			if (columns) {
+				partiallyConsumedTab = toTab > left;
+				const step = toTab > left ? left : toTab;
+				column += step;
+				if (!partiallyConsumedTab) offset++;
+				left -= step;
+			} else {
+				partiallyConsumedTab = false;
+				column += toTab;
+				offset++;
+				left--;
+			}
+		} else {
+			partiallyConsumedTab = false;
+			offset++;
+			column++;
+			left--;
+		}
+	};
+	const addLine = () => {
+		if (partiallyConsumedTab) {
+			offset++;
+			tip.text += " ".repeat(4 - column % 4);
+		}
+		tip.text += `${line.slice(offset)}\n`;
+	};
+	const removeChild = (child) => {
+		const siblings = child.parent?.children;
+		if (siblings === void 0) return;
+		const index = siblings.lastIndexOf(child);
+		if (index !== -1) siblings.splice(index, 1);
+		child.parent = null;
+	};
+	/** Whether a block ends with a blank line before its next sibling. */
+	const gapAfter = (child, next) => next !== void 0 && child.endLine !== next.startLine - 1;
+	const takeReferences = (paragraph) => {
+		let content = paragraph.text;
+		while (content.charCodeAt(0) === C_OPEN_BRACKET) {
+			const taken = parseReference(content, context.refs);
+			if (taken === 0) break;
+			content = content.slice(taken);
+		}
+		paragraph.text = content;
+	};
+	const finalize = (closing, endLine) => {
+		const above = closing.parent;
+		closing.open = false;
+		closing.endLine = endLine;
+		switch (closing.type) {
+			case "paragraph":
+				takeReferences(closing);
+				if (/^[ \t\n]*$/.test(closing.text)) removeChild(closing);
+				break;
+			case "code":
+				if (closing.fenced) {
+					const newline = closing.text.indexOf("\n");
+					closing.label = unescapeString(closing.text.slice(0, newline).trim());
+					closing.text = closing.text.slice(newline + 1);
+				} else closing.text = closing.text.replace(/(?:\n *)+$/, "\n");
+				break;
+			case "list": {
+				const items = closing.children;
+				closing.tight = true;
+				for (let index = 0; index < items.length && closing.tight; index++) {
+					const item = items[index];
+					if (gapAfter(item, items[index + 1])) closing.tight = false;
+					const inner = item.children;
+					for (let child = 0; child < inner.length && closing.tight; child++) if (gapAfter(inner[child], inner[child + 1])) closing.tight = false;
+				}
+				const last = items[items.length - 1];
+				if (last !== void 0) closing.endLine = last.endLine;
+				break;
+			}
+			case "item": {
+				const last = closing.children[closing.children.length - 1];
+				closing.endLine = last === void 0 ? closing.startLine : last.endLine;
+				break;
+			}
+		}
+		if (above !== null) tip = above;
+	};
+	const addChild = (type) => {
+		while (!isContainer(tip.type) || tip.type === "list" && type !== "item") finalize(tip, lineNumber - 1);
+		const child = block(type, lineNumber);
+		child.startOffset = (starts[lineNumber - 1] ?? 0) + nextNonspace;
+		child.parent = tip;
+		child.depth = tip.depth + 1;
+		tip.children.push(child);
+		tip = child;
+		return child;
+	};
+	const closeUnmatchedBlocks = () => {
+		if (allClosed) return;
+		while (oldtip !== lastMatchedContainer) {
+			const parent = oldtip.parent;
+			finalize(oldtip, lineNumber - 1);
+			oldtip = parent;
+		}
+		allClosed = true;
+	};
+	/** Reads a list marker at the next non-space character into a new item's data, or null. */
+	const parseListMarker = (container) => {
+		if (indent >= 4) return null;
+		const rest = line.slice(nextNonspace);
+		const first = rest.charCodeAt(0);
+		const item = block("item", lineNumber);
+		let markerLength = 1;
+		if (first === C_ASTERISK || first === C_PLUS || first === C_DASH) item.bullet = first;
+		else {
+			const found = reOrderedListMarker.exec(rest);
+			if (found === null) return null;
+			if (container.type === "paragraph" && found[1] !== "1") return null;
+			item.ordered = true;
+			item.start = parseInt(found[1], 10);
+			item.delimiter = found[2].charCodeAt(0);
+			markerLength = found[0].length;
+		}
+		const after = line.charCodeAt(nextNonspace + markerLength);
+		if (!Number.isNaN(after) && !isSpaceOrTab(after)) return null;
+		if (container.type === "paragraph" && /^[ \t]*$/.test(line.slice(nextNonspace + markerLength))) return null;
+		advanceNextNonspace();
+		advanceOffset(markerLength, true);
+		const spacesStartColumn = column;
+		const spacesStartOffset = offset;
+		do
+			advanceOffset(1, true);
+		while (column - spacesStartColumn < 5 && isSpaceOrTab(line.charCodeAt(offset)));
+		const blankItem = offset >= line.length;
+		const spaces = column - spacesStartColumn;
+		if (spaces >= 5 || spaces < 1 || blankItem) {
+			item.padding = markerLength + 1;
+			column = spacesStartColumn;
+			offset = spacesStartOffset;
+			if (isSpaceOrTab(line.charCodeAt(offset))) advanceOffset(1, true);
+		} else item.padding = markerLength + spaces;
+		item.markerOffset = indent;
+		return item;
+	};
+	/**
+	* Whether an open block goes on with this line: 0 when it does, 1 when it does not, 2 when the
+	* line closed it and is used up.
+	*/
+	const continues = (container) => {
+		switch (container.type) {
+			case "blockquote":
+				if (indented || line.charCodeAt(nextNonspace) !== C_GREATERTHAN) return 1;
+				advanceNextNonspace();
+				advanceOffset(1, false);
+				if (isSpaceOrTab(line.charCodeAt(offset))) advanceOffset(1, true);
+				return 0;
+			case "item":
+				if (blank) {
+					if (container.children.length === 0) return 1;
+					advanceNextNonspace();
+				} else if (indent >= container.markerOffset + container.padding) advanceOffset(container.markerOffset + container.padding, true);
+				else return 1;
+				return 0;
+			case "footnoteDefinition":
+				if (blank) advanceNextNonspace();
+				else if (indent >= 4) advanceOffset(4, true);
+				else return 1;
+				return 0;
+			case "code":
+				if (container.fenced) {
+					if (indent <= 3 && line.charCodeAt(nextNonspace) === container.fenceChar) {
+						const found = (container.fenceChar === C_DOLLAR ? reClosingMathFence : reClosingCodeFence).exec(line.slice(nextNonspace));
+						if (found !== null && found[0].length >= container.fenceLength) {
+							finalize(container, lineNumber);
+							return 2;
+						}
+					}
+					let skip = container.fenceOffset;
+					while (skip > 0 && isSpaceOrTab(line.charCodeAt(offset))) {
+						advanceOffset(1, true);
+						skip--;
+					}
+				} else if (indent >= 4) advanceOffset(4, true);
+				else if (blank) advanceNextNonspace();
+				else return 1;
+				return 0;
+			case "html": return blank && (container.htmlType === 6 || container.htmlType === 7) ? 1 : 0;
+			case "paragraph":
+			case "table": return blank ? 1 : 0;
+			case "heading":
+			case "thematicBreak": return 1;
+			default: return 0;
+		}
+	};
+	/**
+	* Tries the line as the start of a new block: 0 when it starts none, 1 when it starts a
+	* container (the rest of the line is tried again), 2 when it starts a leaf.
+	*/
+	const startBlock = (container) => {
+		const first = line.charCodeAt(nextNonspace);
+		if (indented) {
+			if (tip.type !== "paragraph" && !blank) {
+				advanceOffset(4, true);
+				closeUnmatchedBlocks();
+				addChild("code");
+				return 2;
+			}
+			return 0;
+		}
+		switch (first) {
+			case C_GREATERTHAN:
+				if (container.depth >= MAX_NESTING) return 0;
+				advanceNextNonspace();
+				advanceOffset(1, false);
+				if (isSpaceOrTab(line.charCodeAt(offset))) advanceOffset(1, true);
+				closeUnmatchedBlocks();
+				addChild("blockquote");
+				return 1;
+			case C_HASH: {
+				const found = reAtxHeadingMarker.exec(line.slice(nextNonspace));
+				if (found === null) return 0;
+				advanceNextNonspace();
+				advanceOffset(found[0].length, false);
+				closeUnmatchedBlocks();
+				const heading = addChild("heading");
+				heading.level = found[0].trim().length;
+				heading.text = line.slice(offset).replace(/^[ \t]*#+[ \t]*$/, "").replace(/[ \t]+#+[ \t]*$/, "");
+				advanceOffset(line.length - offset, false);
+				return 2;
+			}
+			case C_DOLLAR:
+			case C_BACKTICK:
+			case C_TILDE: {
+				if (first === C_DOLLAR && !context.math) return 0;
+				const found = (first === C_DOLLAR ? reMathFence : reCodeFence).exec(line.slice(nextNonspace));
+				if (found === null) return 0;
+				closeUnmatchedBlocks();
+				const code = addChild("code");
+				code.fenced = true;
+				code.fenceLength = found[0].length;
+				code.fenceChar = first;
+				code.fenceOffset = indent;
+				advanceNextNonspace();
+				advanceOffset(code.fenceLength, false);
+				return 2;
+			}
+			case C_LESSTHAN: {
+				const rest = line.slice(nextNonspace);
+				for (let type = 1; type <= 7; type++) if (reHtmlBlockOpen[type].test(rest) && (type < 7 || container.type !== "paragraph" && !(!allClosed && !blank && tip.type === "paragraph"))) {
+					closeUnmatchedBlocks();
+					addChild("html").htmlType = type;
+					return 2;
+				}
+				return 0;
+			}
+		}
+		if (container.type === "paragraph") {
+			if (gfm && (first === C_PIPE || first === C_DASH || first === C_COLON)) {
+				const align = parseDelimiterRow(line.slice(nextNonspace));
+				if (align !== null) {
+					const content = container.text;
+					const cut = content.lastIndexOf("\n", content.length - 2);
+					const header = content.slice(cut + 1, -1);
+					if (splitRow(header).length === align.length) {
+						closeUnmatchedBlocks();
+						if (cut === -1) {
+							tip = container.parent;
+							removeChild(container);
+						} else {
+							container.text = content.slice(0, cut + 1);
+							finalize(container, lineNumber - 2);
+						}
+						const table = addChild("table");
+						table.startLine = lineNumber - 1;
+						table.startOffset = starts[lineNumber - 2] ?? 0;
+						table.align = align;
+						table.rows = [header];
+						advanceOffset(line.length - offset, false);
+						return 2;
+					}
+				}
+			}
+			if (first === C_EQUALS || first === C_DASH) {
+				if (reSetextHeadingLine.test(line.slice(nextNonspace))) {
+					closeUnmatchedBlocks();
+					takeReferences(container);
+					if (container.text.length > 0) {
+						container.type = "heading";
+						container.level = first === C_EQUALS ? 1 : 2;
+						advanceOffset(line.length - offset, false);
+						return 2;
+					}
+				}
+			}
+		}
+		if ((first === C_ASTERISK || first === C_DASH || first === C_UNDERSCORE) && reThematicBreak.test(line.slice(nextNonspace))) {
+			closeUnmatchedBlocks();
+			addChild("thematicBreak");
+			advanceOffset(line.length - offset, false);
+			return 2;
+		}
+		if (container.depth >= 99) return 0;
+		if (gfm && first === C_OPEN_BRACKET && line.charCodeAt(nextNonspace + 1) === 94) {
+			const found = reFootnoteDefinition.exec(line.slice(nextNonspace));
+			if (found !== null) {
+				closeUnmatchedBlocks();
+				advanceNextNonspace();
+				advanceOffset(found[0].length, false);
+				const definition = addChild("footnoteDefinition");
+				definition.label = found[1];
+				const key = normalizeLabel(`[${definition.label}]`);
+				if (!context.footnotes.has(key)) context.footnotes.set(key, definition.label);
+				return 1;
+			}
+		}
+		if (first === C_ASTERISK || first === C_PLUS || first === C_DASH || first >= 48 && first <= 57) {
+			const item = parseListMarker(container);
+			if (item === null) return 0;
+			closeUnmatchedBlocks();
+			if (tip.type !== "list" || tip.ordered !== item.ordered || tip.bullet !== item.bullet || tip.delimiter !== item.delimiter) {
+				const list = addChild("list");
+				list.ordered = item.ordered;
+				list.bullet = item.bullet;
+				list.delimiter = item.delimiter;
+				list.start = item.start;
+			}
+			const added = addChild("item");
+			added.ordered = item.ordered;
+			added.padding = item.padding;
+			added.markerOffset = item.markerOffset;
+			return 1;
+		}
+		return 0;
+	};
+	const incorporateLine = (text) => {
+		let container = doc;
+		oldtip = tip;
+		offset = 0;
+		column = 0;
+		blank = false;
+		partiallyConsumedTab = false;
+		lineNumber++;
+		line = noNul || text.indexOf("\0") === -1 ? text : text.replace(/\0/g, "�");
+		for (;;) {
+			const last = container.children[container.children.length - 1];
+			if (last === void 0 || !last.open) break;
+			container = last;
+			findNextNonspace();
+			const result = continues(container);
+			if (result === 2) return;
+			if (result === 1) {
+				container = container.parent;
+				break;
+			}
+		}
+		allClosed = container === oldtip;
+		lastMatchedContainer = container;
+		let matchedLeaf = container.type !== "paragraph" && acceptsLines(container.type);
+		while (!matchedLeaf) {
+			findNextNonspace();
+			const result = blank ? 0 : startBlock(container);
+			if (result === 0) {
+				advanceNextNonspace();
+				break;
+			}
+			container = tip;
+			if (result === 2) matchedLeaf = true;
+		}
+		if (!allClosed && !blank && tip.type === "paragraph") {
+			addLine();
+			return;
+		}
+		closeUnmatchedBlocks();
+		const type = container.type;
+		if (blank) {
+			const last = container.children[container.children.length - 1];
+			if (last !== void 0) last.lastLineBlank = true;
+		}
+		const lastLineBlank = blank && !(type === "blockquote" || type === "code" && container.fenced || type === "item" && container.children.length === 0 && container.startLine === lineNumber);
+		for (let above = container; above !== null; above = above.parent) above.lastLineBlank = lastLineBlank;
+		if (acceptsLines(type)) {
+			addLine();
+			if (type === "html" && container.htmlType >= 1 && container.htmlType <= 5 && reHtmlBlockClose[container.htmlType].test(line.slice(offset))) finalize(container, lineNumber);
+		} else if (offset < line.length && !blank) {
+			if (type === "table") container.rows.push(line.slice(offset));
+			else {
+				addChild("paragraph");
+				advanceNextNonspace();
+				addLine();
+			}
+		}
+	};
+	/**
+	* The lines of a fenced code block at the top of the document, taken without the work a line
+	* gets elsewhere: from the line after `index`, every line up to one that may close the fence
+	* goes into the code as it is written, in one cut of the document. Returns the last line taken.
+	*
+	* A line may close the fence when, after at most three spaces, it starts with the fence's
+	* character; that line, and whatever follows a fence that did not close, is read the long way.
+	*/
+	const takeFencedLines = (code, index) => {
+		const fenceChar = code.fenceChar;
+		let next = index + 1;
+		for (; next < count; next++) {
+			let at = starts[next];
+			if (input.charCodeAt(at) === C_SPACE) {
+				at++;
+				if (input.charCodeAt(at) === C_SPACE) {
+					at++;
+					if (input.charCodeAt(at) === C_SPACE) at++;
+				}
+			}
+			if (input.charCodeAt(at) === fenceChar) break;
+		}
+		const last = next - 1;
+		if (last === index) return index;
+		const taken = input.slice(starts[index + 1], ends[last]);
+		code.text += `${onlyLf ? taken : taken.replace(reLineEnding, "\n")}\n`;
+		lineNumber += last - index;
+		return last;
+	};
+	for (let index = 0; index < count; index++) {
+		incorporateLine(input.slice(starts[index], ends[index]));
+		if (tip.fenced && tip.parent === doc && tip.fenceOffset === 0 && noNul) index = takeFencedLines(tip, index);
+	}
+	while (tip !== doc) finalize(tip, count);
+	finalize(doc, count);
+	const definitions = /* @__PURE__ */ new Map();
+	const kids = (from) => {
+		const out = [];
+		for (const child of from.children) if (child.type === "footnoteDefinition") {
+			const key = normalizeLabel(`[${child.label}]`);
+			if (!definitions.has(key)) definitions.set(key, child);
+		} else out.push(build(child));
+		return out;
+	};
+	const cells = (row, align, header) => {
+		const parts = splitRow(row);
+		const children = [];
+		for (let index = 0; index < align.length; index++) children.push({
+			type: "tableCell",
+			header,
+			cellAlign: align[index] ?? null,
+			children: parseInlines(parts[index] ?? "", context)
+		});
+		return {
+			type: "tableRow",
+			children
+		};
+	};
+	/** Where a block sits in the document: from its first character to the end of its last line. */
+	const place = (from) => {
+		const last = Math.min(Math.max(from.endLine, from.startLine), starts.length);
+		const lastStart = starts[last - 1] ?? 0;
+		const length = (ends[last - 1] ?? 0) - lastStart;
+		return {
+			start: {
+				line: from.startLine,
+				column: from.startOffset - (starts[from.startLine - 1] ?? 0) + 1,
+				offset: from.startOffset
+			},
+			end: {
+				line: last,
+				column: length + 1,
+				offset: lastStart + length
+			}
+		};
+	};
+	const build = (from) => {
+		switch (from.type) {
+			case "paragraph": return {
+				type: "paragraph",
+				position: place(from),
+				children: parseInlines(from.text, context)
+			};
+			case "heading": return {
+				type: "heading",
+				depth: from.level,
+				position: place(from),
+				children: parseInlines(from.text, context)
+			};
+			case "thematicBreak": return {
+				type: "thematicBreak",
+				position: place(from)
+			};
+			case "code": {
+				if (from.fenceChar === C_DOLLAR) {
+					const node = {
+						type: "math",
+						position: place(from),
+						value: from.text.replace(/\n$/, "")
+					};
+					if (from.label !== "") node.meta = from.label;
+					return node;
+				}
+				const node = {
+					type: "code",
+					position: place(from),
+					value: from.text
+				};
+				if (from.label !== "") {
+					const space = from.label.search(/[ \t]/);
+					node.lang = space === -1 ? from.label : from.label.slice(0, space);
+					if (space !== -1) node.meta = from.label.slice(space + 1).trim();
+				}
+				return node;
+			}
+			case "html": return {
+				type: "html",
+				position: place(from),
+				value: from.text.replace(/(?:\n *)+$/, "")
+			};
+			case "table": {
+				const align = from.align;
+				const rows = from.rows;
+				return {
+					type: "table",
+					position: place(from),
+					align,
+					children: rows.map((row, index) => cells(row, align, index === 0))
+				};
+			}
+			case "list": {
+				const node = {
+					type: "list",
+					position: place(from),
+					ordered: from.ordered,
+					spread: !from.tight,
+					children: kids(from)
+				};
+				for (const item of node.children) item.spread = !from.tight;
+				if (from.ordered) node.start = from.start;
+				return node;
+			}
+			case "item": {
+				const node = {
+					type: "listItem",
+					position: place(from),
+					children: []
+				};
+				const first = from.children[0];
+				if (gfm && first !== void 0 && first.type === "paragraph") {
+					const task = reTaskMarker.exec(first.text);
+					if (task !== null) {
+						node.checked = task[1] !== " ";
+						first.text = first.text.slice(task[0].length + 1);
+					}
+				}
+				node.children = kids(from);
+				return node;
+			}
+			default: return {
+				type: from.type,
+				position: place(from),
+				children: kids(from)
+			};
+		}
+	};
+	const root = {
+		type: "root",
+		children: kids(doc)
+	};
+	const footnotes = [];
+	for (let index = 0;; index++) {
+		let key;
+		let at = 0;
+		for (const used of context.footnoteUses.keys()) if (at++ === index) key = used;
+		if (key === void 0) break;
+		const from = definitions.get(key);
+		if (from === void 0) continue;
+		footnotes.push({
+			type: "footnoteDefinition",
+			identifier: normalizeLabel(`[${from.label}]`).toLowerCase(),
+			label: from.label,
+			index: index + 1,
+			position: place(from),
+			children: kids(from)
+		});
+	}
+	for (const node of footnotes) node.count = context.footnoteUses.get(normalizeLabel(`[${node.label}]`)) ?? 1;
+	return {
+		root,
+		footnotes
+	};
+};
+export { parseBlocks };
+
+//# sourceMappingURL=blocks.js.map