@effected/markdown 0.2.0

package/internal/inlines/link.js

@@ -0,0 +1,212 @@
+import { ReferenceScanner, normalizeReference } from "../references.js";
+import { appendChild, childrenOf, insertAfter, makeInlineNode, unlink } from "../inlineNode.js";
+
+//#region src/internal/inlines/link.ts
+const C_BANG = 33;
+const C_CARET = 94;
+const C_OPEN_BRACKET = 91;
+const C_CLOSE_BRACKET = 93;
+const C_OPEN_PAREN = 40;
+const C_CLOSE_PAREN = 41;
+const reWhitespaceChar = /^[ \t\n\v\f\r]/;
+/**
+* Run one of `references.ts`'s grammar functions over the subject at the
+* scanner's cursor, keeping the two cursors in step.
+*
+* The destination, title and label grammars are identical wherever they
+* appear, so a link reuses exactly what a definition parsed with.
+*/
+const withReferenceScanner = (scanner, run) => {
+	const reference = new ReferenceScanner(scanner.subject);
+	reference.pos = scanner.pos;
+	const result = run(reference);
+	scanner.pos = reference.pos;
+	return result;
+};
+/**
+* The plain-text flattening of a node list — an image's `alt`.
+*
+* ITERATIVE ON PURPOSE. This runs while the brackets close, before
+* materialization's depth guard has seen anything, and the content it walks
+* can nest as deeply as the input has balanced delimiters: the recursive
+* spelling died with a `RangeError` — a defect, not a typed error — on
+* `![` plus ten thousand nested emphasis markers. A flattening has no reason
+* to recurse, so it does not, and needs no cap.
+*/
+const plainTextOf = (nodes) => {
+	let text = "";
+	const pending = [...nodes].reverse();
+	while (pending.length > 0) {
+		const node = pending.pop();
+		if (node === void 0) break;
+		if (node.type === "text" || node.type === "inlineCode") text += node.value;
+		else if (node.type === "image" || node.type === "imageReference") text += node.value;
+		else {
+			const children = childrenOf(node);
+			for (let index = children.length - 1; index >= 0; index -= 1) {
+				const child = children[index];
+				if (child !== void 0) pending.push(child);
+			}
+		}
+	}
+	return text;
+};
+/** `[` — a potential link opener. */
+const linkOpenConstruct = {
+	name: "linkOpen",
+	triggers: [C_OPEN_BRACKET],
+	parse: (scanner) => {
+		const startpos = scanner.pos;
+		scanner.pos += 1;
+		const node = scanner.appendText("[", startpos, scanner.pos);
+		scanner.addBracket(node, startpos, false);
+		return true;
+	}
+};
+/**
+* Build the `!` construct — an image opener when a `[` follows, otherwise
+* literal.
+*
+* `caretOpensImage` is the second GFM footnote seam, and the surprising one.
+* cmark-gfm's bang handler reads
+*
+* ```c
+* if (peek_char(subj) == '[' && peek_char_n(subj, 1) != '^') {
+* ```
+*
+* so under GFM `![^` NEVER opens an image: the `!` stays literal text and the
+* `[` becomes an ordinary bracket, which is what lets `text![^1]` render as a
+* literal `!` followed by a footnote reference (`extensions.txt` example 23
+* pins exactly that). It also means the footnote branch in the close-bracket
+* handler can never see an image opener, which is why that branch does not
+* test for one. CommonMark passes `true` and is untouched.
+*/
+const makeImageOpenConstruct = (caretOpensImage) => ({
+	name: "imageOpen",
+	triggers: [C_BANG],
+	parse: (scanner) => {
+		const startpos = scanner.pos;
+		scanner.pos += 1;
+		if (scanner.peek() === C_OPEN_BRACKET && (caretOpensImage || scanner.subject.charCodeAt(scanner.pos + 1) !== C_CARET)) {
+			scanner.pos += 1;
+			const node = scanner.appendText("![", startpos, scanner.pos);
+			scanner.addBracket(node, startpos + 1, true);
+			return true;
+		}
+		scanner.appendText("!", startpos, scanner.pos);
+		return true;
+	}
+});
+/** `!` — an image opener when a `[` follows, otherwise literal. */
+const imageOpenConstruct = makeImageOpenConstruct(true);
+/**
+* Build the `]` construct — closes a link or image, or stays literal.
+*
+* `onNoMatch` is the dialect seam described on {@link LinkCloseFallback}. With
+* none, this is CommonMark's close-bracket handler exactly.
+*/
+const makeLinkCloseConstruct = (onNoMatch) => ({
+	name: "linkClose",
+	triggers: [C_CLOSE_BRACKET],
+	parse: (scanner) => {
+		const bracketPos = scanner.pos;
+		scanner.pos += 1;
+		const startpos = scanner.pos;
+		const opener = scanner.brackets;
+		if (opener === void 0) {
+			scanner.appendText("]", bracketPos, scanner.pos);
+			return true;
+		}
+		if (!opener.active) {
+			scanner.appendText("]", bracketPos, scanner.pos);
+			scanner.removeBracket();
+			return true;
+		}
+		const isImage = opener.image;
+		const savepos = scanner.pos;
+		let url;
+		let title;
+		let matched = false;
+		if (scanner.peek() === C_OPEN_PAREN) {
+			scanner.pos += 1;
+			const inline = withReferenceScanner(scanner, (reference) => {
+				reference.spnl();
+				const destination = reference.parseLinkDestination();
+				if (destination === void 0) return;
+				reference.spnl();
+				const parsedTitle = reWhitespaceChar.test(reference.subject.charAt(reference.pos - 1)) ? reference.parseLinkTitle() : void 0;
+				reference.spnl();
+				if (reference.peek() !== C_CLOSE_PAREN) return;
+				reference.pos += 1;
+				return {
+					destination,
+					parsedTitle
+				};
+			});
+			if (inline === void 0) scanner.pos = savepos;
+			else {
+				url = inline.destination;
+				title = inline.parsedTitle;
+				matched = true;
+			}
+		}
+		let identifier;
+		let rawLabel;
+		let referenceType = "shortcut";
+		if (!matched) {
+			const beforeLabel = scanner.pos;
+			const labelLength = withReferenceScanner(scanner, (reference) => reference.parseLinkLabel());
+			if (labelLength > 2) {
+				rawLabel = scanner.subject.slice(beforeLabel, beforeLabel + labelLength);
+				referenceType = "full";
+			} else if (opener.bracketAfter !== true) {
+				rawLabel = scanner.subject.slice(opener.index, startpos);
+				referenceType = labelLength === 2 ? "collapsed" : "shortcut";
+			}
+			if (labelLength === 0) scanner.pos = savepos;
+			if (rawLabel !== void 0) {
+				const key = normalizeReference(rawLabel);
+				if (scanner.refmap.has(key)) {
+					identifier = key.toLowerCase();
+					matched = true;
+				}
+			}
+		}
+		if (!matched) {
+			if (onNoMatch?.(scanner, opener, bracketPos, startpos) === true) return true;
+			scanner.removeBracket();
+			scanner.pos = startpos;
+			scanner.appendText("]", bracketPos, scanner.pos);
+			return true;
+		}
+		const node = makeInlineNode(identifier === void 0 ? isImage ? "image" : "link" : isImage ? "imageReference" : "linkReference", opener.node.start, scanner.pos);
+		let child = opener.node.next;
+		while (child !== void 0) {
+			const following = child.next;
+			appendChild(node, child);
+			child = following;
+		}
+		insertAfter(opener.node, node);
+		if (identifier === void 0) {
+			if (url !== void 0) node.data.url = url;
+			if (title !== void 0) node.data.title = title;
+		} else {
+			node.data.identifier = identifier;
+			node.data.label = rawLabel === void 0 ? identifier : rawLabel.slice(1, -1);
+			node.data.referenceType = referenceType;
+		}
+		scanner.processEmphasis(opener.previousDelimiter);
+		scanner.removeBracket();
+		unlink(opener.node);
+		if (isImage) {
+			node.value = plainTextOf(childrenOf(node));
+			for (const orphan of childrenOf(node)) unlink(orphan);
+		} else scanner.deactivateLinkOpeners();
+		return true;
+	}
+});
+/** `]` — closes a link or image, or stays literal. The CommonMark spelling. */
+const linkCloseConstruct = makeLinkCloseConstruct();
+
+//#endregion
+export { imageOpenConstruct, linkCloseConstruct, linkOpenConstruct, makeImageOpenConstruct, makeLinkCloseConstruct };

