@effected/markdown 0.2.0

package/internal/blocks/code.js

@@ -0,0 +1,90 @@
+import { Code } from "../../MarkdownNode.js";
+import { isSpaceOrTab, peekCode } from "../preprocess.js";
+import { unescapeString } from "../unescape.js";
+
+//#region src/internal/blocks/code.ts
+const reBlankLine = /^[ \t]*$/;
+const reClosingCodeFence = /^(?:`{3,}|~{3,})(?=[ \t]*$)/;
+/**
+* Drop the trailing blank lines an indented code block accumulates, and pull
+* the block's end back to the last line that survived.
+*/
+const finalizeIndented = (block) => {
+	const lines = block.stringContent.split("\n");
+	while (lines.length > 0 && reBlankLine.test(lines[lines.length - 1] ?? "")) lines.pop();
+	block.stringContent = lines.length === 0 ? "" : `${lines.join("\n")}\n`;
+	const lastSegment = block.segments[lines.length - 1];
+	if (lastSegment !== void 0) {
+		block.endOffset = lastSegment.sourceOffset + lastSegment.length;
+		block.endLine = block.startLine + lines.length - 1;
+	}
+};
+/**
+* Split a fenced block's first line off as the info string, and the rest as
+* the literal content.
+*
+* mdast splits the info string into `lang` (the first word) and `meta` (the
+* rest); upstream keeps it whole as `info`. Each half is unescaped
+* separately, so a backslash-escaped space inside the language word does not
+* become a split point.
+*/
+const finalizeFenced = (block) => {
+	const content = block.stringContent;
+	const newlineAt = content.indexOf("\n");
+	const firstLine = (newlineAt === -1 ? content : content.slice(0, newlineAt)).trim();
+	block.stringContent = newlineAt === -1 ? "" : content.slice(newlineAt + 1);
+	if (firstLine.length === 0) return;
+	const wordEnd = firstLine.search(/[ \t]/);
+	if (wordEnd === -1) {
+		block.data.lang = unescapeString(firstLine);
+		return;
+	}
+	block.data.lang = unescapeString(firstLine.slice(0, wordEnd));
+	const meta = firstLine.slice(wordEnd).trim();
+	if (meta.length > 0) block.data.meta = unescapeString(meta);
+};
+/** Code: absorbs lines verbatim, contains nothing. */
+const codeConstruct = {
+	type: "code",
+	acceptsLines: true,
+	canContain: () => false,
+	continue: (scanner, block) => {
+		if (block.data.isFenced === true) {
+			const line = scanner.currentLine;
+			const closing = scanner.indent <= 3 && line.charAt(scanner.nextNonspace) === block.data.fenceChar ? reClosingCodeFence.exec(line.slice(scanner.nextNonspace)) : null;
+			if (closing !== null && closing[0].length >= (block.data.fenceLength ?? 3)) {
+				scanner.setLastLineLength(scanner.offset + scanner.indent + closing[0].length);
+				scanner.finalizeBlock(block, scanner.lineNumber);
+				return 2;
+			}
+			let remaining = block.data.fenceOffset ?? 0;
+			while (remaining > 0 && isSpaceOrTab(peekCode(line, scanner.offset))) {
+				scanner.advanceOffset(1, true);
+				remaining -= 1;
+			}
+			return 0;
+		}
+		if (scanner.indent >= 4) scanner.advanceOffset(4, true);
+		else if (scanner.blank) scanner.advanceNextNonspace();
+		else return 1;
+		return 0;
+	},
+	finalize: (_scanner, block) => {
+		if (block.data.isFenced === true) finalizeFenced(block);
+		else finalizeIndented(block);
+	},
+	materialize: (block, _children, context) => {
+		const { isFenced, fenceChar, fenceLength, lang, meta } = block.data;
+		return Code.make({
+			value: block.stringContent,
+			position: context.position(block.startOffset, block.endOffset),
+			...lang === void 0 ? {} : { lang },
+			...meta === void 0 ? {} : { meta },
+			...isFenced === true && fenceChar !== void 0 ? { fenceChar } : {},
+			...isFenced === true && fenceLength !== void 0 ? { fenceLength } : {}
+		});
+	}
+};
+
+//#endregion
+export { codeConstruct };

package/internal/blocks/document.js

@@ -0,0 +1,17 @@
+import { Root } from "../../MarkdownNode.js";
+
+//#region src/internal/blocks/document.ts
+/** The document root: contains everything except a bare list item. */
+const documentConstruct = {
+	type: "document",
+	acceptsLines: false,
+	canContain: (child) => child !== "listItem",
+	continue: () => 0,
+	materialize: (block, children, context) => Root.make({
+		children,
+		position: context.position(block.startOffset, block.endOffset)
+	})
+};
+
+//#endregion
+export { documentConstruct };

package/internal/blocks/fencedCode.js

@@ -0,0 +1,26 @@
+//#region src/internal/blocks/fencedCode.ts
+const reCodeFence = /^`{3,}(?!.*`)|^~{3,}/;
+const fenceCharOf = (char) => char === "`" || char === "~" ? char : void 0;
+/** The fenced-code block start: three or more backticks or tildes. */
+const fencedCodeStart = {
+	name: "fencedCode",
+	trigger: (scanner) => {
+		if (scanner.indented) return 0;
+		const match = reCodeFence.exec(scanner.currentLine.slice(scanner.nextNonspace));
+		if (match === null) return 0;
+		const fenceChar = fenceCharOf(match[0].charAt(0));
+		if (fenceChar === void 0) return 0;
+		scanner.closeUnmatchedBlocks();
+		const container = scanner.addChild("code", scanner.nextNonspace);
+		container.data.isFenced = true;
+		container.data.fenceLength = match[0].length;
+		container.data.fenceChar = fenceChar;
+		container.data.fenceOffset = scanner.indent;
+		scanner.advanceNextNonspace();
+		scanner.advanceOffset(match[0].length, false);
+		return 2;
+	}
+};
+
+//#endregion
+export { fencedCodeStart };

package/internal/blocks/footnoteDefinition.js

@@ -0,0 +1,84 @@
+import { FootnoteDefinition } from "../../MarkdownNode.js";
+import { flowChildren } from "../blockTypes.js";
+import { stickyOf } from "../patterns.js";
+import { normalizeLabelText } from "../references.js";
+
+//#region src/internal/blocks/footnoteDefinition.ts
+/**
+* `_scan_footnote_definition` from `src/scanners.re`:
+*
+* ```re2c
+* '[^' ([^\] \r\n\x00\t]+) ']:' [ \t]*
+* ```
+*
+* The label class is the whole grammar and the whole surprise: a footnote
+* label may hold no whitespace at all, which is where it parts company with a
+* link reference label. The line terminators in the class are unreachable here
+* (the block pass hands over one line at a time, terminator stripped) but stay
+* so the class reads as upstream's.
+*/
+const reFootnoteDefinition = /\[\^([^\]\0\t\n\r ]+)\]:[ \t]*/;
+/** Columns of indentation a continuation line must carry. */
+const CONTINUATION_INDENT = 4;
+/**
+* FootnoteDefinition: a container whose children are flow blocks, continued by
+* four columns of indentation.
+*/
+const footnoteDefinitionConstruct = {
+	type: "footnoteDefinition",
+	acceptsLines: false,
+	canContain: (child) => child !== "listItem",
+	continue: (scanner) => {
+		if (scanner.indent >= CONTINUATION_INDENT) {
+			scanner.advanceOffset(CONTINUATION_INDENT, true);
+			return 0;
+		}
+		return scanner.currentLine.length === 0 ? 0 : 1;
+	},
+	materialize: (block, children, context) => {
+		const footnote = block.data.footnote;
+		if (footnote === void 0) return;
+		return FootnoteDefinition.make({
+			identifier: footnote.identifier,
+			label: footnote.label,
+			children: flowChildren(children),
+			position: context.position(block.startOffset, block.endOffset)
+		});
+	}
+};
+/**
+* The footnote-definition block start: an unindented `[^label]:`.
+*
+* Registered at the CORE position cmark-gfm runs it from — after the thematic
+* break, before the list marker — rather than with the GFM extensions at the
+* end of the table, because that is literally where the branch sits in
+* `open_new_blocks`. It carries no `cont_type == PARAGRAPH` guard, so unlike
+* the thematic break above it, a footnote definition interrupts a paragraph.
+*/
+const footnoteDefinitionStart = {
+	name: "footnoteDefinition",
+	trigger: (scanner) => {
+		if (scanner.indented) return 0;
+		const sticky = stickyOf(reFootnoteDefinition);
+		sticky.lastIndex = scanner.nextNonspace;
+		const found = sticky.exec(scanner.currentLine);
+		const rawLabel = found?.[1];
+		if (found === null || rawLabel === void 0) return 0;
+		const key = normalizeLabelText(rawLabel);
+		if (key === "") return 0;
+		scanner.closeUnmatchedBlocks();
+		const start = scanner.nextNonspace;
+		scanner.advanceNextNonspace();
+		scanner.advanceOffset(found[0].length, false);
+		const block = scanner.addChild("footnoteDefinition", start);
+		block.data.footnote = {
+			key,
+			identifier: key.toLowerCase(),
+			label: rawLabel
+		};
+		return 1;
+	}
+};
+
+//#endregion
+export { footnoteDefinitionConstruct, footnoteDefinitionStart };

package/internal/blocks/frontmatter.js

@@ -0,0 +1,56 @@
+//#region src/internal/blocks/frontmatter.ts
+const FENCES = /* @__PURE__ */ new Map([
+	["---", {
+		format: "yaml",
+		close: "---"
+	}],
+	["+++", {
+		format: "toml",
+		close: "+++"
+	}],
+	["---json", {
+		format: "json",
+		close: "---"
+	}]
+]);
+/**
+* Scan the head of a preprocessed document for a frontmatter block.
+*
+* `lines` is the preprocessor's line table (U+0000 already replaced,
+* terminators stripped, absolute `start` offsets); `text` is the original
+* source, consulted only for the terminators between value lines — a
+* terminator can never contain U+0000, so slicing it from the source is
+* exact, and the value keeps CRLF interiors verbatim while the line content
+* keeps the preprocessor's U+FFFD replacement.
+*
+* Returns `null` when the document has no frontmatter — which is the common
+* case and never an error.
+*/
+const scanFrontmatter = (lines, text) => {
+	const opening = lines[0];
+	if (opening === void 0 || opening.start !== 0) return null;
+	const rule = FENCES.get(opening.text);
+	if (rule === void 0) return null;
+	for (let index = 1; index < lines.length; index += 1) {
+		const line = lines[index];
+		if (line === void 0 || line.text !== rule.close) continue;
+		const parts = [];
+		for (let inner = 1; inner < index; inner += 1) {
+			const current = lines[inner];
+			const next = lines[inner + 1];
+			if (current === void 0 || next === void 0) break;
+			parts.push(current.text);
+			if (inner + 1 < index) parts.push(text.slice(current.start + current.text.length, next.start));
+		}
+		return {
+			format: rule.format,
+			value: parts.join(""),
+			lineCount: index + 1,
+			endOffset: line.start + line.text.length
+		};
+	}
+	return null;
+};
+
+//#endregion
+export { scanFrontmatter };

package/internal/blocks/htmlBlock.js

@@ -0,0 +1,72 @@
+import { Html } from "../../MarkdownNode.js";
+import { peekCode } from "../preprocess.js";
+import { CLOSETAG, OPENTAG } from "../htmlTags.js";
+
+//#region src/internal/blocks/htmlBlock.ts
+const C_LESSTHAN = 60;
+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|section|search|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,
+	/-->/,
+	/\?>/,
+	/>/,
+	/\]\]>/
+];
+/**
+* Whether `rest` closes `block` — only types 1 through 5 have a closing
+* pattern, and the line loop calls this after the line has been appended.
+*/
+const isHtmlBlockEnd = (block, rest) => {
+	const type = block.data.htmlBlockType;
+	if (type === void 0 || type < 1 || type > 5) return false;
+	return reHtmlBlockClose[type]?.test(rest) ?? false;
+};
+/** HTML block: absorbs lines verbatim, contains nothing. */
+const htmlBlockConstruct = {
+	type: "html",
+	acceptsLines: true,
+	canContain: () => false,
+	continue: (scanner, block) => {
+		const type = block.data.htmlBlockType;
+		return scanner.blank && (type === 6 || type === 7) ? 1 : 0;
+	},
+	finalize: (_scanner, block) => {
+		block.stringContent = block.stringContent.replace(/\n$/, "");
+	},
+	materialize: (block, _children, context) => Html.make({
+		value: block.stringContent,
+		position: context.position(block.startOffset, block.endOffset)
+	})
+};
+/** The HTML block start: one of seven open conditions after an unindented `<`. */
+const htmlBlockStart = {
+	name: "htmlBlock",
+	trigger: (scanner, container) => {
+		if (scanner.indented || peekCode(scanner.currentLine, scanner.nextNonspace) !== C_LESSTHAN) return 0;
+		const rest = scanner.currentLine.slice(scanner.nextNonspace);
+		for (let blockType = 1; blockType <= 7; blockType += 1) {
+			const opens = reHtmlBlockOpen[blockType]?.test(rest) ?? false;
+			const mayOpen = blockType < 7 || container.type !== "paragraph" && !(!scanner.allClosed && !scanner.blank && scanner.tip.type === "paragraph");
+			if (opens && mayOpen) {
+				scanner.closeUnmatchedBlocks();
+				const block = scanner.addChild("html", scanner.offset);
+				block.data.htmlBlockType = blockType;
+				return 2;
+			}
+		}
+		return 0;
+	}
+};
+
+//#endregion
+export { htmlBlockConstruct, htmlBlockStart, isHtmlBlockEnd };

