@effected/markdown 0.2.0

package/internal/inlineParser.js

@@ -0,0 +1,403 @@
+import { Break, Delete, Emphasis, FootnoteReference, Html, Image, ImageReference, InlineCode, Link, LinkReference, Strong, Text } from "../MarkdownNode.js";
+import { globalOf, stickyOf } from "./patterns.js";
+import { sourceOffsetAt } from "./segments.js";
+import { GuardExceeded } from "./carriers.js";
+import { appendChild, childrenOf, insertAfter, makeInlineNode, unlink } from "./inlineNode.js";
+import { insertStrikethrough } from "./inlines/strikethrough.js";
+import { inlineDialect } from "./inlineRegistry.js";
+
+//#region src/internal/inlineParser.ts
+const C_UNDERSCORE = 95;
+const C_ASTERISK = 42;
+const reTrailingSpaces = / +$/;
+const C_BACKTICK = 96;
+/**
+* Every backtick run in `subject`, as start offsets grouped by run length.
+*
+* One forward scan, so a code span's search for its closing run is a binary
+* search rather than a walk over every run in between.
+*/
+const indexBacktickRuns = (subject) => {
+	const runs = /* @__PURE__ */ new Map();
+	let index = 0;
+	while (index < subject.length) {
+		if (subject.charCodeAt(index) !== C_BACKTICK) {
+			index += 1;
+			continue;
+		}
+		const start = index;
+		while (index < subject.length && subject.charCodeAt(index) === C_BACKTICK) index += 1;
+		const length = index - start;
+		const starts = runs.get(length);
+		if (starts === void 0) runs.set(length, [start]);
+		else starts.push(start);
+	}
+	return runs;
+};
+var InlineParser = class {
+	subject;
+	pos = 0;
+	refmap;
+	footnoteLabels;
+	delimiters;
+	brackets;
+	/** How many link openers on the stack are still active (see `deactivateLinkOpeners`). */
+	activeLinkOpeners = 0;
+	/** Per-needle memo of the offset from which it no longer occurs. */
+	absentAfter = /* @__PURE__ */ new Map();
+	/** Backtick run starts, by run length; built on first use. */
+	backtickRuns;
+	source;
+	dialect;
+	positionOf;
+	/** The output list's root; only ever a container for the children. */
+	root;
+	constructor(source, dialect, positionOf, refmap, footnoteLabels) {
+		this.source = source;
+		this.subject = source.text;
+		this.dialect = dialect;
+		this.positionOf = positionOf;
+		this.refmap = refmap;
+		this.footnoteLabels = footnoteLabels;
+		this.root = makeInlineNode("text", 0, source.text.length);
+	}
+	peek() {
+		return this.pos < this.subject.length ? this.subject.charCodeAt(this.pos) : -1;
+	}
+	/**
+	* Match `pattern` AT the cursor, advancing past it on success.
+	*
+	* A match that starts later is not a match: every construct here asks
+	* "does this begin at the cursor". Upstream adds `m.index` to its position
+	* instead, which is safe only because its dispatch guarantees index zero —
+	* a guarantee the trigger table does not make (see `inlines/text.ts`).
+	*/
+	match(pattern) {
+		const sticky = stickyOf(pattern);
+		sticky.lastIndex = this.pos;
+		const found = sticky.exec(this.subject);
+		if (found === null) return;
+		this.pos = sticky.lastIndex;
+		return found[0];
+	}
+	matchAhead(pattern) {
+		const forward = globalOf(pattern);
+		forward.lastIndex = this.pos;
+		const found = forward.exec(this.subject);
+		if (found === null) return;
+		this.pos = found.index + found[0].length;
+		return found[0];
+	}
+	hasAhead(needle) {
+		const known = this.absentAfter.get(needle);
+		if (known !== void 0 && this.pos >= known) return false;
+		if (this.subject.indexOf(needle, this.pos) !== -1) return true;
+		this.absentAfter.set(needle, Math.min(known ?? this.pos, this.pos));
+		return false;
+	}
+	closingBacktickRun(from, length) {
+		if (this.backtickRuns === void 0) this.backtickRuns = indexBacktickRuns(this.subject);
+		const starts = this.backtickRuns.get(length);
+		if (starts === void 0) return;
+		let low = 0;
+		let high = starts.length;
+		while (low < high) {
+			const mid = low + high >> 1;
+			if ((starts[mid] ?? 0) < from) low = mid + 1;
+			else high = mid;
+		}
+		return starts[low];
+	}
+	append(node) {
+		appendChild(this.root, node);
+	}
+	appendText(value, from, to) {
+		const node = makeInlineNode("text", from, to, value);
+		appendChild(this.root, node);
+		return node;
+	}
+	lastChild() {
+		return this.root.lastChild;
+	}
+	unputText(count) {
+		if (count === 0) return true;
+		let available = 0;
+		for (let node = this.root.lastChild; node !== void 0 && available < count; node = node.prev) {
+			if (node.type !== "text") break;
+			available += node.value.length;
+		}
+		if (available < count) return false;
+		let remaining = count;
+		while (remaining > 0) {
+			const last = this.root.lastChild;
+			if (last === void 0) return false;
+			if (last.value.length > remaining) {
+				last.value = last.value.slice(0, last.value.length - remaining);
+				last.end -= remaining;
+				return true;
+			}
+			remaining -= last.value.length;
+			unlink(last);
+		}
+		return true;
+	}
+	trimTrailingSpaces() {
+		const last = this.root.lastChild;
+		if (last === void 0 || last.type !== "text") return 0;
+		const trimmed = last.value.replace(reTrailingSpaces, "");
+		const removed = last.value.length - trimmed.length;
+		if (removed === 0) return 0;
+		if (trimmed.length === 0) {
+			unlink(last);
+			return removed;
+		}
+		last.value = trimmed;
+		last.end = Math.max(last.end - removed, last.start);
+		return removed;
+	}
+	removeDelimiter(delimiter) {
+		if (delimiter.previous !== void 0) delimiter.previous.next = delimiter.next;
+		if (delimiter.next === void 0) this.delimiters = delimiter.previous;
+		else delimiter.next.previous = delimiter.previous;
+	}
+	removeDelimitersBetween(bottom, top) {
+		if (bottom.next !== top) {
+			bottom.next = top;
+			top.previous = bottom;
+		}
+	}
+	addBracket(node, index, image) {
+		if (this.brackets !== void 0) this.brackets.bracketAfter = true;
+		this.brackets = {
+			node,
+			previous: this.brackets,
+			previousDelimiter: this.delimiters,
+			index,
+			image,
+			active: true
+		};
+		if (!image) this.activeLinkOpeners += 1;
+	}
+	removeBracket() {
+		const popped = this.brackets;
+		if (popped !== void 0 && !popped.image && popped.active) this.activeLinkOpeners -= 1;
+		this.brackets = popped?.previous;
+	}
+	deactivateLinkOpeners() {
+		if (this.activeLinkOpeners === 0) return;
+		for (let opener = this.brackets; opener !== void 0; opener = opener.previous) if (!opener.image && opener.active) {
+			opener.active = false;
+			this.activeLinkOpeners -= 1;
+		}
+	}
+	/**
+	* Pair up the delimiter stack above `stackBottom` into emphasis and strong
+	* nodes — upstream's `processEmphasis`, including the two rules that make
+	* the algorithm terminate in linear time: `openers_bottom`, which records
+	* how far back a failed search already looked, and the multiple-of-three
+	* rule for runs that can both open and close.
+	*/
+	processEmphasis(stackBottom) {
+		const openersBottom = new Array(20).fill(stackBottom);
+		let closer = this.delimiters;
+		while (closer !== void 0 && closer.previous !== stackBottom) closer = closer.previous;
+		while (closer !== void 0) {
+			if (!closer.canClose) {
+				closer = closer.next;
+				continue;
+			}
+			const closercc = closer.cc;
+			const openersBottomIndex = (closercc === C_UNDERSCORE ? 2 : closercc === 126 ? 14 : 8) + (closer.canOpen ? 3 : 0) + closer.origdelims % 3;
+			let opener = closer.previous;
+			let openerFound = false;
+			while (opener !== void 0 && opener !== stackBottom && opener !== openersBottom[openersBottomIndex]) {
+				const oddMatch = (closer.canOpen || opener.canClose) && closer.origdelims % 3 !== 0 && (opener.origdelims + closer.origdelims) % 3 === 0;
+				if (opener.cc === closer.cc && opener.canOpen && !oddMatch) {
+					openerFound = true;
+					break;
+				}
+				opener = opener.previous;
+			}
+			const oldCloser = closer;
+			if (closercc === C_ASTERISK || closercc === C_UNDERSCORE) if (!openerFound || opener === void 0) closer = closer.next;
+			else {
+				const useDelims = closer.numdelims >= 2 && opener.numdelims >= 2 ? 2 : 1;
+				const openerNode = opener.node;
+				const closerNode = closer.node;
+				opener.numdelims -= useDelims;
+				closer.numdelims -= useDelims;
+				openerNode.value = openerNode.value.slice(0, openerNode.value.length - useDelims);
+				openerNode.end -= useDelims;
+				closerNode.value = closerNode.value.slice(0, closerNode.value.length - useDelims);
+				closerNode.start += useDelims;
+				const emphasis = makeInlineNode(useDelims === 1 ? "emphasis" : "strong", openerNode.end, closerNode.start);
+				emphasis.data.markerChar = closercc === C_UNDERSCORE ? "_" : "*";
+				let between = openerNode.next;
+				while (between !== void 0 && between !== closerNode) {
+					const following = between.next;
+					appendChild(emphasis, between);
+					between = following;
+				}
+				insertAfter(openerNode, emphasis);
+				this.removeDelimitersBetween(opener, closer);
+				if (opener.numdelims === 0) {
+					unlink(openerNode);
+					this.removeDelimiter(opener);
+				}
+				if (closer.numdelims === 0) {
+					unlink(closerNode);
+					const next = closer.next;
+					this.removeDelimiter(closer);
+					closer = next;
+				}
+			}
+			else if (closercc === 126) closer = !openerFound || opener === void 0 ? closer.next : insertStrikethrough(this, opener, closer);
+			else closer = closer.next;
+			if (!openerFound) {
+				openersBottom[openersBottomIndex] = oldCloser.previous;
+				if (!oldCloser.canOpen) this.removeDelimiter(oldCloser);
+			}
+		}
+		while (this.delimiters !== void 0 && this.delimiters !== stackBottom) this.removeDelimiter(this.delimiters);
+	}
+	offsetAt(index) {
+		return sourceOffsetAt(this.source.segments, index, this.source.startOffset);
+	}
+	position(from, to) {
+		const start = this.offsetAt(from);
+		const end = to > from ? this.offsetAt(to - 1) + 1 : this.offsetAt(to);
+		return this.positionOf(start, Math.max(end, start));
+	}
+	/**
+	* Turn the mutable list into mdast nodes, coalescing adjacent text runs.
+	*
+	* Depth is emphasis nesting, which the input controls, so the same cap the
+	* block pass applies to containers applies here.
+	*/
+	materialize(parent, depth) {
+		if (depth > 256) throw new GuardExceeded("NestingDepthExceeded", 256, depth, this.offsetAt(parent.start));
+		const children = [];
+		let pendingText;
+		const flushText = () => {
+			if (pendingText === void 0) return;
+			if (pendingText.value.length > 0) children.push(Text.make({
+				value: pendingText.value,
+				position: this.position(pendingText.start, pendingText.end)
+			}));
+			pendingText = void 0;
+		};
+		for (const node of childrenOf(parent)) {
+			if (node.type === "text") {
+				if (pendingText === void 0) pendingText = makeInlineNode("text", node.start, node.end, node.value);
+				else {
+					pendingText.value += node.value;
+					pendingText.end = node.end;
+				}
+				continue;
+			}
+			flushText();
+			const built = this.materializeNode(node, depth);
+			if (built !== void 0) children.push(built);
+		}
+		flushText();
+		return children;
+	}
+	materializeNode(node, depth) {
+		const position = this.position(node.start, node.end);
+		const { url, title, identifier, label, referenceType, markerChar, breakStyle } = node.data;
+		switch (node.type) {
+			case "inlineCode": return InlineCode.make({
+				value: node.value,
+				position
+			});
+			case "html": return Html.make({
+				value: node.value,
+				position
+			});
+			case "break": return Break.make({
+				position,
+				...breakStyle === void 0 ? {} : { breakStyle }
+			});
+			case "emphasis": return Emphasis.make({
+				children: this.materialize(node, depth + 1),
+				position,
+				...markerChar === void 0 ? {} : { markerChar }
+			});
+			case "delete": return Delete.make({
+				children: this.materialize(node, depth + 1),
+				position
+			});
+			case "strong": return Strong.make({
+				children: this.materialize(node, depth + 1),
+				position,
+				...markerChar === void 0 ? {} : { markerChar }
+			});
+			case "link": return Link.make({
+				url: url ?? "",
+				children: this.materialize(node, depth + 1),
+				position,
+				...title === void 0 ? {} : { title }
+			});
+			case "image": return Image.make({
+				url: url ?? "",
+				position,
+				...title === void 0 ? {} : { title },
+				...node.value === "" ? {} : { alt: node.value }
+			});
+			case "linkReference": return LinkReference.make({
+				identifier: identifier ?? "",
+				referenceType: referenceType ?? "shortcut",
+				children: this.materialize(node, depth + 1),
+				position,
+				...label === void 0 ? {} : { label }
+			});
+			case "footnoteReference": return FootnoteReference.make({
+				identifier: identifier ?? "",
+				position,
+				...label === void 0 ? {} : { label }
+			});
+			case "imageReference": return ImageReference.make({
+				identifier: identifier ?? "",
+				referenceType: referenceType ?? "shortcut",
+				position,
+				...label === void 0 ? {} : { label },
+				...node.value === "" ? {} : { alt: node.value }
+			});
+			default: return;
+		}
+	}
+	/**
+	* One construct at the cursor. Upstream's `parseInline`: try the
+	* constructs this character triggers, then ordinary text, and failing both
+	* take the character literally.
+	*/
+	parseOne() {
+		const code = this.peek();
+		if (code === -1) return false;
+		for (const construct of this.dialect.byTrigger.get(code) ?? []) if (construct.parse(this)) return true;
+		if (this.dialect.text.parse(this)) return true;
+		const from = this.pos;
+		this.pos += 1;
+		this.appendText(String.fromCodePoint(code), from, this.pos);
+		return true;
+	}
+	parse() {
+		while (this.parseOne());
+		this.processEmphasis(void 0);
+		for (const pass of this.dialect.postprocess) pass(this.root);
+		return this.materialize(this.root, 0);
+	}
+};
+/**
+* Parse a leaf block's raw text into phrasing content.
+*
+* A reference only forms when `refmap` holds its normalized label — a
+* dangling `[foo]` is literal text, per the spec — and when one does form it
+* is emitted as a `linkReference` carrying the identifier rather than an
+* eagerly resolved link. `position` comes from the block pass, which owns the
+* line index.
+*/
+const parseInlines = (source, refmap, position, dialect = "commonmark", footnoteLabels = /* @__PURE__ */ new Set()) => new InlineParser(source, inlineDialect(dialect), position, refmap, footnoteLabels).parse();
+
+//#endregion
+export { parseInlines };