package/internal/inlines/rawHtml.js

@@ -0,0 +1,27 @@
+import { reHtmlTag } from "../htmlTags.js";
+import { makeInlineNode } from "../inlineNode.js";
+
+//#region src/internal/inlines/rawHtml.ts
+const C_LESSTHAN = 60;
+/** The raw-HTML forms that scan forward for a fixed closing sequence. */
+const UNTERMINATED_FORMS = [
+	["<!--", "-->"],
+	["<?", "?>"],
+	["<![CDATA[", "]]>"]
+];
+/** A raw HTML tag, comment, processing instruction, declaration or CDATA. */
+const rawHtmlConstruct = {
+	name: "rawHtml",
+	triggers: [C_LESSTHAN],
+	parse: (scanner) => {
+		const from = scanner.pos;
+		for (const [opener, closer] of UNTERMINATED_FORMS) if (scanner.subject.startsWith(opener, from) && !scanner.hasAhead(closer)) return false;
+		const matched = scanner.match(reHtmlTag);
+		if (matched === void 0) return false;
+		scanner.append(makeInlineNode("html", from, scanner.pos, matched));
+		return true;
+	}
+};
+
+//#endregion
+export { rawHtmlConstruct };

package/internal/inlines/strikethrough.js

@@ -0,0 +1,81 @@
+import { appendChild, insertAfter, makeInlineNode, unlink } from "../inlineNode.js";
+import { scanDelims } from "./emphasis.js";
+
+//#region src/internal/inlines/strikethrough.ts
+/** The `~` character code — the construct's only trigger. */
+const C_TILDE = 126;
+/**
+* Consume a `~` run as literal text and, when it is a viable one- or
+* two-tilde run, push it onto the shared delimiter stack.
+*
+* The run becomes a text node either way: a `~` that never pairs has to
+* survive as the character it is.
+*/
+const handleTilde = (scanner) => {
+	const res = scanDelims(scanner, 126);
+	if (res === void 0) return false;
+	const startpos = scanner.pos;
+	scanner.pos += res.numdelims;
+	const node = scanner.appendText(scanner.subject.slice(startpos, scanner.pos), startpos, scanner.pos);
+	if ((res.canOpen || res.canClose) && (res.numdelims === 1 || res.numdelims === 2)) {
+		const delimiter = {
+			cc: 126,
+			numdelims: res.numdelims,
+			origdelims: res.numdelims,
+			node,
+			previous: scanner.delimiters,
+			next: void 0,
+			canOpen: res.canOpen,
+			canClose: res.canClose
+		};
+		if (delimiter.previous !== void 0) delimiter.previous.next = delimiter;
+		scanner.delimiters = delimiter;
+	}
+	return true;
+};
+/**
+* Pair `opener` with `closer` into a `delete` node — upstream's `insert`.
+*
+* Returns the delimiter the caller's loop continues from, which upstream
+* captures as `closer->next` BEFORE it starts unlinking, so both the matched
+* and the mismatched path resume at the same place.
+*/
+const insertStrikethrough = (scanner, opener, closer) => {
+	const resume = closer.next;
+	const openerNode = opener.node;
+	const closerNode = closer.node;
+	if (openerNode.value.length === closerNode.value.length) {
+		const delims = openerNode.value.length;
+		openerNode.value = "";
+		openerNode.end -= delims;
+		closerNode.value = "";
+		closerNode.start += delims;
+		const strikethrough = makeInlineNode("delete", openerNode.end, closerNode.start);
+		let between = openerNode.next;
+		while (between !== void 0 && between !== closerNode) {
+			const following = between.next;
+			appendChild(strikethrough, between);
+			between = following;
+		}
+		insertAfter(openerNode, strikethrough);
+		unlink(openerNode);
+		unlink(closerNode);
+	}
+	let delimiter = closer;
+	while (delimiter !== void 0 && delimiter !== opener) {
+		const previous = delimiter.previous;
+		scanner.removeDelimiter(delimiter);
+		delimiter = previous;
+	}
+	scanner.removeDelimiter(opener);
+	return resume;
+};
+/** GFM strikethrough: `~foo~` and `~~foo~~`. */
+const strikethroughConstruct = {
+	name: "strikethrough",
+	triggers: [126],
+	parse: (scanner) => handleTilde(scanner)
+};
+
+//#endregion
+export { insertStrikethrough, strikethroughConstruct };