package/internal/blocks/indentedCode.js

@@ -0,0 +1,16 @@
+//#region src/internal/blocks/indentedCode.ts
+/** The indented-code block start: four columns of indentation. */
+const indentedCodeStart = {
+	name: "indentedCode",
+	trigger: (scanner) => {
+		if (!scanner.indented || scanner.tip.type === "paragraph" || scanner.blank) return 0;
+		const start = scanner.offset;
+		scanner.advanceOffset(4, true);
+		scanner.closeUnmatchedBlocks();
+		scanner.addChild("code", start);
+		return 2;
+	}
+};
+
+//#endregion
+export { indentedCodeStart };

package/internal/blocks/linkReferenceDefinition.js

@@ -0,0 +1,72 @@
+import { Definition } from "../../MarkdownNode.js";
+import { makeBlockNode } from "../blockTypes.js";
+import { parseReference } from "../references.js";
+import { sliceWithSegments, sourceOffsetAt } from "../segments.js";
+
+//#region src/internal/blocks/linkReferenceDefinition.ts
+const C_OPEN_BRACKET = 91;
+/**
+* Split every leading link reference definition out of `block`, inserting one
+* `definition` node per definition into `block`'s parent, immediately before
+* `block` itself.
+*
+* Definitions can only ever start a paragraph — they cannot interrupt one —
+* so a single leading pass is exhaustive.
+*/
+const extractDefinitions = (block) => {
+	const parent = block.parent;
+	if (parent === void 0) return;
+	while (block.stringContent.charCodeAt(0) === C_OPEN_BRACKET) {
+		const reference = parseReference(block.stringContent);
+		if (reference === void 0) return;
+		const consumed = block.stringContent.slice(0, reference.length);
+		const startOffset = sourceOffsetAt(block.segments, 0, block.startOffset);
+		const linesConsumed = (consumed.match(/\n/g) ?? []).length;
+		const contentLength = consumed.replace(/[ \t\r\n]+$/, "").length;
+		const endOffset = sourceOffsetAt(block.segments, contentLength, startOffset);
+		const contentLines = (consumed.slice(0, contentLength).match(/\n/g) ?? []).length;
+		const node = makeBlockNode("definition", startOffset, block.startLine, block.depth);
+		node.parent = parent;
+		node.open = false;
+		node.endOffset = endOffset;
+		node.endLine = block.startLine + contentLines;
+		node.data.definition = {
+			key: reference.key,
+			identifier: reference.identifier,
+			label: reference.label,
+			url: reference.url,
+			...reference.title === void 0 ? {} : { title: reference.title }
+		};
+		const at = parent.children.indexOf(block);
+		parent.children.splice(at === -1 ? parent.children.length : at, 0, node);
+		const remaining = sliceWithSegments(block.segments, reference.length, block.stringContent.length);
+		block.stringContent = block.stringContent.slice(reference.length);
+		block.segments.splice(0, block.segments.length, ...remaining);
+		block.startLine += linesConsumed;
+		block.startOffset = remaining[0]?.sourceOffset ?? endOffset;
+	}
+};
+/**
+* Definition: a node with no block start of its own — {@link extractDefinitions}
+* is the only thing that ever creates one, already closed.
+*/
+const definitionConstruct = {
+	type: "definition",
+	acceptsLines: false,
+	canContain: () => false,
+	continue: () => 1,
+	materialize: (block, _children, context) => {
+		const definition = block.data.definition;
+		if (definition === void 0) return;
+		return Definition.make({
+			identifier: definition.identifier,
+			label: definition.label,
+			url: definition.url,
+			position: context.position(block.startOffset, block.endOffset),
+			...definition.title === void 0 ? {} : { title: definition.title }
+		});
+	}
+};
+
+//#endregion
+export { definitionConstruct, extractDefinitions };

