@pierre/words 0.0.0-stage → 0.1.0

package/dist/dom-BAclEeRf.js

@@ -0,0 +1,1094 @@
+import { createHtmlSession } from "@pierre/words";
+//#region html/render.ts
+const lineGroup = "<span data-markdown=\"code-lines\">";
+/**
+* Wrap code in groups of 64 lines, so the browser lays out only the last group
+* when a streamed line changes. Each LF stays inside its group, so `textContent`
+* does not change. An LF inside an element never splits a group.
+*/
+function groupLines(body) {
+	let result = "";
+	let start = 0;
+	let lines = 0;
+	let depth = 0;
+	let tag = body.indexOf("<");
+	for (let at = body.indexOf("\n"); at !== -1; at = body.indexOf("\n", at + 1)) {
+		for (; tag !== -1 && tag < at; tag = body.indexOf("<", tag + 1)) if (body.charCodeAt(tag + 1) === 47) depth--;
+		else if (body.charCodeAt(body.indexOf(">", tag) - 1) !== 47) depth++;
+		if (++lines >= 64 && depth === 0) {
+			result += lineGroup + body.slice(start, at + 1) + "</span>";
+			start = at + 1;
+			lines = 0;
+		}
+	}
+	return result === "" || start < body.length ? result + lineGroup + body.slice(start) + "</span>" : result;
+}
+/** Gutter line numbers, in the same 64-line groups as the code. */
+function lineNumbers(count) {
+	let html = "";
+	for (let line = 1; line <= count; line += 64) {
+		html += lineGroup + line;
+		for (let next = line + 1; next < line + 64 && next <= count; next++) html += "\n" + next;
+		html += (line + 64 <= count ? "\n" : "") + "</span>";
+	}
+	return html;
+}
+/** The code buttons as bits: 1 for copy, 2 for download. Equal inline option objects give equal bits. */
+const controlFlags = (controls) => {
+	const code = typeof controls === "object" ? controls.code : controls;
+	return code === false ? 0 : typeof code === "object" ? (code.copy === false ? 0 : 1) | (code.download === false ? 0 : 2) : 3;
+};
+/** The HTML before and after the code of a fenced block. */
+function codeWrapper(attributes, language, incomplete, numbers, options) {
+	const flags = controlFlags(options.controls);
+	const button = (action) => `<button type="button" data-code-action="${action.toLowerCase()}" aria-label="${action} code"${incomplete ? " disabled=\"\"" : ""}>${action}</button>`;
+	return [`<div data-markdown="code-block" data-language="${escapeHtml(language)}"${incomplete ? " data-incomplete=\"true\"" : ""}><div data-markdown="code-header"><span>${escapeHtml(language)}</span><span>${(flags & 1) !== 0 ? button("Copy") : ""}${(flags & 2) !== 0 ? button("Download") : ""}</span></div><pre dir="ltr">${numbers === void 0 ? "" : `<span data-markdown="line-numbers" aria-hidden="true">${lineNumbers(numbers)}</span>`}<code${attributes}>`, "</code></pre></div>"];
+}
+/** Escape text for use in HTML. */
+function escapeHtml(value) {
+	let result = "";
+	let from = 0;
+	for (let at = 0; at < value.length; at++) {
+		let entity;
+		switch (value.charCodeAt(at)) {
+			case 34:
+				entity = "&quot;";
+				break;
+			case 38:
+				entity = "&amp;";
+				break;
+			case 39:
+				entity = "&#39;";
+				break;
+			case 60:
+				entity = "&lt;";
+				break;
+			case 62:
+				entity = "&gt;";
+				break;
+			default: continue;
+		}
+		result += value.slice(from, at) + entity;
+		from = at + 1;
+	}
+	return from === 0 ? value : result + value.slice(from);
+}
+/** Decode only the entities that Wasm writes. The result is text, not HTML. */
+function decodeHtml(value) {
+	let result = "";
+	let from = 0;
+	for (let at = value.indexOf("&"); at !== -1; at = value.indexOf("&", at + 1)) {
+		let character;
+		let end = at + 3;
+		while (end < at + 6 && value.charCodeAt(end) !== 59) end++;
+		switch (value.slice(at + 1, end)) {
+			case "amp":
+				character = "&";
+				break;
+			case "lt":
+				character = "<";
+				break;
+			case "gt":
+				character = ">";
+				break;
+			case "quot":
+				character = "\"";
+				break;
+			case "#39":
+			case "#x27":
+				character = "'";
+				break;
+			default: continue;
+		}
+		result += value.slice(from, at) + character;
+		from = end + 1;
+	}
+	return from === 0 ? value : result + value.slice(from);
+}
+/** Hooks can come from untyped code, and a non-string would print as text. */
+function hookHtml(html) {
+	if (typeof html !== "string") throw new TypeError("HTML hooks must return strings");
+	return html;
+}
+/**
+* Return `url` if it is relative or uses http, https, mailto, tel, or a scheme
+* the parser autolinks (ftp, xmpp). Reject network paths.
+*/
+function defaultUrlTransform(url) {
+	let normalized = "";
+	let from = 0;
+	for (let at = 0; at < url.length; at++) {
+		const code = url.charCodeAt(at);
+		if (code <= 32 || code >= 127 && code <= 159) {
+			normalized += url.slice(from, at);
+			from = at + 1;
+		}
+	}
+	normalized = from === 0 ? url : normalized + url.slice(from);
+	const second = normalized.charCodeAt(1);
+	if (normalized.charCodeAt(0) === 92 || normalized.charCodeAt(0) === 47 && (second === 47 || second === 92)) return void 0;
+	let colon = -1;
+	scheme: for (let at = 0; at < normalized.length; at++) switch (normalized.charCodeAt(at)) {
+		case 35:
+		case 47:
+		case 63: break scheme;
+		case 58: colon = at;
+	}
+	if (colon >= 0) switch (normalized.slice(0, colon).toLowerCase()) {
+		case "http":
+		case "https":
+		case "ftp":
+		case "mailto":
+		case "tel":
+		case "xmpp": break;
+		default: return;
+	}
+	return url;
+}
+const voidTags = /* @__PURE__ */ new Set([
+	"br",
+	"hr",
+	"img",
+	"input"
+]);
+/** Whether the tag at [at, end) of Wasm HTML is void. All but `<input>` end with ` />`. */
+const isVoidAt = (html, at, end) => html.charCodeAt(end - 2) === 47 || html.startsWith("<input", at);
+/** Whether a character code continues a tag name, as `\w` does. */
+const isNameCode = (code) => code >= 48 && code <= 57 || code >= 65 && code <= 90 || code === 95 || code >= 97 && code <= 122;
+/** The language of a fence from the attributes of its `<code>`. */
+function codeLanguage(attributes) {
+	const at = attributes.indexOf("class=\"language-");
+	return at < 0 ? "text" : decodeHtml(attributes.slice(at + 16, attributes.indexOf("\"", at + 16)));
+}
+/**
+* Run `transform` on each `tag` element, without a syntax tree. Inner elements
+* run first, and each element runs once.
+*/
+function mapElements(html, tag, transform) {
+	const expression = new RegExp(`<(/?)${tag}\\b[^>]*>`, "g");
+	const isVoid = voidTags.has(tag);
+	const open = [];
+	let result = "";
+	let cursor = 0;
+	for (let match = expression.exec(html); match !== null; match = expression.exec(html)) {
+		let piece = html.slice(cursor, match.index);
+		cursor = expression.lastIndex;
+		if (match[1] === "" && !isVoid) {
+			if (open.length === 0) result += piece;
+			else open[open.length - 1] += piece;
+			open.push(match[0]);
+			continue;
+		}
+		if (match[1] !== "" && (isVoid || open.length === 0)) piece += match[0];
+		else {
+			const replacement = hookHtml(transform(match[1] === "" ? match[0] : open.pop() + piece + match[0]));
+			piece = match[1] === "" ? piece + replacement : replacement;
+		}
+		if (open.length === 0) result += piece;
+		else open[open.length - 1] += piece;
+	}
+	return result + open.join("") + html.slice(cursor);
+}
+/** Apply element filters and URL checks to HTML from Wasm, and add `data-markdown`. Runs before hooks. */
+function decorate(html, options) {
+	const { allowedElements, disallowedElements } = options;
+	if (allowedElements !== void 0 && disallowedElements !== void 0) throw new Error("Use either allowedElements or disallowedElements");
+	const filtered = allowedElements !== void 0 || disallowedElements !== void 0;
+	const excluded = (tag) => allowedElements !== void 0 ? !allowedElements.includes(tag) : disallowedElements.includes(tag);
+	let result = "";
+	let from = 0;
+	let dropped = 0;
+	for (let at = html.indexOf("<"), end = 0; at !== -1; at = html.indexOf("<", end)) {
+		const closing = html.charCodeAt(at + 1) === 47;
+		if (closing && !filtered) {
+			end = at + 2;
+			continue;
+		}
+		end = html.indexOf(">", at) + 1;
+		if (end === 0) break;
+		if (dropped > 0) {
+			if (!closing) dropped += isVoidAt(html, at, end) ? 0 : 1;
+			else if (--dropped === 0) from = end;
+			continue;
+		}
+		if (closing) {
+			if (options.unwrapDisallowed === true && excluded(html.slice(at + 2, end - 1))) {
+				result += html.slice(from, at);
+				from = end;
+			}
+			continue;
+		}
+		let space = at + 1;
+		for (let code = html.charCodeAt(space); code !== 32 && code !== 62; code = html.charCodeAt(++space));
+		const tag = html.slice(at + 1, space);
+		if (filtered && excluded(tag)) {
+			result += html.slice(from, at);
+			from = end;
+			if (options.unwrapDisallowed !== true && !voidTags.has(tag)) dropped = 1;
+			continue;
+		}
+		if (space === end - 1) {
+			result += html.slice(from, space) + " data-markdown=\"" + tag + "\">";
+			from = end;
+			continue;
+		}
+		result += html.slice(from, at);
+		from = end;
+		let stop = end - 1;
+		if (html.charCodeAt(stop - 1) === 47) for (stop--; html.charCodeAt(stop - 1) === 32; stop--);
+		const text = html.slice(space, stop);
+		const pending = tag === "a" && text === " data-markdown-incomplete";
+		let attributes = "";
+		if (!pending && text !== "") {
+			const note = tag === "a" ? text.indexOf("\" data-footnote-") : -1;
+			const footnote = note > 0 && text.charCodeAt(note - 1) !== 61;
+			let invalidImage = false;
+			let copied = 0;
+			for (let equals = text.indexOf("=\""); equals !== -1; equals = text.indexOf("=\"", copied)) {
+				const start = text.lastIndexOf(" ", equals);
+				const key = text.slice(start + 1, equals);
+				const close = text.indexOf("\"", equals + 2);
+				const value = text.slice(equals + 2, close);
+				attributes += text.slice(copied, start);
+				copied = close + 1;
+				switch (key) {
+					case "align":
+						attributes += ` style="text-align:${value}"`;
+						break;
+					case "id":
+						attributes += ` id="${escapeHtml(options.idPrefix ?? "")}${value}"`;
+						break;
+					case "href":
+					case "src": {
+						const decoded = decodeHtml(value);
+						const transformed = options.urlTransform === void 0 ? decoded : options.urlTransform(decoded, key);
+						let url = transformed == null ? "" : defaultUrlTransform(transformed) ?? "";
+						if (url === "" && transformed !== "") {
+							invalidImage ||= tag === "img";
+							break;
+						}
+						if (footnote && url.startsWith("#")) url = "#" + (options.idPrefix ?? "") + url.slice(1);
+						attributes += ` ${key}="${escapeHtml(url)}"`;
+						break;
+					}
+					default: attributes += text.slice(start, copied);
+				}
+			}
+			if (invalidImage) continue;
+			attributes += text.slice(copied);
+		}
+		if (tag === "img") attributes += " loading=\"lazy\"";
+		else if (tag === "input") attributes += " readonly=\"\"";
+		result += `<${tag} data-markdown="${pending ? "incomplete-link" : tag}"${attributes}>`;
+	}
+	return result + html.slice(from);
+}
+/** Format session output with HTML options. Keeps completed HTML and at most one live highlighter. */
+function createHtmlRenderer(options = {}) {
+	let parser = createHtmlSession();
+	let stable = "";
+	let stableRaw = "";
+	let nextCode = 0;
+	let live;
+	let liveUses = 0;
+	let previousUpdate;
+	let result;
+	let revision = 0;
+	let pendingRaw = "";
+	let pendingInput;
+	let pendingActive = false;
+	let pendingCode = -1;
+	let pendingHtml = "";
+	let pendingFence;
+	let codeCache = /* @__PURE__ */ new Map();
+	let oldCodeCache = /* @__PURE__ */ new Map();
+	let fenceKey = 0;
+	let fence;
+	const dispose = () => {
+		const session = live?.session;
+		live = void 0;
+		session?.dispose();
+	};
+	/** Drop all state after an option change or a hook error, so the next render starts clean. */
+	const resetState = () => {
+		dispose();
+		parser = createHtmlSession();
+		stable = "";
+		stableRaw = "";
+		nextCode = 0;
+		previousUpdate = void 0;
+		result = void 0;
+		pendingInput = void 0;
+		pendingHtml = "";
+		pendingActive = false;
+		pendingCode = -1;
+		pendingFence = void 0;
+		codeCache = /* @__PURE__ */ new Map();
+		oldCodeCache = /* @__PURE__ */ new Map();
+		fence = void 0;
+	};
+	const format = (input, firstCode, active) => {
+		const decorated = decorate(input, options);
+		let html = "";
+		let index = firstCode;
+		let cursor = 0;
+		for (let at = decorated.indexOf("<pre "), scan = 0; at !== -1; at = decorated.indexOf("<pre ", scan)) {
+			const pre = decorated.indexOf(">", at);
+			scan = pre;
+			if (!decorated.startsWith("<code ", pre + 1)) continue;
+			const open = decorated.indexOf(">", pre + 1);
+			const end = decorated.indexOf("</code></pre>", open);
+			if (end < 0) break;
+			const codeAttributes = decorated.slice(pre + 6, open);
+			const content = decorated.slice(open + 1, end);
+			const code = decodeHtml(content);
+			const language = codeLanguage(codeAttributes);
+			const isIncomplete = active && decorated.slice(at, pre).includes("data-markdown-incomplete");
+			const number = index++;
+			html += decorated.slice(cursor, at);
+			cursor = scan = end + 13;
+			const custom = options.plugins?.renderers?.find((renderer) => typeof renderer.language === "string" ? renderer.language === language : renderer.language.includes(language));
+			if (custom !== void 0) {
+				html += hookHtml(custom.render({
+					code,
+					language,
+					isIncomplete
+				}));
+				continue;
+			}
+			const plugin = options.plugins?.code;
+			if (isIncomplete) {
+				if (live !== void 0 && (live.index !== number || live.language !== language)) dispose();
+				if (live === void 0) {
+					const session = plugin?.createSession?.();
+					if (session !== void 0) live = {
+						session,
+						index: number,
+						language
+					};
+				}
+			}
+			let highlighted;
+			if (live !== void 0 && live.index === number) {
+				liveUses++;
+				highlighted = live.session.highlight({
+					code,
+					language,
+					isIncomplete
+				});
+			} else if (plugin !== void 0) {
+				const key = language + "\0" + code;
+				highlighted = isIncomplete ? void 0 : codeCache.get(key) ?? oldCodeCache.get(key);
+				if (highlighted === void 0) {
+					highlighted = plugin.highlight({
+						code,
+						language,
+						isIncomplete
+					});
+					if (!isIncomplete && typeof highlighted === "string") codeCache.set(key, highlighted);
+				} else codeCache.set(key, highlighted);
+			}
+			if (highlighted != null && typeof highlighted !== "string") throw new TypeError("Code highlighters must return HTML strings");
+			if (!isIncomplete && live?.index === number) dispose();
+			let count = 1;
+			for (let line = code.indexOf("\n"); line !== -1 && line < code.length - 1; line = code.indexOf("\n", line + 1)) count++;
+			const [before, after] = codeWrapper(codeAttributes, language, isIncomplete, options.lineNumbers === false ? void 0 : count, options);
+			html += before + groupLines(highlighted ?? content) + after;
+		}
+		html += decorated.slice(cursor);
+		for (const [tag, render] of Object.entries(options.components ?? {})) {
+			let named = tag !== "";
+			for (let at = 0; named && at < tag.length; at++) {
+				const code = tag.charCodeAt(at);
+				named = code >= 97 && code <= 122 || at > 0 && code >= 48 && code <= 57;
+			}
+			if (render === void 0 || !named && tag !== "inlineCode") continue;
+			const inline = tag === "inlineCode";
+			if (!inline && (tag !== "code" || options.components?.inlineCode === void 0)) {
+				html = mapElements(html, tag, render);
+				continue;
+			}
+			let result = "";
+			let from = 0;
+			let pre = html.indexOf("<pre");
+			let code = inline ? html.indexOf("<code") : -1;
+			while (inline ? code !== -1 : pre !== -1) {
+				const isPre = pre !== -1 && (!inline || pre < code);
+				const at = isPre ? pre : code;
+				const name = at + (isPre ? 4 : 5);
+				const open = isNameCode(html.charCodeAt(name)) ? -1 : html.indexOf(">", name);
+				const close = open < 0 ? -1 : html.indexOf(isPre ? "</pre>" : "</code>", open + 1);
+				const next = close < 0 ? name : close + (isPre ? 6 : 7);
+				if (close >= 0 && isPre !== inline) {
+					const element = html.slice(at, next);
+					result += html.slice(from, at) + (inline ? hookHtml(render(element)) : mapElements(element, "code", render));
+					from = next;
+				}
+				if (pre !== -1 && pre < next) pre = html.indexOf("<pre", next);
+				if (inline && code < next) code = html.indexOf("<code", next);
+			}
+			html = result + html.slice(from);
+		}
+		return [html, index];
+	};
+	/**
+	* Format the last open fence as changed lines when no hook or filter needs
+	* its full element. The HTML around the fence is reused while it is unchanged,
+	* so this also works for a fence in a list or quote.
+	*/
+	const formatFence = (input, firstCode, active) => {
+		if (!active || options.allowedElements !== void 0 || options.disallowedElements !== void 0 || options.components !== void 0 && Object.values(options.components).some((hook) => hook !== void 0)) return;
+		const start = input.indexOf("<pre data-markdown-incomplete");
+		if (start < 0) return;
+		const open = input.indexOf(">", start) + 1;
+		const body = input.indexOf(">", open) + 1;
+		const end = input.indexOf("<", body);
+		if (!input.startsWith("<code", open) || end < 0) return;
+		const attributes = input.slice(open + 5, body - 1);
+		const language = codeLanguage(attributes);
+		if (options.plugins?.renderers?.some((renderer) => typeof renderer.language === "string" ? renderer.language === language : renderer.language.includes(language)) === true) return;
+		const plugin = options.plugins?.code;
+		const prefix = input.slice(0, start);
+		const suffix = input.slice(end + 13);
+		if (fence === void 0 || prefix !== fence.prefix || suffix !== fence.suffix || attributes !== fence.attributes || firstCode !== fence.firstCode) {
+			const [before, index] = format(prefix, firstCode, active);
+			fence = {
+				key: ++fenceKey,
+				prefix,
+				suffix,
+				attributes,
+				firstCode,
+				index,
+				before,
+				after: format(suffix, index + 1, active)[0],
+				highlighted: false,
+				escaped: void 0,
+				start: 0,
+				line: 0,
+				code: "",
+				codeStart: 0
+			};
+		}
+		if (live !== void 0 && (live.index !== fence.index || live.language !== language)) dispose();
+		if (live === void 0 && plugin !== void 0) {
+			const session = plugin.createSession?.();
+			if (session !== void 0) live = {
+				session,
+				index: fence.index,
+				language
+			};
+		}
+		if (plugin !== void 0 && live?.session.highlightLines === void 0) return;
+		const escaped = input.slice(body, end);
+		const length = escaped.endsWith("\n") ? escaped.length - 1 : escaped.length;
+		const lastStart = length === 0 ? 0 : escaped.lastIndexOf("\n", length - 1) + 1;
+		const unchanged = escaped === fence.escaped;
+		const from = fence.escaped !== void 0 && lastStart >= fence.start && escaped.slice(0, fence.start) === fence.escaped.slice(0, fence.start) ? fence.start : 0;
+		const firstLine = from === 0 ? 0 : fence.line;
+		let lineCount = firstLine + 1;
+		for (let at = escaped.indexOf("\n", from); at !== -1; at = escaped.indexOf("\n", at + 1)) lineCount++;
+		let code = escaped;
+		let codeStart = lastStart;
+		if (plugin !== void 0) {
+			const head = (from === 0 ? "" : fence.code.slice(0, fence.codeStart)) + decodeHtml(escaped.slice(from, lastStart));
+			code = head + decodeHtml(escaped.slice(lastStart));
+			codeStart = head.length;
+		}
+		if (live !== void 0) liveUses++;
+		let lines = live?.session.highlightLines?.({
+			code,
+			language,
+			isIncomplete: true
+		}) ?? null;
+		if (fence.highlighted !== (lines !== null)) {
+			fence.highlighted = lines !== null;
+			fence.key = ++fenceKey;
+		}
+		lines ??= {
+			firstLine: unchanged ? lineCount : firstLine,
+			lineCount,
+			html: unchanged ? "" : escaped.slice(from),
+			lastLineOffset: unchanged ? 0 : lastStart - from,
+			fullHtml: escaped
+		};
+		fence.escaped = escaped;
+		fence.start = lastStart;
+		fence.line = Math.max(0, lineCount - (escaped.endsWith("\n") ? 2 : 1));
+		fence.code = code;
+		fence.codeStart = codeStart;
+		const update = lines;
+		const count = Math.max(1, update.lineCount - (code.endsWith("\n") ? 1 : 0));
+		const numbers = options.lineNumbers === false ? void 0 : count;
+		const context = fence;
+		const renderOptions = options;
+		let fullPending;
+		return {
+			key: context.key,
+			firstLine: update.firstLine,
+			lineCount: update.lineCount,
+			lastLine: Math.max(0, update.lineCount - (code.endsWith("\n") ? 2 : 1)),
+			lastLineOffset: update.lastLineOffset,
+			html: update.html,
+			numbers,
+			get pending() {
+				if (fullPending !== void 0) return fullPending;
+				const [before, after] = codeWrapper(decorate(`<code${attributes}>`, renderOptions).slice(5, -1), language, true, numbers, renderOptions);
+				return fullPending = context.before + before + groupLines(update.fullHtml) + after + context.after;
+			}
+		};
+	};
+	return {
+		/** Change options. A reset drops caches, so completed output is formatted again. */
+		configure(next, reset = true) {
+			if (reset) resetState();
+			options = next;
+		},
+		render(source, incomplete, active = false) {
+			try {
+				const update = parser.render(source, { incomplete });
+				if (update === previousUpdate && active === pendingActive && result !== void 0) return result;
+				const changed = update !== previousUpdate;
+				let reset = false;
+				let addition = "";
+				if (changed && previousUpdate?.stable === stableRaw && !update.reset) {
+					if (update.addition !== "") {
+						[addition, nextCode] = format(update.addition, nextCode, active);
+						stable += addition;
+					}
+					stableRaw = update.stable;
+					pendingRaw = update.pending;
+				} else if (changed) {
+					const raw = update.stable + update.pending;
+					if (previousUpdate === void 0 || raw.slice(0, stableRaw.length) !== stableRaw) {
+						reset = true;
+						dispose();
+						pendingInput = void 0;
+						fence = void 0;
+						stable = "";
+						stableRaw = "";
+						nextCode = 0;
+						oldCodeCache = codeCache;
+						codeCache = /* @__PURE__ */ new Map();
+					}
+					let cut = Math.max(update.stable.length, stableRaw.length);
+					if (update.reset && cut === stableRaw.length) {
+						const previousRaw = previousUpdate === void 0 ? "" : previousUpdate.stable + previousUpdate.pending;
+						let same = cut;
+						const open = raw.indexOf("<pre data-markdown-incomplete", cut);
+						const limit = Math.min(open < 0 ? raw.length : open, previousRaw.length);
+						while (same < limit && raw.charCodeAt(same) === previousRaw.charCodeAt(same)) same++;
+						let depth = 0;
+						for (let at = same < raw.length ? raw.indexOf("<", cut) : -1, end = 0; at !== -1; at = raw.indexOf("<", end)) {
+							end = raw.indexOf(">", at) + 1;
+							if (end === 0 || end >= same) break;
+							if (raw.charCodeAt(at + 1) === 47) depth--;
+							else if (!isVoidAt(raw, at, end)) depth++;
+							if (depth === 0 && raw.charCodeAt(end) === 10) cut = end + 1;
+						}
+					}
+					if (cut > stableRaw.length) {
+						[addition, nextCode] = format(raw.slice(stableRaw.length, cut), nextCode, active);
+						stable += addition;
+					}
+					stableRaw = cut === update.stable.length ? update.stable : raw.slice(0, cut);
+					pendingRaw = raw.slice(cut);
+				}
+				previousUpdate = update;
+				if (pendingInput !== pendingRaw || pendingActive !== active || pendingCode !== nextCode) {
+					const uses = liveUses;
+					pendingFence = formatFence(pendingRaw, nextCode, active);
+					if (pendingFence === void 0) [pendingHtml] = format(pendingRaw, nextCode, active);
+					if (liveUses === uses) dispose();
+					pendingInput = pendingRaw;
+					pendingActive = active;
+					pendingCode = nextCode;
+				}
+				const completedHtml = stable;
+				const code = pendingFence;
+				const pending = pendingHtml;
+				let fullPending;
+				let fullHtml;
+				result = {
+					get html() {
+						return fullHtml ??= completedHtml + (code?.pending ?? pending);
+					},
+					stable: completedHtml,
+					addition,
+					get pending() {
+						return fullPending ??= code?.pending ?? pending;
+					},
+					code,
+					reset,
+					revision: ++revision
+				};
+				return result;
+			} catch (error) {
+				resetState();
+				throw error;
+			}
+		},
+		dispose
+	};
+}
+//#endregion
+//#region html/dom.ts
+const isFade = (node) => node.nodeType === 1 && node.getAttribute("data-markdown") === "token";
+const isText = (node) => node.nodeType === 3 || isFade(node);
+const passiveText = "[data-markdown=\"token\"], [data-markdown=\"code-header\"], [data-markdown=\"line-numbers\"], [data-markdown=\"caret\"]";
+/** Wrap new text in fade spans, and unwrap each span when its animation ends. */
+function createFades(root) {
+	const pending = /* @__PURE__ */ new Map();
+	const document = root.ownerDocument;
+	const query = document.defaultView?.matchMedia?.("(prefers-reduced-motion: reduce)");
+	let timer;
+	let timerDeadline = Infinity;
+	let requested = false;
+	let duration = 180;
+	const enabled = () => requested && duration > 0 && query?.matches !== true;
+	const arm = (next) => {
+		if (Number.isFinite(next) && timer !== void 0 && next >= timerDeadline) return;
+		if (timer !== void 0) clearTimeout(timer);
+		timer = void 0;
+		timerDeadline = next;
+		if (Number.isFinite(next)) timer = setTimeout(() => flush(), Math.max(0, next - performance.now()));
+	};
+	const flush = (all = false) => {
+		timer = void 0;
+		timerDeadline = Infinity;
+		const now = performance.now();
+		const parents = /* @__PURE__ */ new Set();
+		let next = Infinity;
+		for (const [span, deadline] of pending) {
+			if (!all && deadline > now) {
+				next = Math.min(next, deadline);
+				continue;
+			}
+			const parent = span.parentNode;
+			pending.delete(span);
+			if (parent !== null && root.contains(span)) {
+				while (span.firstChild !== null) parent.insertBefore(span.firstChild, span);
+				parent.removeChild(span);
+				parents.add(parent);
+			}
+		}
+		for (const parent of parents) parent.normalize();
+		arm(next);
+	};
+	const stop = () => {
+		arm(Infinity);
+		if (pending.size > 0) flush(true);
+	};
+	const motionChanged = () => {
+		if (query?.matches === true) stop();
+	};
+	const animate = (text) => {
+		if (!enabled() || text.data.trim() === "" || text.parentElement === null) return;
+		if (text.data.endsWith("\n") && text.data.length > 1 && text.parentElement.closest("pre code") !== null) text.splitText(text.data.length - 1);
+		if (text.parentElement.closest(passiveText) !== null) return;
+		const span = document.createElement("span");
+		span.dataset.markdown = "token";
+		span.dataset.animated = "true";
+		span.style.animationDuration = `${duration}ms`;
+		text.replaceWith(span);
+		span.append(text);
+		pending.set(span, performance.now() + duration);
+	};
+	return {
+		connect() {
+			query?.addEventListener("change", motionChanged);
+		},
+		disconnect() {
+			stop();
+			query?.removeEventListener("change", motionChanged);
+		},
+		finish() {
+			let next = Infinity;
+			for (const [span, deadline] of pending) if (!root.contains(span)) pending.delete(span);
+			else next = Math.min(next, deadline);
+			arm(next);
+		},
+		update(active, options) {
+			requested = active && options !== false;
+			const value = typeof options === "object" ? options.duration ?? 180 : 180;
+			duration = Number.isFinite(value) ? Math.max(0, value) : 180;
+			if (!enabled()) stop();
+		},
+		tree(node) {
+			if (!enabled()) return;
+			if (node.nodeType === 3) animate(node);
+			else {
+				const walker = document.createTreeWalker(node, 4);
+				let text = walker.nextNode();
+				while (text !== null) {
+					const next = walker.nextNode();
+					animate(text);
+					text = next;
+				}
+			}
+		},
+		append(parent, value, before) {
+			const previous = before === null ? parent.lastChild : before.previousSibling;
+			if (!(enabled() && value.trim() !== "" && parent.nodeType === 1 && parent.closest(passiveText) === null) && previous?.nodeType === 3) {
+				previous.appendData(value);
+				return;
+			}
+			const text = document.createTextNode(value);
+			parent.insertBefore(text, before);
+			animate(text);
+		}
+	};
+}
+/** Patch `parent` to match `incoming`, and reuse nodes. A fade span counts as text. Returns the node at `committed`. */
+function patchChildren(parent, incoming, first, fades, committed = -1, marker, revising = false) {
+	const previousText = revising ? parent.textContent ?? "" : void 0;
+	let current = first;
+	let target = incoming.firstChild;
+	let index = 0;
+	let firstPending = null;
+	while (target !== null) {
+		const nextTarget = target.nextSibling;
+		let actual;
+		if (target === marker) {
+			actual = target;
+			parent.insertBefore(target, current);
+		} else if (target.nodeType === 3) {
+			const value = target.nodeValue ?? "";
+			let previous = "";
+			let end = current;
+			while (end !== null && isText(end)) {
+				previous += end.textContent ?? "";
+				end = end.nextSibling;
+			}
+			const append = value.startsWith(previous);
+			const lineAppend = !append && previous.endsWith("\n") && value.endsWith("\n") && value.slice(0, -1).startsWith(previous.slice(0, -1));
+			if (current !== end && (append || lineAppend)) {
+				actual = current;
+				const suffix = append ? value.slice(previous.length) : value.slice(previous.length - 1, -1);
+				if (suffix !== "") {
+					const lead = current.previousSibling;
+					let before = end;
+					if (lineAppend) {
+						let last = end === null ? parent.lastChild : end.previousSibling;
+						while (last !== null && last.nodeType === 1) last = last.lastChild;
+						if (last !== null) {
+							const text = last;
+							before = text.length === 1 ? text : text.splitText(text.length - 1);
+							if (before.parentNode !== parent) parent.insertBefore(before, end);
+						}
+					}
+					fades.append(parent, suffix, before);
+					actual = lead === null ? parent.firstChild : lead.nextSibling;
+				}
+			} else {
+				while (current !== end) {
+					const next = current.nextSibling;
+					parent.removeChild(current);
+					current = next;
+				}
+				actual = target;
+				parent.insertBefore(target, end);
+				if (previous === "") {
+					if (previousText === void 0 || !previousText.includes(target.textContent ?? "")) fades.tree(target);
+					actual = target.parentNode === parent ? target : target.parentNode;
+				}
+			}
+			current = end;
+		} else if (current?.nodeType === 1 && target.nodeType === 1 && current.tagName === target.tagName && !isFade(current)) {
+			actual = current;
+			const element = current;
+			const wanted = target;
+			if (wanted.nextElementSibling === null || !element.isEqualNode(wanted)) {
+				for (let at = element.attributes.length - 1; at >= 0; at--) {
+					const attribute = element.attributes[at];
+					if (!wanted.hasAttribute(attribute.name)) element.removeAttribute(attribute.name);
+				}
+				for (const attribute of wanted.attributes) if (element.getAttribute(attribute.name) !== attribute.value) element.setAttribute(attribute.name, attribute.value);
+				patchChildren(element, wanted, element.firstChild, fades, -1, marker, revising);
+			}
+			current = element.nextSibling;
+		} else {
+			actual = target;
+			const next = current?.nextSibling ?? null;
+			parent.insertBefore(target, current);
+			if (current !== null) parent.removeChild(current);
+			if (previousText === void 0 || !previousText.includes(target.textContent ?? "")) fades.tree(target);
+			current = next;
+		}
+		if (index === committed) firstPending = actual;
+		index++;
+		target = nextTarget;
+	}
+	while (current !== null) {
+		const next = current.nextSibling;
+		parent.removeChild(current);
+		current = next;
+	}
+	return firstPending;
+}
+/** Insert a comment before the last code line, so later updates patch only that line. */
+function markLastCodeLine(code, trailingNewline) {
+	let before = code.firstChild;
+	for (let node = code.lastChild; node !== null; node = node.previousSibling) {
+		if (node.nodeType !== 3) continue;
+		const text = node;
+		let end = text.data.length;
+		if (trailingNewline && text.data.endsWith("\n")) {
+			end--;
+			trailingNewline = false;
+		}
+		if (end === 0) continue;
+		const at = text.data.lastIndexOf("\n", end - 1);
+		if (at < 0) continue;
+		before = at + 1 === text.data.length ? text.nextSibling : text.splitText(at + 1);
+		break;
+	}
+	const marker = code.ownerDocument.createComment("markdown-code");
+	code.insertBefore(marker, before);
+	return marker;
+}
+/** Render Markdown into `root`, and patch its DOM nodes on each update. */
+function createDomRenderer(root, options = {}, formatter = createHtmlRenderer(options)) {
+	const document = root.ownerDocument;
+	const checkpoint = document.createComment("markdown");
+	const template = document.createElement("template");
+	const tail = document.createElement("template");
+	const caret = document.createElement("span");
+	const fades = createFades(root);
+	let revision = 0;
+	let initialized = false;
+	let previousCaret;
+	let codeState;
+	root.dataset.markdown = "root";
+	root.insertBefore(checkpoint, root.firstChild);
+	caret.dataset.markdown = "caret";
+	caret.setAttribute("aria-hidden", "true");
+	const click = (event) => {
+		const button = event.target?.closest("button[data-code-action]");
+		if (button == null || button.disabled || !root.contains(button)) return;
+		const block = button.closest("[data-markdown=\"code-block\"]");
+		const code = block?.querySelector("pre code")?.textContent ?? "";
+		if (button.dataset.codeAction === "copy") document.defaultView?.navigator.clipboard?.writeText(code).then(() => {
+			button.textContent = "Copied";
+			setTimeout(() => {
+				button.textContent = "Copy";
+			}, 2e3);
+		}).catch(() => {
+			button.textContent = "Copy";
+		});
+		else {
+			const url = URL.createObjectURL(new Blob([code], { type: "text/plain;charset=utf-8" }));
+			const link = document.createElement("a");
+			link.href = url;
+			let language = block?.getAttribute("data-language") ?? "";
+			for (let at = 0; at < language.length; at++) {
+				const code = language.charCodeAt(at);
+				if (((code | 32) < 97 || (code | 32) > 122) && (code < 48 || code > 57)) language = "";
+			}
+			link.download = `code.${language === "" ? "txt" : language}`;
+			link.click();
+			setTimeout(() => URL.revokeObjectURL(url), 3e4);
+		}
+	};
+	return {
+		connect() {
+			fades.connect();
+			root.addEventListener("click", click);
+		},
+		disconnect() {
+			fades.disconnect();
+			formatter.dispose();
+			root.removeEventListener("click", click);
+		},
+		/**
+		* Reformat completed output only when an option value changes, so inline
+		* option objects stay cheap. New hook and `urlTransform` functions apply to
+		* later output. A changed set of hook names reformats everything. Plugins
+		* compare by their parts, because a wrapper object is often written inline.
+		*/
+		configure(next) {
+			if (next === options) return;
+			const hooks = (value) => Object.keys(value ?? {}).filter((tag) => value?.[tag] !== void 0).join(" ");
+			const samePlugins = (a, b) => {
+				const left = a?.renderers ?? [];
+				const right = b?.renderers ?? [];
+				return a?.code === b?.code && left.length === right.length && left.every((renderer, at) => renderer.render === right[at].render && String(renderer.language) === String(right[at].language));
+			};
+			let reset = false;
+			const keys = /* @__PURE__ */ new Set([...Object.keys(options), ...Object.keys(next)]);
+			for (const key of keys) {
+				const previous = options[key];
+				const value = next[key];
+				reset ||= !(previous === value || (key === "controls" ? controlFlags(previous) === controlFlags(value) : key === "components" ? hooks(previous) === hooks(value) : key === "urlTransform" ? previous === void 0 === (value === void 0) : key === "plugins" ? samePlugins(previous, value) : Array.isArray(previous) && Array.isArray(value) && previous.length === value.length && previous.every((tag, at) => tag === value[at])));
+			}
+			formatter.configure(next, reset);
+			options = next;
+		},
+		update(source, incomplete, active = false, animated = false, shape) {
+			root.toggleAttribute("data-streaming", active);
+			const update = formatter.render(source, incomplete, active);
+			const changed = update.revision !== revision;
+			const reset = !initialized || changed && (update.reset || update.revision !== revision + 1);
+			fades.update(active, animated);
+			const nextCaret = active ? shape : void 0;
+			if (!changed && nextCaret === previousCaret) return;
+			caret.remove();
+			const codeUpdate = update.code;
+			if (changed && !reset && codeUpdate !== void 0 && codeState !== void 0 && update.addition === "" && codeState.key === codeUpdate.key && root.contains(codeState.marker) && (codeUpdate.firstLine === codeUpdate.lineCount || codeUpdate.firstLine === codeState.line && codeUpdate.firstLine <= codeUpdate.lastLine) && codeUpdate.numbers === void 0 === (codeState.numbers === null) && (codeUpdate.numbers ?? 0) >= codeState.numberCount) {
+				if (codeUpdate.firstLine < codeUpdate.lineCount) {
+					const { html, lastLineOffset } = codeUpdate;
+					const marker = document.createComment("markdown-code");
+					let group = codeState.marker.parentNode;
+					let first = codeState.marker.nextSibling;
+					codeState.marker.remove();
+					for (let start = 0, line = codeUpdate.firstLine;;) {
+						let end = start;
+						let left = 64 - line % 64;
+						for (; left > 0; left--) {
+							const at = html.indexOf("\n", end);
+							if (at < 0) break;
+							end = at + 1;
+						}
+						if (left > 0) end = html.length;
+						if (group === null) {
+							if (start === end) break;
+							group = document.createElement("span");
+							group.setAttribute("data-markdown", "code-lines");
+							codeState.code.append(group);
+							first = null;
+						}
+						const at = lastLineOffset >= start && (lastLineOffset < end || end === html.length) ? lastLineOffset : -1;
+						template.innerHTML = html.slice(start, at < 0 ? end : at);
+						const fragment = template.content;
+						if (at >= 0) {
+							fragment.append(marker);
+							tail.innerHTML = html.slice(at, end);
+							fragment.append(tail.content);
+						}
+						patchChildren(group, fragment, first, fades, -1, at < 0 ? void 0 : marker);
+						if (end === html.length) break;
+						line += 64 - line % 64;
+						start = end;
+						group = null;
+					}
+					codeState.marker = marker;
+					codeState.line = codeUpdate.lastLine;
+				}
+				const count = codeUpdate.numbers ?? 0;
+				if (codeState.numbers !== null && count > codeState.numberCount) {
+					let group = codeState.numbers.lastElementChild;
+					const append = (text) => {
+						const last = group.lastChild;
+						if (last?.nodeType === 3) last.appendData(text);
+						else group.append(text);
+					};
+					let text = "";
+					for (let line = codeState.numberCount + 1; line <= count; line++) {
+						if (line % 64 !== 1) {
+							text += "\n" + line;
+							continue;
+						}
+						append(text + "\n");
+						group = document.createElement("span");
+						group.setAttribute("data-markdown", "code-lines");
+						codeState.numbers.append(group);
+						text = String(line);
+					}
+					append(text);
+					codeState.numberCount = count;
+				}
+			} else if (changed) {
+				codeState?.marker.remove();
+				codeState = void 0;
+				if (reset) {
+					if (checkpoint.parentNode !== null) root.removeChild(checkpoint);
+					root.insertBefore(checkpoint, root.firstChild);
+				}
+				template.innerHTML = reset ? update.stable : update.addition;
+				const fragment = template.content;
+				const count = fragment.childNodes.length;
+				tail.innerHTML = update.pending;
+				const incomingCode = codeUpdate === void 0 ? null : tail.content.querySelector("[data-incomplete] > pre > code");
+				const codeMarker = incomingCode === null || codeUpdate === void 0 ? void 0 : markLastCodeLine(incomingCode.lastElementChild ?? incomingCode, codeUpdate.lastLine < codeUpdate.lineCount - 1);
+				fragment.append(tail.content);
+				const firstPending = patchChildren(root, fragment, checkpoint.nextSibling, fades, count, codeMarker, initialized && reset);
+				if (checkpoint.nextSibling !== firstPending) root.insertBefore(checkpoint, firstPending);
+				if (codeUpdate !== void 0 && codeMarker?.parentNode != null) {
+					const code = codeMarker.parentNode.parentNode;
+					const numbers = code.previousElementSibling;
+					codeState = {
+						code,
+						marker: codeMarker,
+						line: codeUpdate.lastLine,
+						key: codeUpdate.key,
+						numbers: numbers?.getAttribute("data-markdown") === "line-numbers" ? numbers : null,
+						numberCount: codeUpdate.numbers ?? 0
+					};
+				}
+				if (!initialized) {
+					initialized = true;
+					fades.tree(root);
+				}
+			}
+			revision = update.revision;
+			previousCaret = nextCaret;
+			if (nextCaret !== void 0) {
+				caret.dataset.shape = nextCaret;
+				let parent = root;
+				let before = null;
+				for (let node = root.lastChild; node !== null;) {
+					if (node.nodeType === 8 || node.nodeType === 3 && node.data.trim() === "" || node.nodeType === 1 && node.hasAttribute("data-footnotes")) {
+						node = node.previousSibling;
+						continue;
+					}
+					let block = false;
+					if (node.nodeType === 1) switch (node.nodeName) {
+						case "BLOCKQUOTE":
+						case "DIV":
+						case "H1":
+						case "H2":
+						case "H3":
+						case "H4":
+						case "H5":
+						case "H6":
+						case "LI":
+						case "OL":
+						case "P":
+						case "PRE":
+						case "SECTION":
+						case "TABLE":
+						case "TBODY":
+						case "TD":
+						case "TH":
+						case "THEAD":
+						case "TR":
+						case "UL": block = true;
+					}
+					if (!block) {
+						before = node.nextSibling;
+						break;
+					}
+					parent = node;
+					if (node.nodeName === "PRE") {
+						const code = node.lastElementChild;
+						parent = code?.lastElementChild ?? code ?? node;
+						let last = parent.lastChild;
+						while (last?.nodeType === 1 && last.lastChild !== null) last = last.lastChild;
+						if (last?.nodeType === 3 && last.data.endsWith("\n")) {
+							const text = last;
+							before = text.length > 1 ? text.splitText(text.length - 1) : text;
+							parent = before.parentNode;
+						}
+						break;
+					}
+					node = node.lastChild;
+				}
+				parent.insertBefore(caret, before);
+			}
+			fades.finish();
+		}
+	};
+}
+//#endregion
+export { escapeHtml as i, createHtmlRenderer as n, defaultUrlTransform as r, createDomRenderer as t };
+
+//# sourceMappingURL=dom-BAclEeRf.js.map