@effected/markdown 0.2.0

package/index.js

@@ -0,0 +1,15 @@
+import { MarkdownEdit, MarkdownRange } from "./MarkdownEdit.js";
+import { Blockquote, Break, BreakStyle, BulletChar, Code, Definition, Delete, Emphasis, EmphasisChar, FenceChar, FlowContent, FootnoteDefinition, FootnoteReference, Frontmatter, FrontmatterContent, FrontmatterFormat, Heading, HeadingDepth, HeadingStyle, Html, Image, ImageReference, InlineCode, Link, LinkReference, List, ListContent, ListDelimiter, ListItem, MarkdownNode, Paragraph, PhrasingContent, Point, Position, ReferenceType, Root, RowContent, Strong, Table, TableAlign, TableCell, TableContent, TableRow, Text, ThematicBreak, ThematicBreakChar } from "./MarkdownNode.js";
+import { FrontmatterDecodeError, FrontmatterEncodeError, FrontmatterFormatMismatchError, FrontmatterMissingError, FrontmatterValidationError, MarkdownFrontmatter } from "./Frontmatter.js";
+import { SchemaDeclaration, SchemaDeclarationByName, SchemaDeclarationByPath, SchemaDeclarationByUrl, SchemaDeclarationInline, SchemaDeclarationInvalidError, SchemaDeclarationMissingError, SchemaNameUnknownError, SchemaResolver, SchemaVersionUnresolvableError } from "./FrontmatterResolver.js";
+import { JsonFrontmatter } from "./JsonFrontmatter.js";
+import { MarkdownDiagnostic, MarkdownParseErrorCode } from "./MarkdownDiagnostic.js";
+import { Markdown, MarkdownDialect, MarkdownParseError, MarkdownParseOptions, MarkdownStringifyError } from "./Markdown.js";
+import { MarkdownDocument } from "./MarkdownDocument.js";
+import { MarkdownFormat, MarkdownFormattingOptions, MarkdownModificationError, MarkdownModificationErrorCode } from "./MarkdownFormat.js";
+import { MarkdownVisitor, MarkdownVisitorEvent } from "./MarkdownVisitor.js";
+import { Mdast, MdastDecodeError } from "./Mdast.js";
+import { TomlFrontmatter } from "./TomlFrontmatter.js";
+import { YamlFrontmatter } from "./YamlFrontmatter.js";
+
+export { Blockquote, Break, BreakStyle, BulletChar, Code, Definition, Delete, Emphasis, EmphasisChar, FenceChar, FlowContent, FootnoteDefinition, FootnoteReference, Frontmatter, FrontmatterContent, FrontmatterDecodeError, FrontmatterEncodeError, FrontmatterFormat, FrontmatterFormatMismatchError, FrontmatterMissingError, FrontmatterValidationError, Heading, HeadingDepth, HeadingStyle, Html, Image, ImageReference, InlineCode, JsonFrontmatter, Link, LinkReference, List, ListContent, ListDelimiter, ListItem, Markdown, MarkdownDiagnostic, MarkdownDialect, MarkdownDocument, MarkdownEdit, MarkdownFormat, MarkdownFormattingOptions, MarkdownFrontmatter, MarkdownModificationError, MarkdownModificationErrorCode, MarkdownNode, MarkdownParseError, MarkdownParseErrorCode, MarkdownParseOptions, MarkdownRange, MarkdownStringifyError, MarkdownVisitor, MarkdownVisitorEvent, Mdast, MdastDecodeError, Paragraph, PhrasingContent, Point, Position, ReferenceType, Root, RowContent, SchemaDeclaration, SchemaDeclarationByName, SchemaDeclarationByPath, SchemaDeclarationByUrl, SchemaDeclarationInline, SchemaDeclarationInvalidError, SchemaDeclarationMissingError, SchemaNameUnknownError, SchemaResolver, SchemaVersionUnresolvableError, Strong, Table, TableAlign, TableCell, TableContent, TableRow, Text, ThematicBreak, ThematicBreakChar, TomlFrontmatter, YamlFrontmatter };

package/internal/blockParser.js