package/internal/blocks/list.js

@@ -0,0 +1,159 @@
+import { List, ListItem } from "../../MarkdownNode.js";
+import { flowChildren, listItemChildren } from "../blockTypes.js";
+import { isSpaceOrTab, peekCode } from "../preprocess.js";
+
+//#region src/internal/blocks/list.ts
+const reBulletListMarker = /^[*+-]/;
+const reOrderedListMarker = /^(\d{1,9})([.)])/;
+const reNonSpace = /[^ \t\f\v\r\n]/;
+const bulletCharOf = (char) => char === "-" || char === "*" || char === "+" ? char : void 0;
+const delimiterOf = (char) => char === "." || char === ")" ? char : void 0;
+/**
+* Parse a list marker at the scanner's next non-whitespace position,
+* advancing past it on success.
+*/
+const parseListMarker = (scanner, container) => {
+	if (scanner.indent >= 4) return;
+	const rest = scanner.currentLine.slice(scanner.nextNonspace);
+	const markerOffset = scanner.indent;
+	let data;
+	let markerLength;
+	const bullet = reBulletListMarker.exec(rest);
+	const ordered = bullet === null ? reOrderedListMarker.exec(rest) : null;
+	if (bullet !== null) {
+		const bulletChar = bulletCharOf(bullet[0].charAt(0));
+		data = {
+			type: "bullet",
+			tight: true,
+			padding: 0,
+			markerOffset,
+			...bulletChar === void 0 ? {} : { bulletChar }
+		};
+		markerLength = bullet[0].length;
+	} else if (ordered !== null && (container.type !== "paragraph" || Number.parseInt(ordered[1] ?? "", 10) === 1)) {
+		const delimiter = delimiterOf(ordered[2] ?? "");
+		data = {
+			type: "ordered",
+			tight: true,
+			padding: 0,
+			markerOffset,
+			start: Number.parseInt(ordered[1] ?? "1", 10),
+			...delimiter === void 0 ? {} : { delimiter }
+		};
+		markerLength = ordered[0].length;
+	} else return;
+	const afterMarker = peekCode(scanner.currentLine, scanner.nextNonspace + markerLength);
+	if (!(afterMarker === -1 || isSpaceOrTab(afterMarker))) return;
+	if (container.type === "paragraph" && !reNonSpace.test(scanner.currentLine.slice(scanner.nextNonspace + markerLength))) return;
+	scanner.advanceNextNonspace();
+	scanner.advanceOffset(markerLength, true);
+	const spacesStartColumn = scanner.column;
+	const spacesStartOffset = scanner.offset;
+	do
+		scanner.advanceOffset(1, true);
+	while (scanner.column - spacesStartColumn < 5 && isSpaceOrTab(peekCode(scanner.currentLine, scanner.offset)));
+	const blankItem = peekCode(scanner.currentLine, scanner.offset) === -1;
+	const spacesAfterMarker = scanner.column - spacesStartColumn;
+	if (spacesAfterMarker >= 5 || spacesAfterMarker < 1 || blankItem) {
+		data.padding = markerLength + 1;
+		scanner.setScanPosition(spacesStartOffset, spacesStartColumn);
+		if (isSpaceOrTab(peekCode(scanner.currentLine, scanner.offset))) scanner.advanceOffset(1, true);
+	} else data.padding = markerLength + spacesAfterMarker;
+	return data;
+};
+/** Two markers belong to the same list when type, delimiter and bullet agree. */
+const listsMatch = (listData, itemData) => listData.type === itemData.type && listData.delimiter === itemData.delimiter && listData.bulletChar === itemData.bulletChar;
+/** Whether `block` is followed by a sibling that a blank line separates from it. */
+const endsWithBlankLine = (block, next) => next !== void 0 && block.endLine !== next.startLine - 1;
+/** Whether any of `block`'s children are separated from the next by a blank line. */
+const hasBlankLineBetweenChildren = (block) => block.children.some((child, index) => endsWithBlankLine(child, block.children[index + 1]));
+/** List: a container of list items and nothing else. */
+const listConstruct = {
+	type: "list",
+	acceptsLines: false,
+	canContain: (child) => child === "listItem",
+	continue: () => 0,
+	finalize: (_scanner, block) => {
+		let tight = true;
+		for (const [index, item] of block.children.entries()) {
+			const itemSpread = hasBlankLineBetweenChildren(item);
+			item.data.spread = itemSpread;
+			if (endsWithBlankLine(item, block.children[index + 1]) || itemSpread) tight = false;
+		}
+		const listData = block.data.listData;
+		if (listData !== void 0) listData.tight = tight;
+		block.data.spread = !tight;
+		const last = block.children[block.children.length - 1];
+		if (last !== void 0) {
+			block.endOffset = last.endOffset;
+			block.endLine = last.endLine;
+		}
+	},
+	materialize: (block, children, context) => {
+		const listData = block.data.listData;
+		const ordered = listData?.type === "ordered";
+		return List.make({
+			ordered,
+			spread: block.data.spread ?? false,
+			children: listItemChildren(children),
+			position: context.position(block.startOffset, block.endOffset),
+			...ordered && listData?.start !== void 0 ? { start: listData.start } : {},
+			...listData?.bulletChar === void 0 ? {} : { bulletChar: listData.bulletChar },
+			...listData?.delimiter === void 0 ? {} : { delimiter: listData.delimiter }
+		});
+	}
+};
+/** List item: a container of anything but a bare list item. */
+const listItemConstruct = {
+	type: "listItem",
+	acceptsLines: false,
+	canContain: (child) => child !== "listItem",
+	continue: (scanner, block) => {
+		const listData = block.data.listData;
+		if (listData === void 0) return 1;
+		if (scanner.blank) {
+			if (block.children.length === 0) return 1;
+			scanner.advanceNextNonspace();
+		} else if (scanner.indent >= listData.markerOffset + listData.padding) scanner.advanceOffset(listData.markerOffset + listData.padding, true);
+		else return 1;
+		return 0;
+	},
+	finalize: (_scanner, block) => {
+		const last = block.children[block.children.length - 1];
+		if (last !== void 0) {
+			block.endOffset = last.endOffset;
+			block.endLine = last.endLine;
+			return;
+		}
+		block.endLine = block.startLine;
+		block.endOffset = block.startOffset + (block.data.listData?.padding ?? 0);
+	},
+	materialize: (block, children, context) => ListItem.make({
+		spread: block.data.spread ?? false,
+		children: flowChildren(children),
+		position: context.position(block.startOffset, block.endOffset),
+		...block.data.checked === void 0 ? {} : { checked: block.data.checked }
+	})
+};
+/** The list-item block start: a bullet or ordered marker. */
+const listItemStart = {
+	name: "listItem",
+	trigger: (scanner, container) => {
+		if (scanner.indented && container.type !== "list") return 0;
+		const data = parseListMarker(scanner, container);
+		if (data === void 0) return 0;
+		scanner.closeUnmatchedBlocks();
+		const openList = scanner.tip;
+		const openListData = openList.data.listData;
+		if (openList.type !== "list" || openListData === void 0 || !listsMatch(openListData, data)) {
+			const list = scanner.addChild("list", scanner.nextNonspace);
+			list.data.listData = data;
+		}
+		const item = scanner.addChild("listItem", scanner.nextNonspace);
+		item.data.listData = data;
+		return 1;
+	}
+};
+
+//#endregion
+export { listConstruct, listItemConstruct, listItemStart };

