@effected/markdown 0.2.0

package/internal/references.js

@@ -0,0 +1,160 @@
+import { unescapeString } from "./unescape.js";
+import { stickyOf } from "./patterns.js";
+
+//#region src/internal/references.ts
+const ESCAPABLE = "[!\"#$%&'()*+,./:;<=>?@[\\\\\\]^_`{|}~-]";
+const ESCAPED_CHAR = `\\\\${ESCAPABLE}`;
+const reLinkTitle = new RegExp(`^(?:"(${ESCAPED_CHAR}|\\\\[^\\\\]|[^\\\\"\\x00])*"|'(${ESCAPED_CHAR}|\\\\[^\\\\]|[^\\\\'\\x00])*'|\\((${ESCAPED_CHAR}|\\\\[^\\\\]|[^\\\\()\\x00])*\\))`);
+const reLinkDestinationBraces = /^(?:<(?:[^<>\n\\\0]|\\.)*>)/;
+const reEscapable = new RegExp(`^${ESCAPABLE}`);
+const reSpnl = /^ *(?:\n *)?/;
+const reSpaceAtEndOfLine = /^ *(?:\n|$)/;
+const reLinkLabel = /^\[(?:[^\\[\]]|\\.){0,1000}\]/s;
+/**
+* The whitespace set a link destination may not contain, as codes.
+*
+* The destination walk below tests every character it passes. Upstream spells
+* that test `reWhitespaceChar.exec(fromCodePoint(c))`, which allocates a
+* string and runs a regex per character — in a scan that is already O(n) per
+* attempt on an unterminated destination, that constant is the difference
+* between seconds and minutes.
+*/
+const isWhitespaceCode = (code) => code === 32 || code === 9 || code === 10 || code === 11 || code === 12 || code === 13;
+const C_BACKSLASH = 92;
+const C_COLON = 58;
+const C_LESSTHAN = 60;
+const C_OPEN_PAREN = 40;
+const C_CLOSE_PAREN = 41;
+/**
+* A cursor over a subject string, with the handful of primitives upstream's
+* inline parser is built from.
+*/
+var ReferenceScanner = class {
+	subject;
+	pos = 0;
+	constructor(subject) {
+		this.subject = subject;
+	}
+	/** The char code at the cursor, or `-1` at the end of the subject. */
+	peek() {
+		return this.pos < this.subject.length ? this.subject.charCodeAt(this.pos) : -1;
+	}
+	/**
+	* Match `pattern` at the cursor, advancing past it on success.
+	*
+	* Sticky rather than upstream's slice-then-match: every pattern here is
+	* anchored, and slicing the subject per attempt is quadratic on a large
+	* one (`patterns.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];
+	}
+	/** Consume optional spaces and up to one line ending. */
+	spnl() {
+		this.match(reSpnl);
+	}
+	/** The length of the link label at the cursor, or `0` if there is none. */
+	parseLinkLabel() {
+		const found = this.match(reLinkLabel);
+		return found === void 0 || found.length > 1001 ? 0 : found.length;
+	}
+	/**
+	* The link destination at the cursor, unescaped, or `undefined` if there
+	* is none. Never percent-encoded (see the port notes).
+	*/
+	parseLinkDestination() {
+		const braced = this.match(reLinkDestinationBraces);
+		if (braced !== void 0) return unescapeString(braced.slice(1, -1));
+		if (this.peek() === C_LESSTHAN) return;
+		const start = this.pos;
+		let openParens = 0;
+		let code = this.peek();
+		while (code !== -1) {
+			if (code === C_BACKSLASH && reEscapable.test(this.subject.charAt(this.pos + 1))) {
+				this.pos += 1;
+				if (this.peek() !== -1) this.pos += 1;
+			} else if (code === C_OPEN_PAREN) {
+				this.pos += 1;
+				openParens += 1;
+			} else if (code === C_CLOSE_PAREN) {
+				if (openParens < 1) break;
+				this.pos += 1;
+				openParens -= 1;
+			} else if (isWhitespaceCode(code)) break;
+			else this.pos += 1;
+			code = this.peek();
+		}
+		if (this.pos === start && code !== C_CLOSE_PAREN) return;
+		if (openParens !== 0) return;
+		return unescapeString(this.subject.slice(start, this.pos));
+	}
+	/** The link title at the cursor, quotes stripped and unescaped. */
+	parseLinkTitle() {
+		const title = this.match(reLinkTitle);
+		return title === void 0 ? void 0 : unescapeString(title.slice(1, -1));
+	}
+};
+/**
+* Case-fold a bare label: trim, collapse internal whitespace, fold case.
+*
+* The `toLowerCase().toUpperCase()` pair is upstream's Unicode case-folding
+* trick, not redundancy — it is what makes `ẞ` and `ß` the same label.
+*
+* Split out of {@link normalizeReference} because GFM footnote labels are the
+* same fold applied to a label that never carried brackets to strip: this is
+* cmark-gfm's `normalize_map_label`, which its footnote map and its link
+* refmap both call.
+*/
+const normalizeLabelText = (label) => label.trim().replace(/[ \t\r\n]+/g, " ").toLowerCase().toUpperCase();
+/**
+* commonmark.js `normalizeReference`: strip the brackets, then case-fold what
+* is left.
+*/
+const normalizeReference = (rawLabel) => normalizeLabelText(rawLabel.slice(1, rawLabel.length - 1));
+/**
+* Parse a link reference definition at the start of `text`.
+*
+* Returns `undefined` when `text` does not begin with one — which is not an
+* error: the text is simply paragraph content.
+*/
+const parseReference = (text) => {
+	const scanner = new ReferenceScanner(text);
+	const labelLength = scanner.parseLinkLabel();
+	if (labelLength === 0) return;
+	const rawLabel = text.slice(0, labelLength);
+	if (scanner.peek() !== C_COLON) return;
+	scanner.pos += 1;
+	scanner.spnl();
+	const url = scanner.parseLinkDestination();
+	if (url === void 0) return;
+	const beforeTitle = scanner.pos;
+	scanner.spnl();
+	let title = scanner.pos === beforeTitle ? void 0 : scanner.parseLinkTitle();
+	if (title === void 0) scanner.pos = beforeTitle;
+	let atLineEnd = true;
+	if (scanner.match(reSpaceAtEndOfLine) === void 0) if (title === void 0) atLineEnd = false;
+	else {
+		title = void 0;
+		scanner.pos = beforeTitle;
+		atLineEnd = scanner.match(reSpaceAtEndOfLine) !== void 0;
+	}
+	if (!atLineEnd) return;
+	const key = normalizeReference(rawLabel);
+	if (key === "") return;
+	return {
+		key,
+		identifier: key.toLowerCase(),
+		label: rawLabel.slice(1, -1),
+		url,
+		...title === void 0 ? {} : { title },
+		length: scanner.pos
+	};
+};
+
+//#endregion
+export { ReferenceScanner, normalizeLabelText, normalizeReference, parseReference };