package/internal/inlines/text.js

@@ -0,0 +1,22 @@
+//#region src/internal/inlines/text.ts
+const reMain = /^[^\n`[\]\\!<&*_'"]+/;
+const reMainGfm = /^[^\n`[\]\\!<&*_'"~w:]+/;
+/** Consume a run of ordinary characters, stopping before any construct's. */
+const runConstruct = (name, pattern) => ({
+	name,
+	triggers: [],
+	parse: (scanner) => {
+		const from = scanner.pos;
+		const matched = scanner.match(pattern);
+		if (matched === void 0) return false;
+		scanner.appendText(matched, from, scanner.pos);
+		return true;
+	}
+});
+/** Ordinary text: the fallback construct, with no trigger of its own. */
+const textConstruct = runConstruct("text", reMain);
+/** Ordinary text under `gfm`, which has three more characters to yield to. */
+const gfmTextConstruct = runConstruct("text", reMainGfm);
+
+//#endregion
+export { gfmTextConstruct, textConstruct };

package/internal/lineIndex.js

@@ -0,0 +1,76 @@
+//#region src/internal/lineIndex.ts
+/**
+* A precomputed index of line-start offsets over a fixed source text,
+* answering `positionAt(offset)` in `O(log n)` via binary search rather than
+* rescanning the text per query.
+*
+* @remarks
+* Only `\n` begins a new line. A `\r` immediately before a `\n` (CRLF) is
+* left as the trailing character of the prior line — the pair still reads as
+* a single boundary because the following `\n` is what advances the line
+* counter, not the `\r`. A bare `\r` (old Mac line endings) is not
+* recognized as a break; CommonMark's preprocessing pass normalizes those
+* before this index is ever built.
+*/
+var LineIndex = class LineIndex {
+	text;
+	lineStarts;
+	constructor(text, lineStarts) {
+		this.text = text;
+		this.lineStarts = lineStarts;
+	}
+	/**
+	* Build a {@link LineIndex} over `text` with one forward scan.
+	*
+	* @remarks
+	* Recognizes only `\n`, which is why the block pass hands over its own
+	* line table instead — see {@link LineIndex.fromLineStarts}.
+	*/
+	static make(text) {
+		const lineStarts = [0];
+		for (let i = 0; i < text.length; i++) if (text.charCodeAt(i) === 10) lineStarts.push(i + 1);
+		return new LineIndex(text, lineStarts);
+	}
+	/**
+	* Build a {@link LineIndex} over `text` from a line table someone else
+	* already computed.
+	*
+	* @remarks
+	* The parser splits lines on `\r\n`, `\n` AND a bare `\r`; this index's
+	* own scan recognizes only `\n`. For any document without a bare `\r` the
+	* two agree, but for one with them they disagree about what a line is, and
+	* every reported line number would be wrong. Handing the parser's own
+	* table over removes the possibility rather than documenting it: there is
+	* one definition of a line, and it belongs to the preprocessor.
+	*
+	* `starts` must be ascending and begin at 0; a table that is neither is a
+	* wiring bug and dies as a defect.
+	*/
+	static fromLineStarts(text, starts) {
+		if (starts.length === 0 || starts[0] !== 0) throw new TypeError("line index: a line table must be non-empty and start at offset 0");
+		return new LineIndex(text, starts);
+	}
+	/**
+	* The 1-based `{ line, column }` of `offset` within this index's text.
+	* Out-of-range offsets clamp to the nearest valid position (`0` or
+	* `text.length`) rather than throwing.
+	*/
+	positionAt(offset) {
+		const clamped = Math.min(Math.max(offset, 0), this.text.length);
+		let low = 0;
+		let high = this.lineStarts.length - 1;
+		while (low < high) {
+			const mid = low + high + 1 >> 1;
+			if ((this.lineStarts[mid] ?? 0) <= clamped) low = mid;
+			else high = mid - 1;
+		}
+		const lineStart = this.lineStarts[low] ?? 0;
+		return {
+			line: low + 1,
+			column: clamped - lineStart + 1
+		};
+	}
+};
+
+//#endregion
+export { LineIndex };

package/internal/patterns.js

@@ -0,0 +1,26 @@
+//#region src/internal/patterns.ts
+const stickyCache = /* @__PURE__ */ new WeakMap();
+const globalCache = /* @__PURE__ */ new WeakMap();
+const clone = (pattern, flag, dropCaret) => {
+	const source = dropCaret && pattern.source.startsWith("^") ? pattern.source.slice(1) : pattern.source;
+	return new RegExp(source, `${pattern.flags.replace(/[gy]/g, "")}${flag}`);
+};
+/** The sticky twin of `pattern`, anchored at `lastIndex`. */
+const stickyOf = (pattern) => {
+	const cached = stickyCache.get(pattern);
+	if (cached !== void 0) return cached;
+	const made = clone(pattern, "y", true);
+	stickyCache.set(pattern, made);
+	return made;
+};
+/** The global twin of `pattern`, searching forward from `lastIndex`. */
+const globalOf = (pattern) => {
+	const cached = globalCache.get(pattern);
+	if (cached !== void 0) return cached;
+	const made = clone(pattern, "g", false);
+	globalCache.set(pattern, made);
+	return made;
+};
+
+//#endregion
+export { globalOf, stickyOf };

package/internal/preprocess.js

@@ -0,0 +1,58 @@
+//#region src/internal/preprocess.ts
+/** The tab stop width CommonMark fixes for indentation arithmetic. */
+const TAB_STOP = 4;
+/**
+* Split `text` into lines, preserving each line's absolute start offset.
+*
+* `\r\n`, `\n` and `\r` all terminate a line. U+0000 is replaced with U+FFFD
+* per the spec's security note; the replacement is length-preserving so
+* offsets stay aligned with the original source.
+*
+* A single trailing `\n` does not produce a final empty line (upstream's
+* rule — the document "foo\n" is one line, not two). A trailing bare `\r`
+* does, which is also upstream's behavior: the extra blank line is inert.
+*/
+const preprocessLines = (text) => {
+	const lines = [];
+	let start = 0;
+	let index = 0;
+	while (index < text.length) {
+		const code = text.charCodeAt(index);
+		if (code === 10) {
+			lines.push({
+				text: replaceNul(text.slice(start, index)),
+				start
+			});
+			index += 1;
+			start = index;
+		} else if (code === 13) {
+			lines.push({
+				text: replaceNul(text.slice(start, index)),
+				start
+			});
+			index += text.charCodeAt(index + 1) === 10 ? 2 : 1;
+			start = index;
+		} else index += 1;
+	}
+	if (start < text.length || !text.endsWith("\n")) lines.push({
+		text: replaceNul(text.slice(start)),
+		start
+	});
+	return lines;
+};
+/** The spec's security substitution: U+0000 becomes U+FFFD, 1:1 by length. */
+const replaceNul = (line) => line.includes("\0") ? line.replaceAll("\0", "�") : line;
+/** True for the two characters CommonMark treats as horizontal whitespace. */
+const isSpaceOrTab = (code) => code === 32 || code === 9;
+/** The char code at `position`, or `-1` past the end of `line`. */
+const peekCode = (line, position) => position >= 0 && position < line.length ? line.charCodeAt(position) : -1;
+/**
+* Columns from `column` to the next tab stop — the width a `\t` expands to.
+*
+* `column` is the tab-expanded column the block pass tracks, not a character
+* index: a tab at column 2 is two columns wide, at column 4 it is four.
+*/
+const columnsToNextTabStop = (column) => 4 - column % 4;
+
+//#endregion
+export { columnsToNextTabStop, isSpaceOrTab, peekCode, preprocessLines, replaceNul };

package/internal/rawInline.js

@@ -0,0 +1,57 @@
+import { parseInlines } from "./inlineParser.js";
+
+//#region src/internal/rawInline.ts
+const reWhitespace = /\s/;
+const reCmarkSpace = /[ \t\n\r]/;
+/**
+* Trim `text` the way commonmark.js does before inline parsing, carrying the
+* segment table along so the surviving characters keep their source offsets.
+*/
+const trimWithSegments = (text, segments, whitespace) => {
+	let start = 0;
+	let end = text.length;
+	while (start < end && whitespace.test(text.charAt(start))) start += 1;
+	while (end > start && whitespace.test(text.charAt(end - 1))) end -= 1;
+	if (start === 0 && end === text.length) return {
+		text,
+		segments
+	};
+	const trimmed = [];
+	for (const segment of segments) {
+		const from = Math.max(segment.textOffset, start);
+		const to = Math.min(segment.textOffset + segment.length, end);
+		if (to > from) trimmed.push({
+			textOffset: from - start,
+			sourceOffset: segment.sourceOffset + (from - segment.textOffset),
+			length: to - from
+		});
+	}
+	return {
+		text: text.slice(start, end),
+		segments: trimmed
+	};
+};
+/**
+* Prepare a leaf block's accumulated content and run the inline pass over it:
+* trim it, keep its source provenance, and parse it into phrasing content.
+*/
+const prepareInline = (block, position, refmap, dialect = "commonmark", footnoteLabels = /* @__PURE__ */ new Set()) => {
+	const { text, segments } = trimWithSegments(block.stringContent, block.segments, block.type === "tableCell" ? reCmarkSpace : reWhitespace);
+	const first = segments[0];
+	const last = segments[segments.length - 1];
+	const startOffset = first === void 0 ? block.startOffset : first.sourceOffset;
+	return {
+		text,
+		startOffset,
+		endOffset: last === void 0 ? startOffset : last.sourceOffset + last.length,
+		segments,
+		children: text.length === 0 ? [] : parseInlines({
+			text,
+			startOffset,
+			segments
+		}, refmap, position, dialect, footnoteLabels)
+	};
+};
+
+//#endregion
+export { prepareInline };