@localix-ai/flowdown 0.0.0-stage → 0.5.0

package/dist/engine/inlines.js

@@ -0,0 +1,852 @@
+import { ENTITY, decodeEntity, isEscapable, normalizeUri, unescapeString } from "./entities.js";
+// src/engine/inlines.ts
+/**
+* The inline pass: the text of one block read into emphasis, links, code spans and the rest, by
+* the algorithm in the CommonMark spec (a delimiter stack for emphasis, a bracket stack for
+* links). One pass over the text; the parser's state lives in the module, since a block's text
+* is read from start to end before the next one begins.
+*/
+const C_NEWLINE = 10;
+const C_SPACE = 32;
+const C_BANG = 33;
+const C_AMPERSAND = 38;
+const C_OPEN_PAREN = 40;
+const C_CLOSE_PAREN = 41;
+const C_ASTERISK = 42;
+const C_COLON = 58;
+const C_LESSTHAN = 60;
+const C_OPEN_BRACKET = 91;
+const C_BACKSLASH = 92;
+const C_CLOSE_BRACKET = 93;
+const C_CARET = 94;
+const C_UNDERSCORE = 95;
+const C_BACKTICK = 96;
+const C_TILDE = 126;
+const TAGNAME = "[A-Za-z][A-Za-z0-9-]*";
+const OPENTAG = `<${TAGNAME}(?:\\s+[a-zA-Z_:][a-zA-Z0-9:._-]*(?:\\s*=\\s*(?:[^"'=<>\`\\x00-\\x20]+|'[^']*'|"[^"]*"))?)*\\s*/?>`;
+const CLOSETAG = `</${TAGNAME}\\s*[>]`;
+const HTMLTAG = `(?:${OPENTAG}|${CLOSETAG}|<!-->|<!--->|<!--[\\s\\S]*?-->|[<][?][\\s\\S]*?[?][>]|<![A-Za-z]+[^>]*>|<!\\[CDATA\\[[\\s\\S]*?\\]\\]>)`;
+const reHtmlTag = new RegExp(HTMLTAG, "y");
+const reEntity = new RegExp(ENTITY, "iy");
+const reAutolink = /<([A-Za-z][A-Za-z0-9.+-]{1,31}:[^<>\x00-\x20]*)>/y;
+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])?)*)>/y;
+const reLinkLabel = /\[(?:[^\\[\]]|\\[\s\S]){0,1000}\]/y;
+const reLinkDestinationBraces = /<(?:[^<>\n\\\x00]|\\.)*>/y;
+const reLinkTitle = /"(?:\\[\s\S]|[^"\\])*"|'(?:\\[\s\S]|[^'\\])*'|\((?:\\[\s\S]|[^()\\])*\)/y;
+const reSpaceAtEndOfLine = /[ \t]*(?:\n|$)/y;
+const reFootnoteReference = /\[\^([^\]\s]+)\]/y;
+const reUnicodeSpace = /\p{Zs}/u;
+const reUnicodePunctuation = /[\p{P}\p{S}]/u;
+/** Bare addresses: a URL with a scheme, one that starts `www.`, or an email address. */
+const reBareLink = /(?:(?:https?|ftp):\/\/|www\.)[^\s<]*|(mailto:|xmpp:)?[A-Za-z0-9._+-]+@[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)+(\/[A-Za-z0-9@.]+)?/g;
+/** Whether the text may hold a bare address: three searches for a few characters, no regex. */
+const mayHoldBareLink = (text) => text.indexOf("@") !== -1 || text.indexOf("://") !== -1 || text.indexOf("www.") !== -1;
+let subject = "";
+let pos = 0;
+let end = 0;
+let ctx;
+let root;
+let delimiters = null;
+let brackets = null;
+/** Whether the text may hold a bare address (`www.`, `://`, `@`) to turn into a link. */
+let bareLinks = false;
+/** Lengths of backtick runs known to have no closing run in the rest of the text. */
+let noBacktickCloser = null;
+const inl = (type, value = "") => ({
+	type,
+	value,
+	parent: null,
+	prev: null,
+	next: null,
+	first: null,
+	last: null,
+	url: "",
+	title: "",
+	node: null
+});
+const append = (parent, child) => {
+	child.parent = parent;
+	child.prev = parent.last;
+	child.next = null;
+	if (parent.last) parent.last.next = child;
+	else parent.first = child;
+	parent.last = child;
+};
+const unlink = (node) => {
+	if (node.prev) node.prev.next = node.next;
+	else if (node.parent) node.parent.first = node.next;
+	if (node.next) node.next.prev = node.prev;
+	else if (node.parent) node.parent.last = node.prev;
+	node.parent = node.prev = node.next = null;
+};
+const insertAfter = (node, sibling) => {
+	sibling.parent = node.parent;
+	sibling.prev = node;
+	sibling.next = node.next;
+	if (node.next) node.next.prev = sibling;
+	else if (node.parent) node.parent.last = sibling;
+	node.next = sibling;
+};
+const text = (value) => {
+	const node = inl("text", value);
+	append(root, node);
+	return node;
+};
+/** Runs a sticky expression at the current place; the match, with the place moved past it. */
+const match = (re) => {
+	re.lastIndex = pos;
+	const found = re.exec(subject);
+	if (found === null) return null;
+	pos = re.lastIndex;
+	return found[0];
+};
+/** Skips spaces, tabs and at most one line ending. */
+const spnl = () => {
+	let code = subject.charCodeAt(pos);
+	while (code === C_SPACE || code === 9) code = subject.charCodeAt(++pos);
+	if (code === C_NEWLINE) {
+		code = subject.charCodeAt(++pos);
+		while (code === C_SPACE || code === 9) code = subject.charCodeAt(++pos);
+	}
+};
+const isWhitespace = (code) => code === 32 || code === 10 || code === 9 || code === 13 || code === 12 || code >= 128 && reUnicodeSpace.test(String.fromCodePoint(code));
+const isPunctuation = (code) => code < 128 ? isEscapable(code) : reUnicodePunctuation.test(String.fromCodePoint(code));
+const parseNewline = () => {
+	pos++;
+	const last = root.last;
+	if (last !== null && last.type === "text" && last.value.charCodeAt(last.value.length - 1) === 32) {
+		const hard = last.value.charCodeAt(last.value.length - 2) === 32;
+		last.value = last.value.replace(/ +$/, "");
+		append(root, inl(hard ? "break" : "softbreak"));
+	} else append(root, inl("softbreak"));
+	while (subject.charCodeAt(pos) === C_SPACE) pos++;
+};
+const parseBackslash = () => {
+	pos++;
+	const code = subject.charCodeAt(pos);
+	if (code === C_NEWLINE) {
+		pos++;
+		append(root, inl("break"));
+		while (subject.charCodeAt(pos) === C_SPACE) pos++;
+	} else if (isEscapable(code)) {
+		text(subject.charAt(pos));
+		pos++;
+	} else text("\\");
+};
+const parseBackticks = () => {
+	const start = pos;
+	while (subject.charCodeAt(pos) === C_BACKTICK) pos++;
+	const length = pos - start;
+	const after = pos;
+	if (noBacktickCloser === null || !noBacktickCloser.has(length)) {
+		let from = after;
+		for (;;) {
+			const open = subject.indexOf("`", from);
+			if (open === -1) break;
+			let close = open + 1;
+			while (subject.charCodeAt(close) === C_BACKTICK) close++;
+			if (close - open === length) {
+				let content = subject.slice(after, open);
+				if (content.indexOf("\n") !== -1) content = content.replace(/\n/g, " ");
+				if (content.charCodeAt(0) === 32 && content.charCodeAt(content.length - 1) === 32 && /[^ ]/.test(content)) content = content.slice(1, -1);
+				append(root, inl("inlineCode", content));
+				pos = close;
+				return;
+			}
+			from = close;
+		}
+		(noBacktickCloser ??= /* @__PURE__ */ new Set()).add(length);
+	}
+	pos = after;
+	text(subject.slice(start, after));
+};
+const parseDelimiters = (cc) => {
+	const start = pos;
+	while (subject.charCodeAt(pos) === cc) pos++;
+	const num = pos - start;
+	if (cc === C_TILDE && num > 2) {
+		text(subject.slice(start, pos));
+		return;
+	}
+	let before = C_NEWLINE;
+	if (start > 0) {
+		before = subject.charCodeAt(start - 1);
+		if (before >= 56320 && before <= 57343 && start > 1) before = subject.codePointAt(start - 2) ?? before;
+	}
+	const after = pos < end ? subject.codePointAt(pos) ?? C_NEWLINE : C_NEWLINE;
+	const afterIsWhitespace = isWhitespace(after);
+	const afterIsPunctuation = isPunctuation(after);
+	const beforeIsWhitespace = isWhitespace(before);
+	const beforeIsPunctuation = isPunctuation(before);
+	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;
+	const node = text(subject.slice(start, pos));
+	if (!canOpen && !canClose) return;
+	const delimiter = {
+		cc,
+		num,
+		orig: num,
+		node,
+		prev: delimiters,
+		next: null,
+		canOpen,
+		canClose
+	};
+	if (delimiters !== null) delimiters.next = delimiter;
+	delimiters = delimiter;
+};
+const removeDelimiter = (delimiter) => {
+	if (delimiter.prev !== null) delimiter.prev.next = delimiter.next;
+	if (delimiter.next === null) delimiters = delimiter.prev;
+	else delimiter.next.prev = delimiter.prev;
+};
+/** Turns matching delimiter runs above `bottom` into emphasis, strong and strikethrough. */
+const processEmphasis = (bottom) => {
+	const bottoms = [
+		bottom,
+		bottom,
+		bottom,
+		bottom,
+		bottom,
+		bottom,
+		bottom,
+		bottom,
+		bottom,
+		bottom,
+		bottom,
+		bottom,
+		bottom,
+		bottom
+	];
+	let closer = delimiters;
+	while (closer !== null && closer.prev !== bottom) closer = closer.prev;
+	while (closer !== null) {
+		if (!closer.canClose) {
+			closer = closer.next;
+			continue;
+		}
+		const cc = closer.cc;
+		const key = cc === C_TILDE ? 11 + closer.orig : (cc === C_UNDERSCORE ? 0 : 6) + (closer.canOpen ? 3 : 0) + closer.orig % 3;
+		let opener = closer.prev;
+		let found = false;
+		while (opener !== null && opener !== bottom && opener !== bottoms[key]) {
+			if (opener.cc === cc && opener.canOpen) {
+				if (cc === C_TILDE) found = opener.orig === closer.orig;
+				else found = !((closer.canOpen || opener.canClose) && closer.orig % 3 !== 0 && (opener.orig + closer.orig) % 3 === 0);
+				if (found) break;
+			}
+			opener = opener.prev;
+		}
+		const old = closer;
+		if (found && opener !== null) {
+			const use = cc === C_TILDE ? closer.num : closer.num >= 2 && opener.num >= 2 ? 2 : 1;
+			opener.num -= use;
+			closer.num -= use;
+			opener.node.value = opener.node.value.slice(use);
+			closer.node.value = closer.node.value.slice(use);
+			const wrapper = inl(cc === C_TILDE ? "delete" : use === 1 ? "emphasis" : "strong");
+			let between = opener.node.next;
+			while (between !== null && between !== closer.node) {
+				const next = between.next;
+				unlink(between);
+				append(wrapper, between);
+				between = next;
+			}
+			insertAfter(opener.node, wrapper);
+			if (opener.next !== closer) {
+				opener.next = closer;
+				closer.prev = opener;
+			}
+			if (opener.num === 0) {
+				unlink(opener.node);
+				removeDelimiter(opener);
+			}
+			if (closer.num === 0) {
+				unlink(closer.node);
+				const next = closer.next;
+				removeDelimiter(closer);
+				closer = next;
+			}
+		} else {
+			closer = old.next;
+			bottoms[key] = old.prev;
+			if (!old.canOpen) removeDelimiter(old);
+		}
+	}
+	while (delimiters !== null && delimiters !== bottom) removeDelimiter(delimiters);
+};
+const addBracket = (node, index, image) => {
+	if (brackets !== null) brackets.bracketAfter = true;
+	brackets = {
+		node,
+		prev: brackets,
+		prevDelimiter: delimiters,
+		index,
+		image,
+		active: true,
+		bracketAfter: false
+	};
+};
+/** A link destination at the current place, or null. */
+const parseLinkDestination = () => {
+	const braced = match(reLinkDestinationBraces);
+	if (braced !== null) return normalizeUri(unescapeString(braced.slice(1, -1)));
+	if (subject.charCodeAt(pos) === C_LESSTHAN) return null;
+	const start = pos;
+	let depth = 0;
+	let code = 0;
+	while (pos < end) {
+		code = subject.charCodeAt(pos);
+		if (code === C_BACKSLASH && isEscapable(subject.charCodeAt(pos + 1))) pos += 2;
+		else if (code === C_OPEN_PAREN) {
+			pos++;
+			depth++;
+		} else if (code === C_CLOSE_PAREN) {
+			if (depth < 1) break;
+			pos++;
+			depth--;
+		} else if (code <= 32 || code === 127) break;
+		else pos++;
+	}
+	if (pos === start && code !== C_CLOSE_PAREN) return null;
+	if (depth !== 0) return null;
+	return normalizeUri(unescapeString(subject.slice(start, pos)));
+};
+const parseLinkTitle = () => {
+	const title = match(reLinkTitle);
+	return title === null ? null : unescapeString(title.slice(1, -1));
+};
+/** The length of a link label (`[…]`) at the current place, with the place moved past it; or 0. */
+const parseLinkLabel = () => {
+	const label = match(reLinkLabel);
+	return label === null || label.length > 1001 ? 0 : label.length;
+};
+/** A reference label as it is matched: without case, with its whitespace collapsed. */
+const normalizeLabel = (label) => label.slice(1, -1).trim().replace(/[ \t\r\n]+/g, " ").toLowerCase().toUpperCase();
+const parseCloseBracket = () => {
+	const start = pos;
+	pos++;
+	const opener = brackets;
+	if (opener === null) {
+		text("]");
+		return;
+	}
+	if (!opener.active) {
+		text("]");
+		brackets = opener.prev;
+		return;
+	}
+	const image = opener.image;
+	const savepos = pos;
+	let url = "";
+	let title = "";
+	let matched = false;
+	if (subject.charCodeAt(pos) === C_OPEN_PAREN) {
+		pos++;
+		spnl();
+		const destination = parseLinkDestination();
+		if (destination !== null) {
+			const beforeTitle = pos;
+			spnl();
+			let found = null;
+			if (pos !== beforeTitle) found = parseLinkTitle();
+			spnl();
+			if (subject.charCodeAt(pos) === C_CLOSE_PAREN) {
+				pos++;
+				url = destination;
+				title = found ?? "";
+				matched = true;
+			}
+		}
+		if (!matched) pos = savepos;
+	}
+	if (!matched) {
+		const beforeLabel = pos;
+		const length = parseLinkLabel();
+		let label = "";
+		if (length > 2) label = subject.slice(beforeLabel, beforeLabel + length);
+		else if (!opener.bracketAfter) label = subject.slice(opener.index, start + 1);
+		if (length === 0) pos = savepos;
+		if (label !== "") {
+			const reference = ctx.refs.get(normalizeLabel(label));
+			if (reference !== void 0) {
+				url = reference.url;
+				title = reference.title;
+				matched = true;
+			}
+		}
+	}
+	if (!matched) {
+		brackets = opener.prev;
+		pos = start + 1;
+		text("]");
+		return;
+	}
+	const node = inl(image ? "image" : "link");
+	node.url = url;
+	node.title = title;
+	let inside = opener.node.next;
+	while (inside !== null) {
+		const next = inside.next;
+		unlink(inside);
+		append(node, inside);
+		inside = next;
+	}
+	append(root, node);
+	processEmphasis(opener.prevDelimiter);
+	brackets = opener.prev;
+	unlink(opener.node);
+	if (!image) {
+		for (let bracket = brackets; bracket !== null; bracket = bracket.prev) if (!bracket.image) bracket.active = false;
+	}
+};
+const parseOpenBracket = () => {
+	if (ctx.footnotes.size > 0 && subject.charCodeAt(pos + 1) === C_CARET) {
+		reFootnoteReference.lastIndex = pos;
+		const found = reFootnoteReference.exec(subject);
+		const key = found === null ? "" : normalizeLabel(`[${found[1]}]`);
+		const label = ctx.footnotes.get(key);
+		if (label !== void 0) {
+			const uses = (ctx.footnoteUses.get(key) ?? 0) + 1;
+			ctx.footnoteUses.set(key, uses);
+			let index = 0;
+			for (const used of ctx.footnoteUses.keys()) {
+				index++;
+				if (used === key) break;
+			}
+			state.push({
+				type: "footnoteReference",
+				identifier: key.toLowerCase(),
+				label,
+				index,
+				occurrence: uses
+			});
+			pos = reFootnoteReference.lastIndex;
+			return;
+		}
+	}
+	const start = pos;
+	pos++;
+	addBracket(text("["), start, false);
+};
+const parseBang = () => {
+	const start = pos;
+	pos++;
+	if (subject.charCodeAt(pos) === C_OPEN_BRACKET && !(ctx.footnotes.size > 0 && subject.charCodeAt(pos + 1) === C_CARET)) {
+		pos++;
+		addBracket(text("!["), start + 1, true);
+	} else text("!");
+};
+const parseLessThan = () => {
+	reEmailAutolink.lastIndex = pos;
+	let found = reEmailAutolink.exec(subject);
+	if (found !== null) {
+		const address = found[1] ?? "";
+		const node = inl("link");
+		node.url = normalizeUri(`mailto:${address}`);
+		append(node, inl("text", address));
+		append(root, node);
+		pos = reEmailAutolink.lastIndex;
+		return;
+	}
+	reAutolink.lastIndex = pos;
+	found = reAutolink.exec(subject);
+	if (found !== null) {
+		const address = found[1] ?? "";
+		const node = inl("link");
+		node.url = normalizeUri(address);
+		append(node, inl("text", address));
+		append(root, node);
+		pos = reAutolink.lastIndex;
+		return;
+	}
+	const tag = match(reHtmlTag);
+	if (tag !== null) append(root, inl("html", tag));
+	else {
+		pos++;
+		text("<");
+	}
+};
+const parseEntity = () => {
+	reEntity.lastIndex = pos;
+	const found = reEntity.exec(subject);
+	const decoded = found === null ? null : decodeEntity(found[0]);
+	if (decoded === null) {
+		pos++;
+		text("&");
+	} else {
+		pos = reEntity.lastIndex;
+		text(decoded);
+	}
+};
+const isAlphanumeric = (code) => code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122;
+/** Where a bare URL ends, by GitHub's rules for what trails a link without being part of it. */
+const trimBareLink = (link) => {
+	let length = link.length;
+	for (;;) {
+		const last = link.charCodeAt(length - 1);
+		if ("?!.,:*_~'\"".indexOf(link.charAt(length - 1)) !== -1 && length > 0) length--;
+		else if (last === C_CLOSE_PAREN) {
+			let balance = 0;
+			for (let index = 0; index < length; index++) {
+				const code = link.charCodeAt(index);
+				if (code === C_OPEN_PAREN) balance++;
+				else if (code === C_CLOSE_PAREN) balance--;
+			}
+			if (balance >= 0) break;
+			length--;
+		} else if (last === 59) {
+			let start = length - 2;
+			while (start >= 0 && isAlphanumeric(link.charCodeAt(start))) start--;
+			if (start >= 0 && start < length - 2 && link.charCodeAt(start) === C_AMPERSAND) length = start;
+			else length--;
+		} else break;
+	}
+	return link.slice(0, length);
+};
+/** The bare addresses in a run of text, in order. */
+const findBareLinks = (run) => {
+	const found = [];
+	reBareLink.lastIndex = 0;
+	for (let hit = reBareLink.exec(run); hit !== null; hit = reBareLink.exec(run)) {
+		let start = hit.index;
+		let link = hit[0];
+		const first = link.charCodeAt(0);
+		if (link.indexOf("@") !== -1 && !/^(?:https?:|ftp:|www\.)/.test(link)) {
+			let scheme = hit[1] ?? "";
+			if (scheme !== "" && start > 0 && isAlphanumeric(run.charCodeAt(start - 1))) {
+				start += scheme.length;
+				link = link.slice(scheme.length);
+				scheme = "";
+			}
+			if (hit[2] !== void 0 && scheme !== "xmpp:") link = link.slice(0, -hit[2].length);
+			while (link.charCodeAt(link.length - 1) === 46) link = link.slice(0, -1);
+			if (!isAlphanumeric(link.charCodeAt(link.length - 1))) {
+				reBareLink.lastIndex = start + link.length;
+				continue;
+			}
+			found.push({
+				start,
+				end: start + link.length,
+				url: scheme === "" ? `mailto:${link}` : link
+			});
+			reBareLink.lastIndex = start + link.length;
+			continue;
+		}
+		const www = first === 119;
+		if (start > 0) {
+			const before = run.charCodeAt(start - 1);
+			if (www ? !isWhitespace(before) && before !== C_ASTERISK && before !== C_UNDERSCORE && before !== C_TILDE && before !== C_OPEN_PAREN : before >= 65 && before <= 90 || before >= 97 && before <= 122 || before === 60) continue;
+		}
+		const host = www ? 0 : link.indexOf("://") + 3;
+		let hostEnd = host;
+		while (hostEnd < link.length) {
+			const code = link.charCodeAt(hostEnd);
+			if (code < 128 && !isAlphanumeric(code) && code !== 45 && code !== 46 && code !== C_UNDERSCORE) break;
+			hostEnd++;
+		}
+		const segments = link.slice(host, hostEnd).split(".");
+		if (hostEnd === host || www && (segments.length < 2 || link.length < 5)) continue;
+		if (segments.slice(-2).some((segment) => segment.indexOf("_") !== -1)) continue;
+		link = trimBareLink(link);
+		if (link.length <= host) continue;
+		found.push({
+			start,
+			end: start + link.length,
+			url: www ? `http://${link}` : link
+		});
+		reBareLink.lastIndex = start + link.length;
+	}
+	return found;
+};
+/** The plain text of a run of nodes: what an image's `alt` holds. */
+const plainText = (nodes) => {
+	let out = "";
+	for (const node of nodes) if (node.type === "image") out += node.alt ?? "";
+	else if (node.children) out += plainText(node.children);
+	else if (node.type === "break") out += "\n";
+	else out += node.value ?? "";
+	return out;
+};
+/** A run of finished nodes with the bare addresses in its text made into links. */
+const linkify = (nodes) => {
+	let out = null;
+	for (let index = 0; index < nodes.length; index++) {
+		const node = nodes[index];
+		const value = node.type === "text" ? node.value ?? "" : "";
+		const found = value !== "" && mayHoldBareLink(value) ? findBareLinks(value) : null;
+		if (found === null || found.length === 0) {
+			if (out !== null) out.push(node);
+			continue;
+		}
+		out ??= nodes.slice(0, index);
+		let from = 0;
+		for (const span of found) {
+			if (span.start > from) out.push({
+				type: "text",
+				value: value.slice(from, span.start)
+			});
+			out.push({
+				type: "link",
+				url: normalizeUri(span.url),
+				title: "",
+				children: [{
+					type: "text",
+					value: value.slice(span.start, span.end)
+				}]
+			});
+			from = span.end;
+		}
+		if (from < value.length) out.push({
+			type: "text",
+			value: value.slice(from)
+		});
+	}
+	return out ?? nodes;
+};
+/**
+* The finished nodes under a parent, with text that ended up side by side joined. `links` is
+* whether bare addresses in the text become links: not inside a link, which cannot hold another.
+*/
+const finish = (parent, links) => {
+	const out = [];
+	let last;
+	for (let node = parent.first; node !== null; node = node.next) {
+		let made;
+		switch (node.type) {
+			case "text":
+				if (node.value === "") continue;
+				if (last !== void 0 && last.type === "text") {
+					last.value += node.value;
+					continue;
+				}
+				made = {
+					type: "text",
+					value: node.value
+				};
+				break;
+			case "link":
+				made = {
+					type: "link",
+					url: node.url,
+					title: node.title,
+					children: finish(node, false)
+				};
+				break;
+			case "image": {
+				const children = finish(node, false);
+				made = {
+					type: "image",
+					url: node.url,
+					title: node.title,
+					alt: plainText(children)
+				};
+				break;
+			}
+			case "emphasis":
+			case "strong":
+			case "delete":
+				made = {
+					type: node.type,
+					children: finish(node, links)
+				};
+				break;
+			case "softbreak":
+				if (last !== void 0 && last.type === "text") {
+					last.value += "\n";
+					continue;
+				}
+				made = {
+					type: "text",
+					value: "\n"
+				};
+				break;
+			case "break":
+				made = { type: "break" };
+				break;
+			case "node":
+				if (node.node === null) continue;
+				made = node.node;
+				break;
+			default: made = {
+				type: node.type,
+				value: node.value
+			};
+		}
+		out.push(made);
+		last = made;
+	}
+	return links ? linkify(out) : out;
+};
+/**
+* Runs one parse of a document and puts back what the inline parser was reading before it. The
+* parser keeps its place in this module, which is what makes it fast; an extension's rule that
+* parses a text of its own (a caption, a cell) starts a second parse in the middle of the first,
+* and the first one goes on from where it was.
+*/
+const isolated = (run) => {
+	const held = [
+		subject,
+		pos,
+		end,
+		ctx,
+		root,
+		delimiters,
+		brackets,
+		bareLinks,
+		noBacktickCloser
+	];
+	const heldText = state.text;
+	const heldPos = state.pos;
+	try {
+		return run();
+	} finally {
+		[subject, pos, end, ctx, root, delimiters, brackets, bareLinks, noBacktickCloser] = held;
+		state.text = heldText;
+		state.pos = heldPos;
+	}
+};
+const state = {
+	text: "",
+	pos: 0,
+	push: (node) => {
+		const wrapper = inl("node");
+		wrapper.node = node;
+		append(root, wrapper);
+	}
+};
+/** Reads the inline text of one block into nodes. */
+const parseInlines = (source, context) => {
+	let length = source.length;
+	while (length > 0) {
+		const code = source.charCodeAt(length - 1);
+		if (code !== 32 && code !== 10 && code !== 9) break;
+		length--;
+	}
+	subject = length === source.length ? source : source.slice(0, length);
+	pos = 0;
+	end = length;
+	ctx = context;
+	root = inl("root");
+	delimiters = null;
+	brackets = null;
+	noBacktickCloser = null;
+	bareLinks = context.gfm && mayHoldBareLink(subject);
+	const special = context.special;
+	const rules = context.rules;
+	while (pos < end) {
+		const code = subject.charCodeAt(pos);
+		const own = code < 128 ? rules[code] : void 0;
+		if (own !== void 0) {
+			state.text = subject;
+			state.pos = pos;
+			let handled = false;
+			for (const rule of own) if (rule(state)) {
+				handled = true;
+				break;
+			}
+			if (handled) {
+				pos = state.pos;
+				continue;
+			}
+		}
+		switch (code) {
+			case C_NEWLINE:
+				parseNewline();
+				break;
+			case C_BACKSLASH:
+				parseBackslash();
+				break;
+			case C_BACKTICK:
+				parseBackticks();
+				break;
+			case C_ASTERISK:
+			case C_UNDERSCORE:
+				parseDelimiters(code);
+				break;
+			case C_TILDE:
+				if (context.gfm) parseDelimiters(code);
+				else {
+					pos++;
+					text("~");
+				}
+				break;
+			case C_OPEN_BRACKET:
+				parseOpenBracket();
+				break;
+			case C_BANG:
+				parseBang();
+				break;
+			case C_CLOSE_BRACKET:
+				parseCloseBracket();
+				break;
+			case C_LESSTHAN:
+				parseLessThan();
+				break;
+			case C_AMPERSAND:
+				parseEntity();
+				break;
+			default: {
+				const start = pos;
+				pos++;
+				while (pos < end) {
+					const next = subject.charCodeAt(pos);
+					if (next < 128 && special[next] === 1) break;
+					pos++;
+				}
+				text(subject.slice(start, pos));
+			}
+		}
+	}
+	processEmphasis(null);
+	const nodes = finish(root, bareLinks);
+	subject = "";
+	return nodes;
+};
+/**
+* Reads one link reference definition from the start of a paragraph's text into `refs`. Returns
+* how many characters it took, or 0 when the text does not start with a definition.
+*/
+const parseReference = (source, refs) => {
+	subject = source;
+	pos = 0;
+	end = source.length;
+	const labelLength = parseLinkLabel();
+	if (labelLength === 0) return 0;
+	const label = source.slice(0, labelLength);
+	if (source.charCodeAt(pos) !== C_COLON) return 0;
+	pos++;
+	spnl();
+	const destination = parseLinkDestination();
+	if (destination === null) return 0;
+	const beforeTitle = pos;
+	spnl();
+	let title = null;
+	if (pos !== beforeTitle) title = parseLinkTitle();
+	if (title === null) pos = beforeTitle;
+	let atLineEnd = match(reSpaceAtEndOfLine) !== null;
+	if (!atLineEnd && title !== null) {
+		title = null;
+		pos = beforeTitle;
+		atLineEnd = match(reSpaceAtEndOfLine) !== null;
+	}
+	if (!atLineEnd) return 0;
+	const normalized = normalizeLabel(label);
+	if (normalized === "") return 0;
+	if (!refs.has(normalized)) refs.set(normalized, {
+		url: destination,
+		title: title ?? ""
+	});
+	return pos;
+};
+/** The characters that start an inline construct, as a table by ASCII code. */
+const specialCharacters = (extra) => {
+	const table = /* @__PURE__ */ new Uint8Array(128);
+	for (const char of `\n\\\`*_~[]!<&${extra}`) table[char.charCodeAt(0)] = 1;
+	return table;
+};
+export { CLOSETAG, OPENTAG, isolated, normalizeLabel, parseInlines, parseReference, specialCharacters };
+
+//# sourceMappingURL=inlines.js.map