package/internal/segments.js

@@ -0,0 +1,36 @@
+//#region src/internal/segments.ts
+/**
+* The absolute source offset of `textIndex` within a segmented content run.
+*
+* An index that falls between segments resolves to the end of the segment
+* before it, which is the closest real source position there is.
+*/
+const sourceOffsetAt = (segments, textIndex, fallback) => {
+	let offset = fallback;
+	for (const segment of segments) {
+		if (textIndex < segment.textOffset) return offset;
+		if (textIndex < segment.textOffset + segment.length) return segment.sourceOffset + (textIndex - segment.textOffset);
+		offset = segment.sourceOffset + segment.length;
+	}
+	return offset;
+};
+/**
+* Cut `[from, to)` out of a segmented content run, keeping the provenance of
+* every character that survives.
+*/
+const sliceWithSegments = (segments, from, to) => {
+	const sliced = [];
+	for (const segment of segments) {
+		const start = Math.max(segment.textOffset, from);
+		const end = Math.min(segment.textOffset + segment.length, to);
+		if (end > start) sliced.push({
+			textOffset: start - from,
+			sourceOffset: segment.sourceOffset + (start - segment.textOffset),
+			length: end - start
+		});
+	}
+	return sliced;
+};
+
+//#endregion
+export { sliceWithSegments, sourceOffsetAt };