@temelj/mdx 0.13.0 → 0.15.0

package/dist/parser/block-parser.mjs

@@ -0,0 +1,895 @@
+import { sourceRange } from "../ranges.mjs";
+import { PhysicalLineScanner } from "../source.mjs";
+import { consumeIndent, isAsciiLetter, isBlank, isSpaceOrTab } from "./characters.mjs";
+import { blockQuoteMarker, footnoteMarker, isSiblingListItem, listMarker, taskListMarker } from "./block-container-recognizers.mjs";
+import { matched, noMatch } from "./recognizer.mjs";
+import { directiveContainerMarker, isClosingDirectiveFence, recognizeLeafDirective } from "./block-directive-recognizers.mjs";
+import { interruptsParagraph, isClosingFence, isClosingMathFence, recognizeAtxHeading, recognizeDefinition, recognizeFence, recognizeFrontmatter, recognizeMathFence, recognizeRawHtml, recognizeSameLineMath, recognizeSetext, recognizeTable, recognizeThematicBreak, tableRow, trimLineEndingOffset } from "./block-leaf-recognizers.mjs";
+import { JavaScriptScanner } from "./javascript-scanner.mjs";
+import { JsxBoundaryScanner } from "./embedded-scanner.mjs";
+import { parseJavaScriptBoundary } from "./javascript-boundary.mjs";
+//#region src/parser/block-parser.ts
+var BlockParser = class BlockParser {
+	#blocks = [];
+	#containers = [];
+	#leaf;
+	#syntax;
+	#onSettled;
+	#settled;
+	#items = {
+		draft: false,
+		owned: /* @__PURE__ */ new WeakMap()
+	};
+	constructor(syntax, blocks = [], onSettled) {
+		this.#syntax = syntax;
+		this.#leaf = new LeafParser(syntax);
+		this.#blocks.push(...blocks);
+		this.#onSettled = onSettled;
+		this.#settled = settledLength(this.#blocks);
+	}
+	/** The number of top-level blocks that later input cannot change. */
+	get settledCount() {
+		return this.#settled;
+	}
+	checkpoint() {
+		if (this.#containers.length !== 0 || !this.#leaf.idle) return;
+		const tail = this.#blocks.at(-1);
+		if (tail?.kind === "list") this.#items.owned.delete(tail.items);
+		return {
+			length: this.#blocks.length,
+			tail
+		};
+	}
+	fork(checkpoint) {
+		const blocks = this.#blocks.slice(0, checkpoint.length);
+		if (checkpoint.tail !== void 0) blocks[blocks.length - 1] = checkpoint.tail;
+		return new BlockParser(this.#syntax, blocks, this.#onSettled);
+	}
+	/**
+	* A copy of the unsettled part: a trailing list, the open containers, and
+	* the active leaf. Finishing it costs only the open tail.
+	*/
+	tail() {
+		const copy = new BlockParser(this.#syntax, this.#blocks.slice(this.#settled));
+		copy.#items.draft = true;
+		copy.#containers.push(...this.#containers);
+		copy.#leaf.copyFrom(this.#leaf);
+		return copy;
+	}
+	pending() {
+		return this.#leaf.pending();
+	}
+	write(source, physicalLine) {
+		this.#leaf.rollback();
+		this.writeLine(source, physicalLine);
+		while (this.#onSettled !== void 0 && this.#settled < settledLength(this.#blocks)) {
+			this.#onSettled(this.#blocks[this.#settled], this.#settled);
+			this.#settled++;
+		}
+	}
+	writeLine(source, physicalLine) {
+		let cursor = physicalLine.range.start === 0 && source.char(0) === "" ? physicalLine.content.start + 1 : physicalLine.content.start;
+		let matchedContainers = 0;
+		for (const [index, frame] of this.#containers.entries()) {
+			if (frame.kind === "directiveContainer" && isClosingDirectiveFence(source, physicalLine, cursor, frame.fenceLength)) {
+				this.appendLeafBlocks(this.#leaf.finish());
+				const current = this.#containers[index];
+				if (current.kind !== "directiveContainer") throw new Error("Directive frame changed while closing its leaf");
+				this.#containers[index] = {
+					...current,
+					end: physicalLine.range.end
+				};
+				this.closeContainers(index);
+				return;
+			}
+			const continuation = continueContainer(source, physicalLine, cursor, frame);
+			if (continuation === void 0) break;
+			cursor = continuation;
+			matchedContainers = index + 1;
+			this.#containers[index] = {
+				...frame,
+				end: physicalLine.range.end
+			};
+		}
+		if (matchedContainers === this.#containers.length && this.#leaf.ownsFollowingLine) {
+			this.appendLeafBlocks(this.#leaf.write(source, contentLine(physicalLine, cursor)));
+			return;
+		}
+		const unmatched = matchedContainers < this.#containers.length;
+		let line = contentLine(physicalLine, cursor);
+		const unmatchedFrame = this.#containers[matchedContainers];
+		const siblingItem = unmatchedFrame?.kind === "listItem" && isSiblingListItem(source, line, unmatchedFrame);
+		const lazy = unmatched && !siblingItem && this.#leaf.canLazyContinue(source, line);
+		if (lazy) for (let index = matchedContainers; index < this.#containers.length; index++) {
+			const frame = this.#containers[index];
+			this.#containers[index] = {
+				...frame,
+				end: physicalLine.range.end
+			};
+		}
+		if (!lazy) {
+			if (unmatched) {
+				this.appendLeafBlocks(this.#leaf.finish());
+				this.closeContainers(matchedContainers);
+			}
+			if (this.#leaf.hasParagraph) {
+				if (opensContainer(source, line, this.#syntax)) {
+					this.appendLeafBlocks(this.#leaf.finish());
+					cursor = openContainers(source, physicalLine, cursor, this.#containers, this.#syntax);
+				}
+			} else cursor = openContainers(source, physicalLine, cursor, this.#containers, this.#syntax);
+		}
+		line = contentLine(physicalLine, cursor);
+		const task = taskListMarker(source, line, this.#containers, this.#leaf.hasParagraph);
+		if (task !== void 0) {
+			this.#containers[this.#containers.length - 1] = {
+				...task.frame,
+				checked: task.checked
+			};
+			line = contentLine(physicalLine, task.contentStart);
+		}
+		if (isBlankLine(source, line)) markListBlank(this.#containers);
+		else settleListBlank(this.#containers, lazy ? this.#containers.length : matchedContainers);
+		const allowFrontmatter = physicalLine.line === 1 && this.#blocks.length === 0 && this.#containers.length === 0;
+		this.appendLeafBlocks(this.#leaf.write(source, line, allowFrontmatter));
+	}
+	finish(source) {
+		this.#leaf.rollback();
+		this.appendLeafBlocks(this.#leaf.finish(source));
+		this.closeContainers(0);
+		return [...this.#blocks];
+	}
+	appendLeafBlocks(blocks) {
+		for (const block of blocks) appendBlock(this.#blocks, this.#containers, block);
+	}
+	closeContainers(keep) {
+		while (this.#containers.length > keep) {
+			const frame = this.#containers.pop();
+			if (frame === void 0) throw new Error("Container stack changed while closing a frame");
+			if (frame.kind === "blockQuote") appendBlock(this.#blocks, this.#containers, {
+				kind: "blockQuote",
+				range: sourceRange(frame.start, frame.end),
+				children: frame.children
+			});
+			else if (frame.kind === "listItem") appendListItem(this.#blocks, this.#containers, frame, this.#items);
+			else if (frame.kind === "footnoteDefinition") appendBlock(this.#blocks, this.#containers, {
+				kind: "footnoteDefinition",
+				range: sourceRange(frame.start, frame.end),
+				identifier: frame.identifier,
+				children: frame.children
+			});
+			else if (frame.kind === "directiveContainer") appendBlock(this.#blocks, this.#containers, {
+				kind: "directive",
+				range: sourceRange(frame.start, frame.end),
+				name: frame.name,
+				label: frame.label,
+				attributes: frame.attributes,
+				children: frame.children
+			});
+		}
+	}
+};
+/** Arrays an open leaf grows in place. Only the parser that created one extends it. */
+const growable = /* @__PURE__ */ new WeakSet();
+function isGrowable(array) {
+	return growable.has(array);
+}
+var LeafParser = class {
+	#syntax;
+	#active;
+	/** Set on a tail draft: extensions are logged so the parser can undo them. */
+	#draftLog;
+	#log = [];
+	#expressionScanner;
+	#jsxScanner;
+	constructor(syntax) {
+		this.#syntax = syntax;
+	}
+	get hasParagraph() {
+		return this.#active?.kind === "paragraph";
+	}
+	get idle() {
+		return this.#active === void 0;
+	}
+	get ownsFollowingLine() {
+		const kind = this.#active?.kind;
+		return kind === "fencedCode" || kind === "html" || kind === "frontmatter" || kind === "math" || kind === "expression" || kind === "jsx" || kind === "esm";
+	}
+	copyFrom(source) {
+		source.rollback();
+		this.#draftLog = source.#log;
+		this.#active = source.#active;
+		this.#expressionScanner = source.#expressionScanner?.clone();
+		this.#jsxScanner = source.#jsxScanner?.clone();
+	}
+	/** Undoes a tail draft's extensions, so the open leaf holds only written lines. */
+	rollback() {
+		for (let index = this.#log.length - 1; index >= 0; index--) {
+			const [array, length] = this.#log[index];
+			array.length = length;
+		}
+		this.#log.length = 0;
+	}
+	/**
+	* Appends to a leaf array without copying it. A tail draft logs the old
+	* length, so the parser it came from can undo the extension.
+	*/
+	grow(array, ...items) {
+		if (!isGrowable(array)) {
+			const copy = [...array, ...items];
+			growable.add(copy);
+			return copy;
+		}
+		this.#draftLog?.push([array, array.length]);
+		array.push(...items);
+		return array;
+	}
+	pending() {
+		const active = this.#active;
+		if (active === void 0) return;
+		if (active.kind === "paragraph") return {
+			kind: "paragraph",
+			range: sourceRange(active.start, active.end),
+			input: active.lines
+		};
+		if (active.kind === "fencedCode") return {
+			kind: "fencedCode",
+			range: sourceRange(active.start, active.end),
+			value: active.value,
+			language: active.language,
+			meta: active.meta
+		};
+		if (active.kind === "math") return {
+			kind: "math",
+			range: sourceRange(active.start, active.end),
+			value: active.value,
+			format: active.format
+		};
+		if (active.kind === "jsx") return {
+			kind: "jsx",
+			range: sourceRange(active.start, active.end),
+			opening: this.#jsxScanner?.opening()
+		};
+		if (active.kind === "expression" || active.kind === "esm") return {
+			kind: active.kind,
+			range: sourceRange(active.start, active.end)
+		};
+	}
+	canLazyContinue(source, line) {
+		return this.#active?.kind === "paragraph" && !isBlankLine(source, line) && !this.interruptsParagraph(source, line) && !opensContainer(source, line, this.#syntax);
+	}
+	write(source, line, allowFrontmatter = false) {
+		const blocks = [];
+		if (this.continueActive(source, line, blocks)) return blocks;
+		if (isBlankLine(source, line)) return [...blocks, ...this.finish()];
+		if (this.continueParagraph(source, line, blocks)) return blocks;
+		this.startLeaf(source, line, allowFrontmatter, blocks);
+		return blocks;
+	}
+	/**
+	* Feeds a line to an open leaf that owns its lines. Returns `false` when the
+	* leaf closed without consuming the line, so the line starts new content.
+	*/
+	continueActive(source, line, blocks) {
+		const active = this.#active;
+		switch (active?.kind) {
+			case "expression":
+			case "jsx":
+				this.continueEmbedded(source, line, active, blocks);
+				return true;
+			case "esm":
+				if (isBlankLine(source, line)) blocks.push(this.finishEmbedded(source));
+				else this.#active = {
+					...active,
+					end: line.range.end,
+					value: this.grow(active.value, embeddedSegment(line))
+				};
+				return true;
+			case "html":
+				if (source.slice(line.content.start, line.content.end).includes(active.closing)) blocks.push(this.closeActive(line.range.end));
+				else this.#active = {
+					...active,
+					end: line.range.end
+				};
+				return true;
+			case "frontmatter":
+				if (source.slice(line.content.start, line.content.end).trim() === active.fence) blocks.push(this.closeActive(line.range.end));
+				else this.#active = {
+					...active,
+					end: line.range.end,
+					valueEnd: line.range.end
+				};
+				return true;
+			case "math":
+				if (isClosingMathFence(source, line, active)) blocks.push(this.closeActive(line.range.end));
+				else this.#active = {
+					...active,
+					end: line.range.end,
+					value: this.grow(active.value, {
+						kind: "source",
+						range: line.range
+					})
+				};
+				return true;
+			case "fencedCode":
+				if (isClosingFence(source, line, active)) blocks.push(this.closeActive(line.range.end));
+				else this.#active = {
+					...active,
+					end: line.range.end,
+					value: this.grow(active.value, {
+						kind: "source",
+						range: line.range
+					})
+				};
+				return true;
+			case "indentedCode": return this.continueIndentedCode(source, line, active, blocks);
+			case "table": return this.continueTable(source, line, active, blocks);
+			case "paragraph":
+			case void 0: return false;
+			default: return active;
+		}
+	}
+	continueEmbedded(source, line, active, blocks) {
+		const scanner = active.kind === "expression" ? this.#expressionScanner : this.#jsxScanner;
+		if (scanner === void 0) throw new Error(`Missing retained scanner for ${active.kind}`);
+		const result = scanner.append(source.slice(line.range.start, line.range.end));
+		this.#active = {
+			...active,
+			end: line.range.end,
+			value: this.grow(active.value, embeddedSegment(line))
+		};
+		if (result.kind !== "open") blocks.push(this.finishEmbedded(source, result.kind === "invalid"));
+	}
+	/** Blank lines stay pending until more indented code follows them. */
+	continueIndentedCode(source, line, active, blocks) {
+		if (isBlankLine(source, line)) {
+			this.#active = {
+				...active,
+				end: line.range.end,
+				pendingBlank: this.grow(active.pendingBlank, {
+					kind: "source",
+					range: sourceRange(line.content.end, line.range.end)
+				})
+			};
+			return true;
+		}
+		const indented = indentedCodeLine(source, line);
+		if (indented !== void 0) {
+			this.#active = {
+				...active,
+				end: line.range.end,
+				value: this.grow(active.value, ...active.pendingBlank, ...indented),
+				pendingBlank: []
+			};
+			return true;
+		}
+		blocks.push(this.closeActive());
+		return false;
+	}
+	continueTable(source, line, active, blocks) {
+		if (isBlankLine(source, line)) {
+			blocks.push(this.closeActive());
+			return false;
+		}
+		this.#active = {
+			...active,
+			end: line.range.end,
+			rows: this.grow(active.rows, tableRow(source, line.content))
+		};
+		return true;
+	}
+	/**
+	* A paragraph line can turn the paragraph into a setext heading or a table,
+	* or continue it. Returns `false` when the line interrupts the paragraph.
+	*/
+	continueParagraph(source, line, blocks) {
+		const active = this.#active;
+		if (active?.kind !== "paragraph") return false;
+		const setext = recognizeSetext(source, line, active);
+		if (setext.kind === "matched") {
+			blocks.push(setext.value);
+			this.#active = void 0;
+			return true;
+		}
+		const table = recognizeTable(source, line, active);
+		if (table.kind === "matched") {
+			this.#active = table.value;
+			return true;
+		}
+		if (this.interruptsParagraph(source, line)) {
+			blocks.push(this.closeActive());
+			return false;
+		}
+		this.#active = {
+			kind: "paragraph",
+			start: active.start,
+			end: line.content.end,
+			lines: this.grow(active.lines, {
+				kind: "source",
+				range: active.pendingEnding
+			}, {
+				kind: "source",
+				range: line.content
+			}),
+			pendingEnding: sourceRange(line.content.end, line.range.end)
+		};
+		return true;
+	}
+	/** Starts the leaf a non-blank line opens, in CommonMark precedence order. */
+	startLeaf(source, line, allowFrontmatter, blocks) {
+		if (!startsParagraph(source, line.content.start)) {
+			if (allowFrontmatter) {
+				const frontmatter = recognizeFrontmatter(source, line, this.#syntax);
+				if (frontmatter.kind === "matched") {
+					this.#active = frontmatter.value;
+					return;
+				}
+			}
+			for (const recognize of [recognizeLeafDirective, recognizeSameLineMath]) {
+				const result = recognize(source, line, this.#syntax);
+				if (result.kind === "matched") {
+					blocks.push(result.value);
+					return;
+				}
+			}
+			const math = recognizeMathFence(source, line, this.#syntax);
+			if (math.kind === "matched") {
+				this.#active = math.value;
+				return;
+			}
+			if (this.startEmbedded(source, line, blocks)) return;
+			for (const recognize of [
+				recognizeRawHtml,
+				recognizeDefinition,
+				recognizeFence,
+				recognizeAtxHeading,
+				recognizeThematicBreak
+			]) {
+				const result = recognize(source, line);
+				if (result.kind === "matched") {
+					if (result.value.kind === "openLeaf") this.#active = result.value.leaf;
+					else blocks.push(result.value.block);
+					return;
+				}
+			}
+			const indented = indentedCodeLine(source, line);
+			if (indented !== void 0) {
+				this.#active = {
+					kind: "indentedCode",
+					start: line.range.start,
+					end: line.range.end,
+					value: indented,
+					pendingBlank: []
+				};
+				return;
+			}
+		}
+		this.#active = {
+			kind: "paragraph",
+			start: line.content.start,
+			end: line.content.end,
+			lines: [{
+				kind: "source",
+				range: line.content
+			}],
+			pendingEnding: sourceRange(line.content.end, line.range.end)
+		};
+	}
+	/**
+	* Starts flow JSX, an expression, or ESM. Returns `false` when the construct
+	* closes with more content on its line, which makes it phrasing content.
+	*/
+	startEmbedded(source, line, blocks) {
+		const embedded = recognizeEmbeddedFlowStart(source, line);
+		if (embedded.kind !== "matched") return false;
+		this.#active = {
+			kind: embedded.value.kind,
+			start: line.content.start,
+			end: line.range.end,
+			value: [embeddedSegment(line)]
+		};
+		if (embedded.value.kind === "esm") return true;
+		const start = embedded.value.kind === "expression" ? embedded.value.markerEnd : line.content.start;
+		const text = source.slice(start, line.range.end);
+		let result;
+		if (embedded.value.kind === "expression") {
+			this.#expressionScanner = new JavaScriptScanner("}");
+			result = this.#expressionScanner.append(text);
+		} else {
+			this.#jsxScanner = new JsxBoundaryScanner();
+			result = this.#jsxScanner.append(text);
+		}
+		if (!(result.kind === "closed" && !isBlank(source.slice(start + result.offset, line.content.end)))) {
+			if (result.kind !== "open") blocks.push(this.finishEmbedded(source, result.kind === "invalid"));
+			return true;
+		}
+		this.#active = void 0;
+		this.#expressionScanner = void 0;
+		this.#jsxScanner = void 0;
+		return false;
+	}
+	finish(source) {
+		if (this.#active?.kind === "esm" && source !== void 0) return [this.finishEmbedded(source)];
+		if (this.#active?.kind === "frontmatter" && source !== void 0) {
+			const active = this.#active;
+			this.#active = void 0;
+			const contentEnd = trimLineEndingOffset(source, active.valueEnd);
+			const paragraphStart = active.format === "yaml" ? active.valueStart : active.start;
+			const fallback = [];
+			if (active.format === "yaml") fallback.push({
+				kind: "thematicBreak",
+				range: sourceRange(active.start, trimLineEndingOffset(source, active.valueStart))
+			});
+			if (contentEnd > paragraphStart) fallback.push({
+				kind: "paragraph",
+				range: sourceRange(paragraphStart, contentEnd),
+				input: [{
+					kind: "source",
+					range: sourceRange(paragraphStart, contentEnd)
+				}]
+			});
+			return fallback;
+		}
+		if (this.#active?.kind === "expression" || this.#active?.kind === "jsx" || this.#active?.kind === "esm") {
+			const active = this.#active;
+			const opening = this.#jsxScanner?.opening();
+			this.#active = void 0;
+			this.#expressionScanner = void 0;
+			this.#jsxScanner = void 0;
+			return [{
+				kind: "invalidMdx",
+				range: sourceRange(active.start, active.end),
+				syntax: active.kind,
+				state: "incomplete",
+				opening
+			}];
+		}
+		return this.#active === void 0 ? [] : [this.closeActive()];
+	}
+	finishEmbedded(source, structurallyInvalid = false) {
+		const active = this.#active;
+		if (active?.kind !== "expression" && active?.kind !== "jsx" && active?.kind !== "esm") throw new Error("Cannot finish a missing embedded flow leaf");
+		this.#active = void 0;
+		this.#expressionScanner = void 0;
+		this.#jsxScanner = void 0;
+		const authored = segmentsText(source, active.value);
+		const javascript = active.kind === "expression" ? authored.slice(authored.indexOf("{") + 1, authored.lastIndexOf("}")) : authored;
+		const boundary = structurallyInvalid || active.kind === "expression" && javascript.trim() === "" ? void 0 : parseJavaScriptBoundary(active.kind === "jsx" ? "jsxExpression" : active.kind, javascript, active.kind === "expression" ? active.start + authored.indexOf("{") + 1 : active.start);
+		return !structurallyInvalid && (active.kind === "expression" && javascript.trim() === "" || boundary?.kind === "valid") ? {
+			kind: active.kind,
+			range: sourceRange(active.start, active.end)
+		} : {
+			kind: "invalidMdx",
+			range: sourceRange(active.start, active.end),
+			syntax: active.kind,
+			state: "invalid"
+		};
+	}
+	closeActive(end) {
+		const active = this.#active;
+		if (active === void 0) throw new Error("Cannot close a missing leaf");
+		this.#active = void 0;
+		if (active.kind === "paragraph") return {
+			kind: "paragraph",
+			range: sourceRange(active.start, active.end),
+			input: active.lines
+		};
+		if (active.kind === "fencedCode") return {
+			kind: "code",
+			range: sourceRange(active.start, end ?? active.end),
+			value: active.value,
+			fenced: true,
+			language: active.language,
+			meta: active.meta
+		};
+		if (active.kind === "indentedCode") return {
+			kind: "code",
+			range: sourceRange(active.start, active.end),
+			value: active.value,
+			fenced: false,
+			language: void 0,
+			meta: void 0
+		};
+		if (active.kind === "table") return {
+			kind: "table",
+			range: sourceRange(active.start, active.end),
+			alignments: active.alignments,
+			rows: active.rows
+		};
+		if (active.kind === "frontmatter") return {
+			kind: "frontmatter",
+			range: sourceRange(active.start, end ?? active.end),
+			value: sourceRange(active.valueStart, active.valueEnd),
+			format: active.format
+		};
+		if (active.kind === "math") return {
+			kind: "math",
+			range: sourceRange(active.start, end ?? active.end),
+			value: active.value,
+			format: active.format,
+			meta: active.meta
+		};
+		if (active.kind === "html") return {
+			kind: "rawHtml",
+			range: sourceRange(active.start, end ?? active.end)
+		};
+		throw new Error(`Cannot close unimplemented ${active.kind} leaf`);
+	}
+	interruptsParagraph(source, line) {
+		if (startsParagraph(source, line.content.start)) return false;
+		return interruptsParagraph(source, line) || recognizeLeafDirective(source, line, this.#syntax).kind === "matched" || recognizeSameLineMath(source, line, this.#syntax).kind === "matched" || recognizeMathFence(source, line, this.#syntax).kind === "matched" || recognizeEmbeddedFlowStart(source, line).kind === "matched";
+	}
+};
+/** Unindented letters start paragraphs, except the ESM keywords import and export. */
+function startsParagraph(source, start) {
+	const character = source.char(start);
+	return isAsciiLetter(character) && character !== "i" && character !== "e";
+}
+/** Rejects ordinary content before slicing a potentially long, chunked line. */
+function isBlankLine(source, line) {
+	return line.content.start === line.content.end || isSpaceOrTab(source.char(line.content.start)) && isBlank(source.slice(line.content.start, line.content.end));
+}
+function matchEmbeddedFlowStart(source, line) {
+	const start = consumeIndent(source, line.content.start, line.content.end, 3).offset;
+	const content = source.slice(start, line.content.end);
+	if (content.startsWith("{")) return {
+		kind: "expression",
+		markerEnd: start + 1
+	};
+	if (/^<(?:>|\/(?:>|[A-Za-z_$][\w$-]*(?:[.:][A-Za-z_$][\w$-]*)*(?=[\s>]|$))|[A-Za-z_$][\w$-]*(?:[.:][A-Za-z_$][\w$-]*)*(?=[\s/{>]|$))/u.test(content)) return {
+		kind: "jsx",
+		markerEnd: start + 1
+	};
+	if (/^(?:import\s|export(?:\s|\{))/u.test(content)) return {
+		kind: "esm",
+		markerEnd: start
+	};
+}
+function recognizeEmbeddedFlowStart(source, line) {
+	const match = matchEmbeddedFlowStart(source, line);
+	return match === void 0 ? noMatch : matched(match);
+}
+function segmentsText(source, segments) {
+	let value = "";
+	for (const segment of segments) value += segment.kind === "source" ? source.slice(segment.range.start, segment.range.end) : " ".repeat(segment.columns);
+	return value;
+}
+/**
+* Top-level blocks that later input cannot change. A closing list item merges
+* into a preceding list with the same marker, so only a trailing list can grow.
+*/
+function settledLength(blocks) {
+	return blocks.at(-1)?.kind === "list" ? blocks.length - 1 : blocks.length;
+}
+function appendBlock(root, containers, block) {
+	const parent = containers.at(-1);
+	if (parent === void 0) {
+		root.push(block);
+		return;
+	}
+	if (parent.kind === "directiveContainer") {
+		const children = [...parent.children, block];
+		containers[containers.length - 1] = {
+			...parent,
+			children
+		};
+		return;
+	}
+	const children = [...parent.children, block];
+	const index = containers.length - 1;
+	containers[index] = {
+		...parent,
+		children
+	};
+}
+function appendListItem(root, containers, frame, growth) {
+	const item = {
+		range: sourceRange(frame.rangeStart, frame.end),
+		checked: frame.checked,
+		spread: frame.spread,
+		children: frame.children
+	};
+	const parent = containers.at(-1);
+	const siblings = parent === void 0 ? root : [...parent.children];
+	const previous = siblings.at(-1);
+	if (previous?.kind === "list" && previous.ordered === frame.ordered && previous.marker === frame.markerCharacter) siblings[siblings.length - 1] = {
+		...previous,
+		range: sourceRange(previous.range.start, frame.end),
+		spread: previous.spread || previous.trailingBlank || frame.spread,
+		...grownItems(previous, item, parent === void 0 ? growth : void 0),
+		trailingBlank: frame.blankPending
+	};
+	else siblings.push({
+		kind: "list",
+		range: sourceRange(frame.rangeStart, frame.end),
+		ordered: frame.ordered,
+		start: frame.start,
+		spread: frame.spread,
+		marker: frame.markerCharacter,
+		items: [item],
+		trailingBlank: frame.blankPending
+	});
+	if (parent !== void 0) containers[containers.length - 1] = {
+		...parent,
+		children: siblings
+	};
+}
+/** The items after appending `item`, without copying the items a top-level list already has. */
+function grownItems(list, item, growth) {
+	if (growth === void 0) return { items: [
+		...list.items,
+		...list.closing ?? [],
+		item
+	] };
+	if (growth.draft) return {
+		items: list.items,
+		closing: [...list.closing ?? [], item]
+	};
+	const owned = growth.owned.get(list.items);
+	if (owned !== void 0) {
+		owned.push(item);
+		return { items: owned };
+	}
+	const items = [...list.items, item];
+	growth.owned.set(items, items);
+	return { items };
+}
+function continueContainer(source, line, cursor, frame) {
+	if (frame.kind === "blockQuote") return blockQuoteMarker(source, line.content.end, cursor)?.contentStart;
+	if (frame.kind === "listItem") {
+		if (isBlank(source.slice(cursor, line.content.end))) return line.content.end;
+		return consumeColumns(source, cursor, line.content.end, frame.contentIndent);
+	}
+	if (frame.kind === "footnoteDefinition") {
+		if (isBlank(source.slice(cursor, line.content.end))) return line.content.end;
+		return consumeColumns(source, cursor, line.content.end, frame.contentIndent);
+	}
+	if (frame.kind === "directiveContainer") return cursor;
+}
+function openContainers(source, line, initialCursor, containers, syntax) {
+	let cursor = initialCursor;
+	while (cursor < line.content.end) {
+		if (isAsciiLetter(source.char(cursor))) break;
+		const quote = blockQuoteMarker(source, line.content.end, cursor);
+		if (quote !== void 0) {
+			containers.push({
+				kind: "blockQuote",
+				marker: sourceRange(quote.markerStart, quote.markerEnd),
+				contentIndent: quote.contentStart - quote.markerEnd,
+				start: quote.markerStart,
+				end: line.range.end,
+				children: []
+			});
+			cursor = quote.contentStart;
+			continue;
+		}
+		const footnote = footnoteMarker(source, line.content.end, cursor);
+		if (footnote !== void 0) {
+			containers.push({
+				kind: "footnoteDefinition",
+				marker: sourceRange(footnote.markerStart, footnote.markerEnd),
+				identifier: footnote.identifier,
+				contentIndent: 4,
+				start: footnote.markerStart,
+				end: line.range.end,
+				children: []
+			});
+			cursor = footnote.contentStart;
+			continue;
+		}
+		const directive = syntax.directives ? directiveContainerMarker(source, line.content.end, cursor) : void 0;
+		if (directive !== void 0) {
+			containers.push({
+				kind: "directiveContainer",
+				marker: sourceRange(directive.markerStart, directive.markerEnd),
+				name: directive.name,
+				fenceLength: directive.fenceLength,
+				start: directive.markerStart,
+				end: line.range.end,
+				children: [],
+				label: directive.label,
+				attributes: directive.attributes
+			});
+			cursor = line.content.end;
+			continue;
+		}
+		const adjusted = contentLine(line, cursor);
+		if (recognizeThematicBreak(source, adjusted).kind === "matched") break;
+		const list = listMarker(source, line.content.end, cursor);
+		if (list === void 0) break;
+		containers.push({
+			kind: "listItem",
+			marker: sourceRange(list.markerStart, list.markerEnd),
+			markerCharacter: list.markerCharacter,
+			contentIndent: list.contentIndent,
+			ordered: list.ordered,
+			start: list.start,
+			checked: void 0,
+			spread: false,
+			blankPending: false,
+			rangeStart: list.markerStart,
+			end: line.range.end,
+			children: []
+		});
+		cursor = list.contentStart;
+	}
+	return cursor;
+}
+function opensContainer(source, line, syntax) {
+	if (isAsciiLetter(source.char(line.content.start))) return false;
+	return blockQuoteMarker(source, line.content.end, line.content.start) !== void 0 || footnoteMarker(source, line.content.end, line.content.start) !== void 0 || syntax.directives && directiveContainerMarker(source, line.content.end, line.content.start) !== void 0 || recognizeThematicBreak(source, line).kind !== "matched" && listMarker(source, line.content.end, line.content.start, true) !== void 0;
+}
+function consumeColumns(source, start, end, required) {
+	const indent = consumeIndent(source, start, end, required);
+	return indent.columns >= required ? indent.offset : void 0;
+}
+function indentedCodeLine(source, line) {
+	const contentStart = consumeColumns(source, line.content.start, line.content.end, 4);
+	return contentStart === void 0 ? void 0 : [{
+		kind: "source",
+		range: sourceRange(contentStart, line.range.end)
+	}];
+}
+/** Records a blank line in the trailing list items that directly contain it. */
+function markListBlank(containers) {
+	for (let index = containers.length - 1; index >= 0; index--) {
+		const frame = containers[index];
+		if (frame.kind !== "listItem") return;
+		containers[index] = {
+			...frame,
+			blankPending: true
+		};
+	}
+}
+/**
+* Resolves pending blank lines once content arrives. Only the deepest surviving
+* item receives a new direct child after the blank line, which makes it loose. A
+* new sibling item of a nested list keeps the blank inside that nested list.
+*/
+function settleListBlank(containers, surviving) {
+	const opened = containers[surviving];
+	for (let index = 0; index < surviving; index++) {
+		const frame = containers[index];
+		if (frame.kind !== "listItem" || !frame.blankPending) continue;
+		const last = frame.children.at(-1);
+		const nestedSibling = opened?.kind === "listItem" && last?.kind === "list" && last.ordered === opened.ordered && last.marker === opened.markerCharacter;
+		containers[index] = {
+			...frame,
+			blankPending: false,
+			spread: frame.spread || index === surviving - 1 && !nestedSibling
+		};
+	}
+}
+function contentLine(line, contentStart) {
+	if (line.range.start === contentStart) return line;
+	return {
+		line: line.line,
+		range: sourceRange(contentStart, line.range.end),
+		content: sourceRange(contentStart, line.content.end),
+		ending: line.ending
+	};
+}
+/**
+* Parses a nested flow region, such as multi-line JSX children, with offsets in
+* the enclosing source. Frontmatter is never recognized inside the region.
+*/
+function parseFlowRange(source, range, syntax) {
+	const scanner = new PhysicalLineScanner({ offset: range.start });
+	const parser = new BlockParser({
+		...syntax,
+		frontmatter: []
+	});
+	for (const physicalLine of [...scanner.append(source.slice(range.start, range.end)), ...scanner.complete()]) parser.write(source, physicalLine);
+	return parser.finish(source);
+}
+/** An embedded flow line from its content to the end of the line, including the ending. */
+function embeddedSegment(line) {
+	return {
+		kind: "source",
+		range: sourceRange(line.content.start, line.range.end)
+	};
+}
+//#endregion
+export { BlockParser, parseFlowRange };
+
+//# sourceMappingURL=block-parser.mjs.map