package/internal/inlineRegistry.js

@@ -0,0 +1,68 @@
+import { autolinkConstruct } from "./inlines/autolink.js";
+import { linkifyEmails, urlAutolinkConstruct, wwwAutolinkConstruct } from "./inlines/autolinkLiteral.js";
+import { codeSpanConstruct } from "./inlines/codeSpan.js";
+import { emphasisConstruct } from "./inlines/emphasis.js";
+import { entityConstruct } from "./inlines/entity.js";
+import { escapeConstruct } from "./inlines/escape.js";
+import { imageOpenConstruct, linkCloseConstruct, linkOpenConstruct } from "./inlines/link.js";
+import { gfmImageOpenConstruct, gfmLinkCloseConstruct } from "./inlines/footnoteReference.js";
+import { lineBreakConstruct } from "./inlines/lineBreak.js";
+import { rawHtmlConstruct } from "./inlines/rawHtml.js";
+import { strikethroughConstruct } from "./inlines/strikethrough.js";
+import { gfmTextConstruct, textConstruct } from "./inlines/text.js";
+
+//#region src/internal/inlineRegistry.ts
+const triggerTable = (constructs) => {
+	const table = /* @__PURE__ */ new Map();
+	for (const construct of constructs) for (const trigger of construct.triggers) {
+		const bucket = table.get(trigger);
+		if (bucket === void 0) table.set(trigger, [construct]);
+		else bucket.push(construct);
+	}
+	return table;
+};
+/** The CommonMark construct set, which every dialect starts from. */
+const COMMONMARK_CONSTRUCTS = [
+	lineBreakConstruct,
+	escapeConstruct,
+	codeSpanConstruct,
+	emphasisConstruct,
+	linkOpenConstruct,
+	imageOpenConstruct,
+	linkCloseConstruct,
+	autolinkConstruct,
+	rawHtmlConstruct,
+	entityConstruct
+];
+const commonmarkDialect = {
+	byTrigger: triggerTable(COMMONMARK_CONSTRUCTS),
+	text: textConstruct,
+	postprocess: []
+};
+const gfmDialect = {
+	byTrigger: triggerTable([
+		...COMMONMARK_CONSTRUCTS.filter((construct) => construct !== linkCloseConstruct && construct !== imageOpenConstruct),
+		gfmLinkCloseConstruct,
+		gfmImageOpenConstruct,
+		strikethroughConstruct,
+		wwwAutolinkConstruct,
+		urlAutolinkConstruct
+	]),
+	text: gfmTextConstruct,
+	postprocess: [linkifyEmails]
+};
+const dialects = /* @__PURE__ */ new Map([["commonmark", commonmarkDialect], ["gfm", gfmDialect]]);
+/**
+* The inline 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 inlineDialect = (dialect) => {
+	const found = dialects.get(dialect);
+	if (found === void 0) throw new TypeError(`unknown markdown dialect: ${String(dialect)}`);
+	return found;
+};
+
+//#endregion
+export { inlineDialect };

package/internal/inlines/autolink.js

@@ -0,0 +1,36 @@
+import { appendChild, makeInlineNode } from "../inlineNode.js";
+
+//#region src/internal/inlines/autolink.ts
+const C_LESSTHAN = 60;
+const reEmailAutolink = /^<([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/;
+const reAutolink = /^<[A-Za-z][A-Za-z0-9.+-]{1,31}:[^<>\0- ]*>/i;
+/** An absolute-URI or email autolink. */
+const autolinkConstruct = {
+	name: "autolink",
+	triggers: [C_LESSTHAN],
+	parse: (scanner) => {
+		const from = scanner.pos;
+		const email = scanner.match(reEmailAutolink);
+		if (email !== void 0) {
+			const destination = email.slice(1, -1);
+			const node = makeInlineNode("link", from, scanner.pos);
+			node.data.url = `mailto:${destination}`;
+			appendChild(node, makeInlineNode("text", from + 1, scanner.pos - 1, destination));
+			scanner.append(node);
+			return true;
+		}
+		const uri = scanner.match(reAutolink);
+		if (uri !== void 0) {
+			const destination = uri.slice(1, -1);
+			const node = makeInlineNode("link", from, scanner.pos);
+			node.data.url = destination;
+			appendChild(node, makeInlineNode("text", from + 1, scanner.pos - 1, destination));
+			scanner.append(node);
+			return true;
+		}
+		return false;
+	}
+};
+
+//#endregion
+export { autolinkConstruct };