@effected/markdown 0.2.0

package/internal/inlines/autolinkLiteral.js

@@ -0,0 +1,374 @@
+import { appendChild, childrenOf, insertAfter, makeInlineNode, unlink } from "../inlineNode.js";
+
+//#region src/internal/inlines/autolinkLiteral.ts
+const C_LOWER_W = 119;
+const C_COLON = 58;
+/** `cmark_isspace`: ASCII only, deliberately — upstream's URL scan uses it. */
+const reAsciiSpace = /^[ \t\n\v\f\r]$/;
+const reAlnum = /^[0-9A-Za-z]$/;
+const reAlpha = /^[A-Za-z]$/;
+const reUnicodeSpace = /^[\t\n\f\r \u00a0\u1680\u2000-\u200a\u202f\u205f\u3000]$/;
+const reAsciiPunctuation = /^[!-/:-@[-`{-~]$/;
+const reUnicodePunctuation = /^\p{P}$/u;
+/** The schemes `sd_autolink_issafe` whitelists, in its order. */
+const SAFE_SCHEMES = [
+	"http://",
+	"https://",
+	"ftp://"
+];
+/** Whether the code point at `index` may appear in a host name. */
+const isValidHostChar = (subject, index) => {
+	const code = subject.codePointAt(index);
+	if (code === void 0) return false;
+	const char = String.fromCodePoint(code);
+	if (reUnicodeSpace.test(char)) return false;
+	return !(code < 128 ? reAsciiPunctuation.test(char) : reUnicodePunctuation.test(char));
+};
+/**
+* `autolink_delim`: pull the link's end back off trailing punctuation.
+*
+* Two rules beyond "drop the trailing mark". Parens are BALANCED rather than
+* simply stripped, so `www.a.com/q_(bar)` keeps its group while `(www.a.com/q)`
+* gives its closer back to the surrounding text. And a trailing `;` is
+* examined for an entity reference: `…&hl;` cuts at the `&`, because the
+* writer will re-escape that run and the link must not swallow it.
+*/
+const autolinkDelim = (subject, base, end) => {
+	let linkEnd = end;
+	let opening = 0;
+	let closing = 0;
+	for (let index = 0; index < linkEnd; index += 1) {
+		const char = subject.charAt(base + index);
+		if (char === "<") {
+			linkEnd = index;
+			break;
+		}
+		if (char === "(") opening += 1;
+		else if (char === ")") closing += 1;
+	}
+	while (linkEnd > 0) {
+		const char = subject.charAt(base + linkEnd - 1);
+		if (char === ")") {
+			if (closing <= opening) return linkEnd;
+			closing -= 1;
+			linkEnd -= 1;
+			continue;
+		}
+		if ("?!.,:*_~'\"".includes(char)) {
+			linkEnd -= 1;
+			continue;
+		}
+		if (char === ";") {
+			if (linkEnd < 2) {
+				linkEnd -= 1;
+				continue;
+			}
+			let newEnd = linkEnd - 2;
+			while (newEnd > 0 && reAlpha.test(subject.charAt(base + newEnd))) newEnd -= 1;
+			if (newEnd < linkEnd - 2 && subject.charAt(base + newEnd) === "&") linkEnd = newEnd;
+			else linkEnd -= 1;
+			continue;
+		}
+		return linkEnd;
+	}
+	return linkEnd;
+};
+/**
+* `check_domain`: how much of `subject` from `base` is a plausible domain.
+*
+* The underscore rule is the interesting one and it is a HOST-name rule, not
+* a domain-name rule: an `_` in either of the last two dot-separated segments
+* disqualifies the whole match (`www.xxx._yyy.zzz` is literal text), while one
+* further left is fine (`www._xxx.yyy.zzz` links). The `np > 10` escape hatch
+* is upstream's fix for GHSA-29g3-96g3-jg6c — a very long segmented run stops
+* being re-examined rather than going quadratic.
+*/
+const checkDomain = (subject, base, size, allowShort) => {
+	let index = 1;
+	let dots = 0;
+	let underscoresPenultimate = 0;
+	let underscoresLast = 0;
+	for (; index < size - 1; index += 1) {
+		if (subject.charAt(base + index) === "\\" && index < size - 2) index += 1;
+		const char = subject.charAt(base + index);
+		if (char === "_") underscoresLast += 1;
+		else if (char === ".") {
+			underscoresPenultimate = underscoresLast;
+			underscoresLast = 0;
+			dots += 1;
+		} else if (!isValidHostChar(subject, base + index) && char !== "-") break;
+	}
+	if ((underscoresPenultimate > 0 || underscoresLast > 0) && dots <= 10) return 0;
+	if (allowShort) return index;
+	return dots > 0 ? index : 0;
+};
+/** `sd_autolink_issafe`: does the run at `start` open with a whitelisted scheme. */
+const isSafeScheme = (subject, start, length) => SAFE_SCHEMES.some((scheme) => length > scheme.length && subject.slice(start, start + scheme.length).toLowerCase() === scheme && isValidHostChar(subject, start + scheme.length));
+/** Extend a matched prefix to the next space or `<`, as both matchers do. */
+const extendToBoundary = (subject, base, from, size) => {
+	let linkEnd = from;
+	while (linkEnd < size) {
+		const char = subject.charAt(base + linkEnd);
+		if (reAsciiSpace.test(char) || char === "<") break;
+		linkEnd += 1;
+	}
+	return linkEnd;
+};
+/** Append a literal-autolink `link` node spanning `[start, end)`. */
+const appendLiteralLink = (scanner, start, end, url) => {
+	const text = scanner.subject.slice(start, end);
+	const node = makeInlineNode("link", start, end);
+	node.data.url = url;
+	appendChild(node, makeInlineNode("text", start, end, text));
+	scanner.append(node);
+	scanner.pos = end;
+};
+/**
+* `www_match`: a `www.` host with no scheme, which links to `http://` + itself.
+*
+* The preceding character is the gate — start of line, whitespace, or one of
+* `*`, `_`, `~`, `(` — which is what keeps `xwww.a.com` from linking.
+*/
+const wwwAutolinkConstruct = {
+	name: "wwwAutolink",
+	triggers: [C_LOWER_W],
+	parse: (scanner) => {
+		if (scanner.brackets !== void 0) return false;
+		const start = scanner.pos;
+		if (start > 0) {
+			const before = scanner.subject.charAt(start - 1);
+			if (!"*_~(".includes(before) && !reAsciiSpace.test(before)) return false;
+		}
+		const size = scanner.subject.length - start;
+		if (size < 4 || scanner.subject.slice(start, start + 4) !== "www.") return false;
+		const domain = checkDomain(scanner.subject, start, size, false);
+		if (domain === 0) return false;
+		const linkEnd = autolinkDelim(scanner.subject, start, extendToBoundary(scanner.subject, start, domain, size));
+		if (linkEnd === 0) return false;
+		appendLiteralLink(scanner, start, start + linkEnd, `http://${scanner.subject.slice(start, start + linkEnd)}`);
+		return true;
+	}
+};
+/**
+* `url_match`: a bare `http://`, `https://` or `ftp://` URL.
+*
+* The trigger is the `:`, so the scheme itself is already behind the cursor
+* and already emitted as text. Upstream calls `cmark_node_unput` to take it
+* back; `scanner.unputText` is that, and its refusal is a real bail-out —
+* when the scheme's characters did not come from plain text nodes (a decoded
+* entity, say) the run is not the source text it appears to be and no link
+* forms.
+*/
+const urlAutolinkConstruct = {
+	name: "urlAutolink",
+	triggers: [C_COLON],
+	parse: (scanner) => {
+		if (scanner.brackets !== void 0) return false;
+		const colon = scanner.pos;
+		const { subject } = scanner;
+		const size = subject.length - colon;
+		if (size < 4 || subject.charAt(colon + 1) !== "/" || subject.charAt(colon + 2) !== "/") return false;
+		let rewind = 0;
+		while (rewind < colon && reAlpha.test(subject.charAt(colon - rewind - 1))) rewind += 1;
+		if (!isSafeScheme(subject, colon - rewind, size + rewind)) return false;
+		const domain = checkDomain(subject, colon + 3, size - 3, true);
+		if (domain === 0) return false;
+		const linkEnd = autolinkDelim(subject, colon, extendToBoundary(subject, colon, 3 + domain, size));
+		if (linkEnd === 0) return false;
+		if (!scanner.unputText(rewind)) return false;
+		const start = colon - rewind;
+		const end = colon + linkEnd;
+		appendLiteralLink(scanner, start, end, subject.slice(start, end));
+		return true;
+	}
+};
+/**
+* `validate_protocol`: is `protocol` the run immediately left of the address,
+* and is it itself preceded by a non-alphanumeric?
+*
+* The second half is why `mmmmailto:foo@bar.baz` links only `foo@bar.baz`.
+*/
+const validateProtocol = (protocol, data, at, rewind, maxRewind) => {
+	const length = protocol.length;
+	if (length > maxRewind - rewind) return false;
+	if (data.slice(at - rewind - length, at - rewind) !== protocol) return false;
+	if (length === maxRewind - rewind) return true;
+	return !reAlnum.test(data.charAt(at - rewind - length - 1));
+};
+/**
+* `postprocess_text`: every email address in one merged run of text.
+*
+* The shape is upstream's, `goto found_at` included — when the forward scan
+* runs into a SECOND `@` the candidate is re-anchored on it rather than
+* abandoned, which is what makes `a@b@c.d` link `b@c.d`. Neither `auto_mailto`
+* nor `np` is reset on that re-entry, because upstream's `goto` jumps past
+* their initializers.
+*/
+const scanEmails = (data) => {
+	const matches = [];
+	let start = 0;
+	let offset = 0;
+	let remaining = data.length;
+	while (offset < remaining) {
+		const at = data.indexOf("@", start + offset);
+		if (at === -1) break;
+		let maxRewind = at - (start + offset);
+		let autoMailto = true;
+		let isXmpp = false;
+		let rewind = 0;
+		let linkEnd = 1;
+		let dots = 0;
+		let reanchored = true;
+		let abandoned = false;
+		while (reanchored) {
+			reanchored = false;
+			for (rewind = 0; rewind < maxRewind; rewind += 1) {
+				const char = data.charAt(start + offset + maxRewind - rewind - 1);
+				if (reAlnum.test(char) || ".+-_".includes(char)) continue;
+				if (char === ":") {
+					if (validateProtocol("mailto:", data, start + offset + maxRewind, rewind, maxRewind)) {
+						autoMailto = false;
+						continue;
+					}
+					if (validateProtocol("xmpp:", data, start + offset + maxRewind, rewind, maxRewind)) {
+						autoMailto = false;
+						isXmpp = true;
+						continue;
+					}
+				}
+				break;
+			}
+			if (rewind === 0) {
+				offset += maxRewind + 1;
+				abandoned = true;
+				break;
+			}
+			const bound = remaining - offset - maxRewind;
+			for (linkEnd = 1; linkEnd < bound; linkEnd += 1) {
+				const char = data.charAt(start + offset + maxRewind + linkEnd);
+				if (reAlnum.test(char)) continue;
+				if (char === "@") {
+					offset += maxRewind + 1;
+					maxRewind = linkEnd - 1;
+					reanchored = true;
+					break;
+				}
+				if (char === "." && linkEnd < bound - 1 && reAlnum.test(data.charAt(start + offset + maxRewind + linkEnd + 1))) {
+					dots += 1;
+					continue;
+				}
+				if (char === "/" && isXmpp) continue;
+				if (char !== "-" && char !== "_") break;
+			}
+		}
+		if (abandoned) continue;
+		const last = data.charAt(start + offset + maxRewind + linkEnd - 1);
+		if (linkEnd < 2 || dots === 0 || !reAlpha.test(last) && last !== ".") {
+			offset += maxRewind + linkEnd;
+			continue;
+		}
+		linkEnd = autolinkDelim(data, start + offset + maxRewind, linkEnd);
+		if (linkEnd === 0) {
+			offset += maxRewind + 1;
+			continue;
+		}
+		const from = start + offset + maxRewind - rewind;
+		const to = start + offset + maxRewind + linkEnd;
+		const text = data.slice(from, to);
+		matches.push({
+			from,
+			to,
+			url: autoMailto ? `mailto:${text}` : text
+		});
+		start += offset + maxRewind + linkEnd;
+		remaining -= offset + maxRewind + linkEnd;
+		offset = 0;
+	}
+	return matches;
+};
+/** Replace a run of adjacent text nodes with the same text plus its email links. */
+const linkifyRun = (pieces) => {
+	const merged = pieces.map((piece) => piece.node.value).join("");
+	const matches = scanEmails(merged);
+	if (matches.length === 0) return;
+	/**
+	* The local content index a merged-run index came from.
+	*
+	* Exact whenever the contributing node's value is its source characters,
+	* which is every node the text fallback produced. A node whose value was
+	* DECODED — an entity, a backslash escape — is shorter than the source it
+	* spans, so an index inside it clamps to that node's own range rather than
+	* running past its end. An email address holds neither, so this is a
+	* bound, not a rounding.
+	*/
+	const localAt = (index) => {
+		for (const piece of pieces) {
+			const within = index - piece.valueStart;
+			if (within <= piece.node.value.length) return piece.node.start + Math.min(within, piece.node.end - piece.node.start);
+		}
+		const last = pieces[pieces.length - 1];
+		return last === void 0 ? 0 : last.node.end;
+	};
+	const replacements = [];
+	let cursor = 0;
+	const pushText = (from, to) => {
+		if (to <= from) return;
+		replacements.push(makeInlineNode("text", localAt(from), localAt(to), merged.slice(from, to)));
+	};
+	for (const match of matches) {
+		pushText(cursor, match.from);
+		const start = localAt(match.from);
+		const end = localAt(match.to);
+		const link = makeInlineNode("link", start, end);
+		link.data.url = match.url;
+		appendChild(link, makeInlineNode("text", start, end, merged.slice(match.from, match.to)));
+		replacements.push(link);
+		cursor = match.to;
+	}
+	pushText(cursor, merged.length);
+	const lastPiece = pieces[pieces.length - 1];
+	if (lastPiece === void 0) return;
+	let tail = lastPiece.node;
+	for (const replacement of replacements) {
+		insertAfter(tail, replacement);
+		tail = replacement;
+	}
+	for (const piece of pieces) unlink(piece.node);
+};
+/**
+* Turn every bare email address in the finished list into a link.
+*
+* Iterative on purpose: this walks the tree emphasis and strikethrough just
+* built, whose depth the input controls, and the parser's depth cap does not
+* apply until materialization. A tree walk has no reason to recurse.
+*/
+const linkifyEmails = (root) => {
+	const pending = [root];
+	while (pending.length > 0) {
+		const container = pending.pop();
+		if (container === void 0) break;
+		let pieces = [];
+		let valueLength = 0;
+		const flush = () => {
+			if (pieces.length > 0) linkifyRun(pieces);
+			pieces = [];
+			valueLength = 0;
+		};
+		for (const child of childrenOf(container)) {
+			if (child.type === "text") {
+				pieces.push({
+					node: child,
+					valueStart: valueLength
+				});
+				valueLength += child.value.length;
+				continue;
+			}
+			flush();
+			if (child.type !== "link" && child.type !== "linkReference") pending.push(child);
+		}
+		flush();
+	}
+};
+
+//#endregion
+export { linkifyEmails, urlAutolinkConstruct, wwwAutolinkConstruct };

package/internal/inlines/codeSpan.js

@@ -0,0 +1,32 @@
+import { makeInlineNode } from "../inlineNode.js";
+
+//#region src/internal/inlines/codeSpan.ts
+const C_BACKTICK = 96;
+const reTicksHere = /^`+/;
+const reNewline = /\n/gm;
+const reNonSpace = /[^ ]/;
+/** A code span. */
+const codeSpanConstruct = {
+	name: "codeSpan",
+	triggers: [C_BACKTICK],
+	parse: (scanner) => {
+		const from = scanner.pos;
+		const ticks = scanner.match(reTicksHere);
+		if (ticks === void 0) return false;
+		const afterOpenTicks = scanner.pos;
+		const closing = scanner.closingBacktickRun(afterOpenTicks, ticks.length);
+		if (closing !== void 0) {
+			const contents = scanner.subject.slice(afterOpenTicks, closing).replace(reNewline, " ");
+			const stripped = contents.length > 0 && reNonSpace.test(contents) && contents.startsWith(" ") && contents.endsWith(" ") ? contents.slice(1, -1) : contents;
+			scanner.pos = closing + ticks.length;
+			scanner.append(makeInlineNode("inlineCode", from, scanner.pos, stripped));
+			return true;
+		}
+		scanner.pos = afterOpenTicks;
+		scanner.appendText(ticks, from, scanner.pos);
+		return true;
+	}
+};
+
+//#endregion
+export { codeSpanConstruct };

package/internal/inlines/emphasis.js

@@ -0,0 +1,79 @@
+//#region src/internal/inlines/emphasis.ts
+const C_ASTERISK = 42;
+const C_UNDERSCORE = 95;
+const rePunctuation = /^[!"#$%&'()*+,\-./:;<=>?@[\]\\^_`{|}~\p{P}\p{S}]/u;
+const reUnicodeWhitespaceChar = /^\s/;
+/**
+* Measure the delimiter run at the cursor and decide whether it can open or
+* close emphasis, per the spec's left- and right-flanking rules. Leaves the
+* cursor where it found it.
+*
+* The `_` arm is the only character-specific rule here, so `~` (which follows
+* `*`'s rules) reuses this as it stands.
+*/
+const scanDelims = (scanner, cc) => {
+	const startpos = scanner.pos;
+	let numdelims = 0;
+	while (scanner.peek() === cc) {
+		numdelims += 1;
+		scanner.pos += 1;
+	}
+	if (numdelims === 0) {
+		scanner.pos = startpos;
+		return;
+	}
+	const charBefore = startpos === 0 ? "\n" : scanner.subject.charAt(startpos - 1);
+	const ccAfter = scanner.peek();
+	const charAfter = ccAfter === -1 ? "\n" : String.fromCodePoint(ccAfter);
+	const afterIsWhitespace = reUnicodeWhitespaceChar.test(charAfter);
+	const afterIsPunctuation = rePunctuation.test(charAfter);
+	const beforeIsWhitespace = reUnicodeWhitespaceChar.test(charBefore);
+	const beforeIsPunctuation = rePunctuation.test(charBefore);
+	const leftFlanking = !afterIsWhitespace && (!afterIsPunctuation || beforeIsWhitespace || beforeIsPunctuation);
+	const rightFlanking = !beforeIsWhitespace && (!beforeIsPunctuation || afterIsWhitespace || afterIsPunctuation);
+	const canOpen = cc === C_UNDERSCORE ? leftFlanking && (!rightFlanking || beforeIsPunctuation) : leftFlanking;
+	const canClose = cc === C_UNDERSCORE ? rightFlanking && (!leftFlanking || afterIsPunctuation) : rightFlanking;
+	scanner.pos = startpos;
+	return {
+		numdelims,
+		canOpen,
+		canClose
+	};
+};
+const markerCharOf = (cc) => cc === C_UNDERSCORE ? "_" : "*";
+/**
+* Consume a delimiter run as literal text and, when it could open or close
+* emphasis, push it onto the delimiter stack for `processEmphasis` to pair up.
+*/
+const handleDelim = (scanner, cc) => {
+	const res = scanDelims(scanner, cc);
+	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);
+	node.data.markerChar = markerCharOf(cc);
+	if (res.canOpen || res.canClose) {
+		const delimiter = {
+			cc,
+			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;
+};
+/** Emphasis and strong emphasis: `*` and `_` runs. */
+const emphasisConstruct = {
+	name: "emphasis",
+	triggers: [C_ASTERISK, C_UNDERSCORE],
+	parse: (scanner) => handleDelim(scanner, scanner.peek())
+};
+
+//#endregion
+export { emphasisConstruct, scanDelims };

package/internal/inlines/entity.js

@@ -0,0 +1,21 @@
+import { decodeEntity } from "../entities.js";
+import { ENTITY } from "../unescape.js";
+
+//#region src/internal/inlines/entity.ts
+const C_AMPERSAND = 38;
+const reEntityHere = new RegExp(`^${ENTITY}`, "i");
+/** A named, decimal or hexadecimal character reference. */
+const entityConstruct = {
+	name: "entity",
+	triggers: [C_AMPERSAND],
+	parse: (scanner) => {
+		const from = scanner.pos;
+		const matched = scanner.match(reEntityHere);
+		if (matched === void 0) return false;
+		scanner.appendText(decodeEntity(matched) ?? matched, from, scanner.pos);
+		return true;
+	}
+};
+
+//#endregion
+export { entityConstruct };

package/internal/inlines/escape.js

@@ -0,0 +1,34 @@
+import { ESCAPABLE } from "../unescape.js";
+import { makeInlineNode } from "../inlineNode.js";
+
+//#region src/internal/inlines/escape.ts
+const C_BACKSLASH = 92;
+const C_NEWLINE = 10;
+const reEscapable = new RegExp(`^${ESCAPABLE}`);
+/** A backslash escape, or a backslash hard line break. */
+const escapeConstruct = {
+	name: "escape",
+	triggers: [C_BACKSLASH],
+	parse: (scanner) => {
+		const from = scanner.pos;
+		scanner.pos += 1;
+		if (scanner.peek() === C_NEWLINE) {
+			scanner.pos += 1;
+			const node = makeInlineNode("break", from, scanner.pos);
+			node.data.breakStyle = "backslash";
+			scanner.append(node);
+			return true;
+		}
+		const escaped = scanner.subject.charAt(scanner.pos);
+		if (reEscapable.test(escaped)) {
+			scanner.pos += 1;
+			scanner.appendText(escaped, from, scanner.pos);
+			return true;
+		}
+		scanner.appendText("\\", from, scanner.pos);
+		return true;
+	}
+};
+
+//#endregion
+export { escapeConstruct };

package/internal/inlines/footnoteReference.js

@@ -0,0 +1,63 @@
+import { normalizeLabelText } from "../references.js";
+import { insertAfter, makeInlineNode, unlink } from "../inlineNode.js";
+import { makeImageOpenConstruct, makeLinkCloseConstruct } from "./link.js";
+
+//#region src/internal/inlines/footnoteReference.ts
+const C_CARET = 94;
+/**
+* Whether the bracket that just closed looks like `[^...]` with something
+* between the caret and the `]`.
+*
+* Upstream tests the node list — the node after the opener must be TEXT whose
+* literal starts with `^`, and there must be more content than that caret
+* alone (`literal->len > 1 || opener->inl_text->next->next`). Read off the
+* subject the two tests are the same: `^` triggers no construct, so it always
+* lands in a text node, and "more content" is precisely "the `]` is not the
+* next character".
+*/
+const looksLikeFootnote = (subject, openerIndex, bracketPos) => subject.charCodeAt(openerIndex + 1) === C_CARET && bracketPos > openerIndex + 2;
+/**
+* cmark-gfm's footnote branch: form a reference, or leave the whole span as
+* the literal text upstream's post-pass would have rewritten it to.
+*/
+const footnoteReferenceFallback = (scanner, opener, bracketPos, afterBracket) => {
+	if (!looksLikeFootnote(scanner.subject, opener.index, bracketPos)) return false;
+	scanner.pos = afterBracket;
+	const rawLabel = scanner.subject.slice(opener.index + 2, bracketPos);
+	const key = normalizeLabelText(rawLabel);
+	const matched = key !== "" && scanner.footnoteLabels.has(key);
+	scanner.processEmphasis(opener.previousDelimiter);
+	const start = opener.node.start;
+	const node = matched ? makeInlineNode("footnoteReference", start, scanner.pos) : makeInlineNode("text", start, scanner.pos, `[^${rawLabel}]`);
+	if (matched) {
+		node.data.identifier = key.toLowerCase();
+		node.data.label = rawLabel;
+	}
+	insertAfter(opener.node, node);
+	let child = node.next;
+	while (child !== void 0) {
+		const following = child.next;
+		unlink(child);
+		child = following;
+	}
+	scanner.removeBracket();
+	unlink(opener.node);
+	return true;
+};
+/**
+* The `]` construct for the `gfm` dialect: CommonMark's, with the footnote
+* branch wired into its no-match seam.
+*/
+const gfmLinkCloseConstruct = makeLinkCloseConstruct(footnoteReferenceFallback);
+/**
+* The `!` construct for the `gfm` dialect: CommonMark's, refusing to open an
+* image on `![^` so the caret can reach the footnote branch.
+*
+* `makeImageOpenConstruct` carries the reason; it is a footnote rule living on
+* the bang, which is why it is re-exported from here rather than left to look
+* like a link concern.
+*/
+const gfmImageOpenConstruct = makeImageOpenConstruct(false);
+
+//#endregion
+export { footnoteReferenceFallback, gfmImageOpenConstruct, gfmLinkCloseConstruct };

package/internal/inlines/lineBreak.js

@@ -0,0 +1,25 @@
+import { makeInlineNode } from "../inlineNode.js";
+
+//#region src/internal/inlines/lineBreak.ts
+const C_NEWLINE = 10;
+const reInitialSpace = /^ */;
+/** A soft or hard line break. */
+const lineBreakConstruct = {
+	name: "lineBreak",
+	triggers: [C_NEWLINE],
+	parse: (scanner) => {
+		const from = scanner.pos;
+		scanner.pos += 1;
+		const trailingSpaces = scanner.trimTrailingSpaces();
+		if (trailingSpaces >= 2) {
+			const node = makeInlineNode("break", from - trailingSpaces, scanner.pos);
+			node.data.breakStyle = "spaces";
+			scanner.append(node);
+		} else scanner.appendText("\n", from, scanner.pos);
+		scanner.match(reInitialSpace);
+		return true;
+	}
+};
+
+//#endregion
+export { lineBreakConstruct };