@@ -0,0 +1,419 @@
+import { Frontmatter, Point, Position, Root } from "../MarkdownNode.js";
+import { makeBlockNode } from "./blockTypes.js";
+import { columnsToNextTabStop, preprocessLines } from "./preprocess.js";
+import { isHtmlBlockEnd } from "./blocks/htmlBlock.js";
+import { blockDialect } from "./blockRegistry.js";
+import { scanFrontmatter } from "./blocks/frontmatter.js";
+import { GuardExceeded } from "./carriers.js";
+import { LineIndex } from "./lineIndex.js";
+import { prepareInline } from "./rawInline.js";
+
+//#region src/internal/blockParser.ts
+/** Upstream's cheap pre-filter: a line that cannot start any block. */
+const reMaybeSpecial = /^[#`~*+_=<>0-9-]/;
+var BlockParser = class {
+	lines;
+	lineIndex;
+	dialect;
+	/**
+	* The dialect's NAME, kept alongside its block tables because the inline
+	* pass keys its own registry off the same string.
+	*/
+	dialectName;
+	sourceLength;
+	doc;
+	tipNode;
+	oldtip;
+	lastMatchedContainer;
+	currentLine = "";
+	lineStart = 0;
+	lineNumber = 0;
+	offset = 0;
+	column = 0;
+	nextNonspace = 0;
+	nextNonspaceColumn = 0;
+	indent = 0;
+	indented = false;
+	blank = false;
+	allClosed = true;
+	partiallyConsumedTab = false;
+	lastLineLength = 0;
+	frontmatterCapture;
+	constructor(text, dialect, dialectName, frontmatter = false) {
+		this.lines = preprocessLines(text);
+		this.frontmatterCapture = frontmatter ? scanFrontmatter(this.lines, text) : null;
+		const starts = this.lines.map((line) => line.start);
+		if (text.endsWith("\n")) starts.push(text.length);
+		this.lineIndex = LineIndex.fromLineStarts(text, starts);
+		this.sourceLength = text.length;
+		this.dialect = dialect;
+		this.dialectName = dialectName;
+		this.doc = makeBlockNode("document", 0, 1);
+		this.tipNode = this.doc;
+		this.oldtip = this.doc;
+		this.lastMatchedContainer = this.doc;
+	}
+	/**
+	* The deepest open block. Only reachable while the document is open — a
+	* read after the final finalize is a wiring bug and dies as a defect.
+	*/
+	get tip() {
+		const tip = this.tipNode;
+		if (tip === void 0) throw new TypeError("block parser: the tip was read after the document was finalized");
+		return tip;
+	}
+	constructOf(type) {
+		const construct = this.dialect.constructs.get(type);
+		if (construct === void 0) throw new TypeError(`block parser: no construct registered for block type ${type}`);
+		return construct;
+	}
+	advanceOffset(count, columns = false) {
+		const line = this.currentLine;
+		let remaining = count;
+		let char = line.charAt(this.offset);
+		while (remaining > 0 && char !== "") {
+			if (char === "	") {
+				const charsToTab = columnsToNextTabStop(this.column);
+				if (columns) {
+					this.partiallyConsumedTab = charsToTab > remaining;
+					const charsToAdvance = charsToTab > remaining ? remaining : charsToTab;
+					this.column += charsToAdvance;
+					this.offset += this.partiallyConsumedTab ? 0 : 1;
+					remaining -= charsToAdvance;
+				} else {
+					this.partiallyConsumedTab = false;
+					this.column += charsToTab;
+					this.offset += 1;
+					remaining -= 1;
+				}
+			} else {
+				this.partiallyConsumedTab = false;
+				this.offset += 1;
+				this.column += 1;
+				remaining -= 1;
+			}
+			char = line.charAt(this.offset);
+		}
+	}
+	advanceNextNonspace() {
+		this.offset = this.nextNonspace;
+		this.column = this.nextNonspaceColumn;
+		this.partiallyConsumedTab = false;
+	}
+	findNextNonspace() {
+		const line = this.currentLine;
+		let index = this.offset;
+		let cols = this.column;
+		let char = line.charAt(index);
+		while (char !== "") {
+			if (char === " ") {
+				index += 1;
+				cols += 1;
+			} else if (char === "	") {
+				index += 1;
+				cols += columnsToNextTabStop(cols);
+			} else break;
+			char = line.charAt(index);
+		}
+		this.blank = char === "\n" || char === "\r" || char === "";
+		this.nextNonspace = index;
+		this.nextNonspaceColumn = cols;
+		this.indent = this.nextNonspaceColumn - this.column;
+		this.indented = this.indent >= 4;
+	}
+	addLine() {
+		const tip = this.tip;
+		if (this.partiallyConsumedTab) {
+			this.offset += 1;
+			tip.stringContent += " ".repeat(columnsToNextTabStop(this.column));
+		}
+		const content = this.currentLine.slice(this.offset);
+		tip.segments.push({
+			textOffset: tip.stringContent.length,
+			sourceOffset: this.lineStart + this.offset,
+			length: content.length
+		});
+		tip.stringContent += `${content}\n`;
+	}
+	addChild(type, offsetInLine) {
+		while (!this.constructOf(this.tip.type).canContain(type)) this.finalizeBlock(this.tip, this.lineNumber - 1);
+		const parent = this.tip;
+		const depth = parent.depth + 1;
+		if (depth > 256) throw new GuardExceeded("NestingDepthExceeded", 256, depth, this.lineStart + offsetInLine);
+		const child = makeBlockNode(type, this.lineStart + offsetInLine, this.lineNumber, depth);
+		child.parent = parent;
+		parent.children.push(child);
+		this.tipNode = child;
+		return child;
+	}
+	setScanPosition(offset, column) {
+		this.offset = offset;
+		this.column = column;
+	}
+	setLastLineLength(length) {
+		this.lastLineLength = length;
+	}
+	replaceBlock(block, type) {
+		const parent = block.parent;
+		const replacement = makeBlockNode(type, block.startOffset, block.startLine, block.depth);
+		replacement.parent = parent;
+		replacement.stringContent = block.stringContent;
+		replacement.segments.push(...block.segments);
+		replacement.endOffset = block.endOffset;
+		replacement.endLine = block.endLine;
+		if (parent !== void 0) {
+			const at = parent.children.indexOf(block);
+			if (at === -1) parent.children.push(replacement);
+			else parent.children[at] = replacement;
+		}
+		block.open = false;
+		this.tipNode = replacement;
+		return replacement;
+	}
+	insertBefore(block, type) {
+		const parent = block.parent;
+		const sibling = makeBlockNode(type, block.startOffset, block.startLine, block.depth);
+		sibling.parent = parent;
+		sibling.open = false;
+		if (parent !== void 0) {
+			const at = parent.children.indexOf(block);
+			if (at === -1) parent.children.push(sibling);
+			else parent.children.splice(at, 0, sibling);
+		}
+		return sibling;
+	}
+	closeUnmatchedBlocks() {
+		if (this.allClosed) return;
+		while (this.oldtip !== this.lastMatchedContainer) {
+			const parent = this.oldtip.parent;
+			this.finalizeBlock(this.oldtip, this.lineNumber - 1);
+			this.oldtip = parent ?? this.doc;
+		}
+		this.allClosed = true;
+	}
+	finalizeBlock(block, lineNumber) {
+		const above = block.parent;
+		block.open = false;
+		block.endLine = lineNumber;
+		block.endOffset = this.endOfLine(lineNumber, this.lastLineLength);
+		this.constructOf(block.type).finalize?.(this, block);
+		this.tipNode = above;
+	}
+	/**
+	* The absolute offset `length` characters into line `lineNumber` — the
+	* offset form of upstream's `sourcepos[1] = [lineNumber, lastLineLength]`.
+	* Out-of-range line numbers clamp rather than throw.
+	*/
+	endOfLine(lineNumber, length) {
+		const index = Math.min(Math.max(lineNumber - 1, 0), this.lines.length - 1);
+		const line = this.lines[index];
+		if (line === void 0) return 0;
+		return line.start + Math.min(Math.max(length, 0), line.text.length);
+	}
+	incorporateLine(line) {
+		let container = this.doc;
+		this.oldtip = this.tip;
+		this.offset = 0;
+		this.column = 0;
+		this.blank = false;
+		this.partiallyConsumedTab = false;
+		this.lineNumber += 1;
+		this.currentLine = line.text;
+		this.lineStart = line.start;
+		let lastChild = container.children[container.children.length - 1];
+		while (lastChild?.open) {
+			container = lastChild;
+			this.findNextNonspace();
+			const verdict = this.constructOf(container.type).continue(this, container);
+			if (verdict === 2) return;
+			if (verdict === 1) {
+				container = container.parent ?? this.doc;
+				break;
+			}
+			lastChild = container.children[container.children.length - 1];
+		}
+		this.allClosed = container === this.oldtip;
+		this.lastMatchedContainer = container;
+		let matchedLeaf = container.type !== "paragraph" && this.constructOf(container.type).acceptsLines;
+		const starts = this.dialect.starts;
+		while (!matchedLeaf) {
+			this.findNextNonspace();
+			if (!this.indented) {
+				const rest = this.currentLine.slice(this.nextNonspace);
+				if (!reMaybeSpecial.test(rest) && !(this.dialect.mayStartBlock?.(rest, container) ?? false)) {
+					this.advanceNextNonspace();
+					break;
+				}
+			}
+			let index = 0;
+			while (index < starts.length) {
+				const start = starts[index];
+				const result = start === void 0 ? 0 : start.trigger(this, container);
+				if (result === 1) {
+					container = this.tip;
+					break;
+				}
+				if (result === 2) {
+					container = this.tip;
+					matchedLeaf = true;
+					break;
+				}
+				index += 1;
+			}
+			if (index === starts.length) {
+				this.advanceNextNonspace();
+				break;
+			}
+		}
+		if (!this.allClosed && !this.blank && this.tip.type === "paragraph") this.addLine();
+		else {
+			this.closeUnmatchedBlocks();
+			if (this.constructOf(container.type).acceptsLines) {
+				this.addLine();
+				if (container.type === "html" && isHtmlBlockEnd(container, this.currentLine.slice(this.offset))) {
+					this.lastLineLength = this.currentLine.length;
+					this.finalizeBlock(container, this.lineNumber);
+				}
+			} else if (this.offset < this.currentLine.length && !this.blank) {
+				container = this.addChild("paragraph", this.offset);
+				this.advanceNextNonspace();
+				this.addLine();
+			}
+		}
+		this.lastLineLength = this.currentLine.length;
+	}
+	/**
+	* Prepend the captured frontmatter node, when there is one. The root's
+	* own span widens to cover the block if the body ended before it — the
+	* frontmatter-only document, where the block pass saw no lines at all.
+	*/
+	withFrontmatter(root) {
+		const capture = this.frontmatterCapture;
+		if (capture === null) return root;
+		const node = Frontmatter.make({
+			type: "frontmatter",
+			format: capture.format,
+			value: capture.value,
+			position: this.position(0, capture.endOffset)
+		});
+		const position = root.position.end.offset >= capture.endOffset ? root.position : this.position(0, capture.endOffset);
+		return Root.make({
+			type: "root",
+			children: [node, ...root.children],
+			position
+		});
+	}
+	position(startOffset, endOffset) {
+		const start = Math.min(Math.max(startOffset, 0), this.sourceLength);
+		const end = Math.min(Math.max(endOffset, start), this.sourceLength);
+		const startPoint = this.lineIndex.positionAt(start);
+		const endPoint = this.lineIndex.positionAt(end);
+		return Position.make({
+			start: Point.make({
+				line: startPoint.line,
+				column: startPoint.column,
+				offset: start
+			}),
+			end: Point.make({
+				line: endPoint.line,
+				column: endPoint.column,
+				offset: end
+			})
+		});
+	}
+	/**
+	* Depth-first materialization. Recursion depth is container nesting depth,
+	* which `addChild`'s `MAX_NESTING_DEPTH` guard caps at parse time — this
+	* walk can never see a tree the line loop refused to build.
+	*/
+	materializeBlock(block, context, definitions) {
+		const children = [];
+		for (const child of block.children) {
+			const node = this.materializeBlock(child, context, definitions);
+			if (node !== void 0 && node.type !== "root") children.push(node);
+		}
+		const definition = definitions.get(block);
+		if (definition !== void 0) return definition;
+		return this.constructOf(block.type).materialize(block, children, context);
+	}
+	/**
+	* Index every reference target in the tree — link reference definitions and
+	* GFM footnote definition labels — before anything else is built.
+	*
+	* The inline pass resolves references against these, and a definition can
+	* appear anywhere, including after the paragraph that references it, so
+	* both maps have to exist before the first leaf is parsed. Walking twice is
+	* the price; the alternative is a mutable tree the inline pass patches
+	* afterwards.
+	*
+	* Link reference definitions are MATERIALIZED here, so the tree and the
+	* refmap point at one object. Footnote definitions deliberately are not:
+	* a footnote definition is a container whose children are flow blocks, and
+	* materializing those runs the inline pass over them — which consults this
+	* very map. Only the labels are collected, which is all formation needs,
+	* and the nodes are built in document order by the ordinary walk. That is
+	* why `footnoteLabels` is a set of labels rather than a map to nodes; a
+	* consumer wanting the node walks the tree, where it still sits.
+	*/
+	collectReferences(block, context, nodes, refmap, footnoteLabels) {
+		if (block.type === "definition") {
+			const materialized = this.constructOf(block.type).materialize(block, [], context);
+			const key = block.data.definition?.key;
+			if (materialized?.type === "definition" && key !== void 0) {
+				nodes.set(block, materialized);
+				if (!refmap.has(key)) refmap.set(key, materialized);
+			}
+			return;
+		}
+		const footnoteKey = block.data.footnote?.key;
+		if (footnoteKey !== void 0) footnoteLabels.add(footnoteKey);
+		for (const child of block.children) this.collectReferences(child, context, nodes, refmap, footnoteLabels);
+	}
+	parse() {
+		const skippedLines = this.frontmatterCapture?.lineCount ?? 0;
+		this.lineNumber = skippedLines;
+		for (let index = skippedLines; index < this.lines.length; index += 1) {
+			const line = this.lines[index];
+			if (line !== void 0) this.incorporateLine(line);
+		}
+		while (this.tipNode !== void 0) this.finalizeBlock(this.tipNode, this.lines.length);
+		this.doc.endOffset = this.sourceLength;
+		const refmap = /* @__PURE__ */ new Map();
+		const footnoteLabels = /* @__PURE__ */ new Set();
+		const definitionNodes = /* @__PURE__ */ new Map();
+		const rawInlines = [];
+		const context = {
+			position: (start, end) => this.position(start, end),
+			inlineSlice: (block) => prepareInline(block, (start, end) => this.position(start, end), refmap, this.dialectName, footnoteLabels),
+			registerInline: (parent, prepared) => {
+				rawInlines.push({
+					parent,
+					text: prepared.text,
+					startOffset: prepared.startOffset,
+					segments: prepared.segments
+				});
+			}
+		};
+		this.collectReferences(this.doc, context, definitionNodes, refmap, footnoteLabels);
+		const materialized = this.materializeBlock(this.doc, context, definitionNodes);
+		if (materialized === void 0 || materialized.type !== "root") throw new TypeError("block parser: the document construct did not materialize a root");
+		return {
+			root: this.withFrontmatter(materialized),
+			rawInlines,
+			carriers: [],
+			refmap,
+			footnoteLabels
+		};
+	}
+};
+/**
+* Run the block pass over `text`.
+*
+* Every node carries a complete {@link Position}, leaf blocks have their
+* inline content parsed, and `rawInlines` reports the raw text each leaf was
+* built from.
+*/
+const parseBlocks = (text, dialect = "commonmark", frontmatter = false) => new BlockParser(text, blockDialect(dialect), dialect, frontmatter).parse();
+
+//#endregion
+export { parseBlocks };

package/internal/blockRegistry.js

@@ -0,0 +1,90 @@
+import { atxHeadingStart, headingConstruct } from "./blocks/atxHeading.js";
+import { blockquoteConstruct, blockquoteStart } from "./blocks/blockquote.js";
+import { codeConstruct } from "./blocks/code.js";
+import { documentConstruct } from "./blocks/document.js";
+import { fencedCodeStart } from "./blocks/fencedCode.js";
+import { footnoteDefinitionConstruct, footnoteDefinitionStart } from "./blocks/footnoteDefinition.js";
+import { htmlBlockConstruct, htmlBlockStart } from "./blocks/htmlBlock.js";
+import { indentedCodeStart } from "./blocks/indentedCode.js";
+import { definitionConstruct } from "./blocks/linkReferenceDefinition.js";
+import { listConstruct, listItemConstruct, listItemStart } from "./blocks/list.js";
+import { paragraphConstruct } from "./blocks/paragraph.js";
+import { setextHeadingStart } from "./blocks/setextHeading.js";
+import { tableCellConstruct, tableConstruct, tableHeaderStart, tableRowConstruct, tableRowStart } from "./blocks/table.js";
+import { taskListItemStart } from "./blocks/taskListItem.js";
+import { thematicBreakConstruct, thematicBreakStart } from "./blocks/thematicBreak.js";
+
+//#region src/internal/blockRegistry.ts
+const constructTable = (constructs) => new Map(constructs.map((construct) => [construct.type, construct]));
+const commonmarkDialect = {
+	constructs: constructTable([
+		documentConstruct,
+		blockquoteConstruct,
+		listConstruct,
+		listItemConstruct,
+		paragraphConstruct,
+		headingConstruct,
+		thematicBreakConstruct,
+		codeConstruct,
+		htmlBlockConstruct,
+		definitionConstruct
+	]),
+	starts: [
+		blockquoteStart,
+		atxHeadingStart,
+		fencedCodeStart,
+		htmlBlockStart,
+		setextHeadingStart,
+		thematicBreakStart,
+		listItemStart,
+		indentedCodeStart
+	]
+};
+const gfmDialect = {
+	constructs: constructTable([
+		documentConstruct,
+		blockquoteConstruct,
+		listConstruct,
+		listItemConstruct,
+		paragraphConstruct,
+		headingConstruct,
+		thematicBreakConstruct,
+		codeConstruct,
+		htmlBlockConstruct,
+		definitionConstruct,
+		footnoteDefinitionConstruct,
+		tableConstruct,
+		tableRowConstruct,
+		tableCellConstruct
+	]),
+	starts: [
+		blockquoteStart,
+		atxHeadingStart,
+		fencedCodeStart,
+		htmlBlockStart,
+		setextHeadingStart,
+		thematicBreakStart,
+		footnoteDefinitionStart,
+		listItemStart,
+		indentedCodeStart,
+		taskListItemStart,
+		tableHeaderStart,
+		tableRowStart
+	],
+	mayStartBlock: (rest, container) => container.type === "table" || rest.startsWith("[") || rest.startsWith("|") || rest.startsWith(":")
+};
+const dialects = /* @__PURE__ */ new Map([["commonmark", commonmarkDialect], ["gfm", gfmDialect]]);
+/**
+* The block tables for `dialect`.
+*
+* An unknown dialect cannot arrive through the schema-typed public surface,
+* so it is programmer error and dies as a defect.
+*/
+const blockDialect = (dialect) => {
+	const found = dialects.get(dialect);
+	if (found === void 0) throw new TypeError(`unknown markdown dialect: ${String(dialect)}`);
+	return found;
+};
+
+//#endregion
+export { blockDialect };

package/internal/blockTypes.js

@@ -0,0 +1,27 @@
+//#region src/internal/blockTypes.ts
+/** Narrow materialized children to the flow content most constructs contain. */
+const flowChildren = (children) => children.filter((child) => child.type !== "root" && child.type !== "listItem" && child.type !== "tableRow" && child.type !== "tableCell");
+/** Narrow materialized children to the list items a list contains. */
+const listItemChildren = (children) => children.filter((child) => child.type === "listItem");
+/** Narrow materialized children to the rows a table contains. */
+const tableRowChildren = (children) => children.filter((child) => child.type === "tableRow");
+/** Narrow materialized children to the cells a table row contains. */
+const tableCellChildren = (children) => children.filter((child) => child.type === "tableCell");
+/** Open a fresh {@link BlockNode}. */
+const makeBlockNode = (type, startOffset, startLine, depth = 0) => ({
+	type,
+	depth,
+	parent: void 0,
+	children: [],
+	open: true,
+	stringContent: "",
+	segments: [],
+	startOffset,
+	endOffset: startOffset,
+	startLine,
+	endLine: startLine,
+	data: {}
+});
+
+//#endregion
+export { flowChildren, listItemChildren, makeBlockNode, tableCellChildren, tableRowChildren };

package/internal/blocks/atxHeading.js

@@ -0,0 +1,54 @@
+import { Heading } from "../../MarkdownNode.js";
+
+//#region src/internal/blocks/atxHeading.ts
+const reATXHeadingMarker = /^#{1,6}(?:[ \t]+|$)/;
+const reOnlyTrailingHashes = /^[ \t]*#+[ \t]*$/;
+const reClosingHashes = /[ \t]+#+[ \t]*$/;
+/** Narrow a `#`-run length to the schema's depth literal; the regex caps it at 6. */
+const headingDepth = (hashes) => hashes < 1 ? 1 : hashes > 6 ? 6 : hashes;
+/** Heading: never spans more than one line, and contains no blocks. */
+const headingConstruct = {
+	type: "heading",
+	acceptsLines: false,
+	canContain: () => false,
+	continue: () => 1,
+	materialize: (block, _children, context) => {
+		const inline = context.inlineSlice(block);
+		const style = block.data.headingStyle ?? "atx";
+		const node = Heading.make({
+			depth: block.data.level ?? 1,
+			children: inline.children,
+			position: context.position(block.startOffset, block.endOffset),
+			headingStyle: style
+		});
+		context.registerInline(node, inline);
+		return node;
+	}
+};
+/** The ATX heading block start: `#` through `######`, optionally closed. */
+const atxHeadingStart = {
+	name: "atxHeading",
+	trigger: (scanner) => {
+		if (scanner.indented) return 0;
+		const match = reATXHeadingMarker.exec(scanner.currentLine.slice(scanner.nextNonspace));
+		if (match === null) return 0;
+		scanner.advanceNextNonspace();
+		scanner.advanceOffset(match[0].length, false);
+		scanner.closeUnmatchedBlocks();
+		const container = scanner.addChild("heading", scanner.nextNonspace);
+		container.data.level = headingDepth(match[0].trim().length);
+		container.data.headingStyle = "atx";
+		const content = scanner.currentLine.slice(scanner.offset).replace(reOnlyTrailingHashes, "").replace(reClosingHashes, "");
+		container.stringContent = content;
+		container.segments.push({
+			textOffset: 0,
+			sourceOffset: scanner.lineStart + scanner.offset,
+			length: content.length
+		});
+		scanner.advanceOffset(scanner.currentLine.length - scanner.offset, false);
+		return 2;
+	}
+};
+
+//#endregion
+export { atxHeadingStart, headingConstruct };

package/internal/blocks/blockquote.js

@@ -0,0 +1,40 @@
+import { Blockquote } from "../../MarkdownNode.js";
+import { flowChildren } from "../blockTypes.js";
+import { isSpaceOrTab, peekCode } from "../preprocess.js";
+
+//#region src/internal/blocks/blockquote.ts
+const C_GREATERTHAN = 62;
+/** Blockquote: continues while each line carries its `>` marker. */
+const blockquoteConstruct = {
+	type: "blockquote",
+	acceptsLines: false,
+	canContain: (child) => child !== "listItem",
+	continue: (scanner) => {
+		const line = scanner.currentLine;
+		if (scanner.indented || peekCode(line, scanner.nextNonspace) !== C_GREATERTHAN) return 1;
+		scanner.advanceNextNonspace();
+		scanner.advanceOffset(1, false);
+		if (isSpaceOrTab(peekCode(line, scanner.offset))) scanner.advanceOffset(1, true);
+		return 0;
+	},
+	materialize: (block, children, context) => Blockquote.make({
+		children: flowChildren(children),
+		position: context.position(block.startOffset, block.endOffset)
+	})
+};
+/** The blockquote block start: an unindented `>`. */
+const blockquoteStart = {
+	name: "blockquote",
+	trigger: (scanner) => {
+		if (scanner.indented || peekCode(scanner.currentLine, scanner.nextNonspace) !== C_GREATERTHAN) return 0;
+		scanner.advanceNextNonspace();
+		scanner.advanceOffset(1, false);
+		if (isSpaceOrTab(peekCode(scanner.currentLine, scanner.offset))) scanner.advanceOffset(1, true);
+		scanner.closeUnmatchedBlocks();
+		scanner.addChild("blockquote", scanner.nextNonspace);
+		return 1;
+	}
+};
+
+//#endregion
+export { blockquoteConstruct, blockquoteStart };