package/internal/blocks/paragraph.js

@@ -0,0 +1,27 @@
+import { Paragraph } from "../../MarkdownNode.js";
+import { extractDefinitions } from "./linkReferenceDefinition.js";
+
+//#region src/internal/blocks/paragraph.ts
+/** Paragraph: absorbs lines until a blank one, and contains nothing. */
+const paragraphConstruct = {
+	type: "paragraph",
+	acceptsLines: true,
+	canContain: () => false,
+	continue: (scanner) => scanner.blank ? 1 : 0,
+	finalize: (_scanner, block) => {
+		extractDefinitions(block);
+	},
+	materialize: (block, _children, context) => {
+		const inline = context.inlineSlice(block);
+		if (inline.text.length === 0) return;
+		const node = Paragraph.make({
+			children: inline.children,
+			position: context.position(block.startOffset, block.endOffset)
+		});
+		context.registerInline(node, inline);
+		return node;
+	}
+};
+
+//#endregion
+export { paragraphConstruct };

package/internal/blocks/setextHeading.js

@@ -0,0 +1,24 @@
+import { extractDefinitions } from "./linkReferenceDefinition.js";
+
+//#region src/internal/blocks/setextHeading.ts
+const reSetextHeadingLine = /^(?:=+|-+)[ \t]*$/;
+/** The setext heading block start: a run of `=` or `-` under a paragraph. */
+const setextHeadingStart = {
+	name: "setextHeading",
+	trigger: (scanner, container) => {
+		if (scanner.indented || container.type !== "paragraph") return 0;
+		const match = reSetextHeadingLine.exec(scanner.currentLine.slice(scanner.nextNonspace));
+		if (match === null) return 0;
+		scanner.closeUnmatchedBlocks();
+		extractDefinitions(container);
+		if (container.stringContent.length === 0) return 0;
+		const heading = scanner.replaceBlock(container, "heading");
+		heading.data.level = match[0].charAt(0) === "=" ? 1 : 2;
+		heading.data.headingStyle = "setext";
+		scanner.advanceOffset(scanner.currentLine.length - scanner.offset, false);
+		return 2;
+	}
+};
+
+//#endregion
+export { setextHeadingStart };