@typbase/codemirror 0.2.1

package/dist/index.mjs

@@ -0,0 +1,2110 @@
+import { acceptCompletion, autocompletion, closeBracketsKeymap, completionKeymap, snippet, startCompletion } from "@codemirror/autocomplete";
+import { indentService } from "@codemirror/language";
+import { Decoration, EditorView, ViewPlugin, WidgetType, hoverTooltip, keymap, showTooltip } from "@codemirror/view";
+import { ChangeSet, EditorSelection, EditorState, Facet, Prec, RangeSetBuilder, StateEffect, StateField, countColumn, findColumn } from "@codemirror/state";
+import { copyLineDown, copyLineUp, indentLess, indentMore, insertBlankLine, moveLineDown, moveLineUp, redo, redoSelection, simplifySelection, standardKeymap, toggleBlockComment, toggleLineComment, undo, undoSelection } from "@codemirror/commands";
+import { linter, nextDiagnostic, setDiagnostics } from "@codemirror/lint";
+import { closeSearchPanel, findNext, findPrevious, gotoLine, openSearchPanel, selectNextOccurrence, selectSelectionMatches } from "@codemirror/search";
+import { LRUCache } from "lru-cache";
+//#region src/highlight.ts
+const typstSyntaxHighlighting = (fileId, typstState) => StateField.define({
+	create(state) {
+		return buildDecorations$2(state, fileId, typstState);
+	},
+	update(decoration, transaction) {
+		if (transaction.docChanged) return buildDecorations$2(transaction.state, fileId, typstState);
+		return decoration;
+	},
+	provide(field) {
+		return EditorView.decorations.from(field);
+	}
+});
+function buildDecorations$2(state, fileId, typstState) {
+	const builder = new RangeSetBuilder();
+	let tokens;
+	try {
+		tokens = typstState.highlight(fileId, state.doc.toString());
+	} catch (error) {
+		console.error("[typst] highlight panicked:", error);
+		return Decoration.none;
+	}
+	for (const token of tokens) builder.add(token.range.start, token.range.end, Decoration.mark({ class: token.tag }));
+	return builder.finish();
+}
+const parseBackticks = (str, into) => {
+	const result = str.split("`").map((sub, i) => {
+		if (i % 2) {
+			const code = document.createElement("code");
+			code.textContent = sub;
+			return code;
+		}
+		return document.createTextNode(sub);
+	});
+	into.append(...result);
+};
+//#endregion
+//#region src/hover.ts
+const typstHoverTooltip = (fileId, typstState) => hoverTooltip((_, pos, side) => {
+	let tooltip;
+	try {
+		tooltip = typstState.hover(fileId, pos, side);
+	} catch (error) {
+		console.error("[typst] hover panicked:", error);
+		return null;
+	}
+	if (tooltip) return {
+		pos,
+		create() {
+			const div = document.createElement("div");
+			if (tooltip.startsWith("<code>")) div.innerHTML = "<pre>" + tooltip.replace(/span data-tag=(\w+)/g, (_match, tag) => `span class="${"typ-" + tag}"`) + "</pre>";
+			else parseBackticks(tooltip, div);
+			return { dom: div };
+		}
+	};
+	return null;
+});
+//#endregion
+//#region src/commands.ts
+function toggleStrong(view) {
+	toggleAroundSelection(view, ["*"], ["*"]);
+	return true;
+}
+function toggleEmph(view) {
+	toggleAroundSelection(view, ["_"], ["_"]);
+	return true;
+}
+function toggleUnderline(view) {
+	toggleAroundSelection(view, ["#underline["], ["]"]);
+	return true;
+}
+function toggleStrike(view) {
+	toggleAroundSelection(view, ["#strike["], ["]"]);
+	return true;
+}
+function toggleMath(view) {
+	toggleAroundSelection(view, ["$", "$ "], ["$", " $"]);
+	return true;
+}
+function insertTabLike(view) {
+	return view.state.selection.ranges.some((range) => !range.empty) ? indentMore(view) : (view.dispatch(view.state.changeByRange(({ from: pos }) => {
+		const line = view.state.doc.lineAt(pos);
+		const spaces = countColumn(line.text, 2, pos - line.from) % 2 == 0 ? "  " : " ";
+		return {
+			changes: {
+				from: pos,
+				insert: spaces
+			},
+			range: EditorSelection.cursor(pos + spaces.length)
+		};
+	})), true);
+}
+function toggleCode(view) {
+	return toggleAroundSelection(view, ["`", {
+		regex: /(`{3,}([a-z0-9][a-z0-9-]*)?(\s*)*)/i,
+		replacement: "```\n"
+	}], ["`", {
+		regex: /((\s*)*`{3,})/,
+		replacement: "\n```"
+	}], true) === 0 && view.state.selection.ranges.every((range) => range.empty) && startCompletion(view), true;
+}
+function insertFontFamily(n, font) {
+	return wrapOrInsert(n, `#text(font: "${font}")[`, "]", `#set text(font: "${font}")\n`), true;
+}
+function cycleHeading(view) {
+	if (view.state.facet(EditorState.readOnly)) return true;
+	const { state } = view;
+	return view.dispatch(state.changeByRange((r) => {
+		let o = r.from;
+		let c = r.to;
+		const u = state.doc.lineAt(o), d = u.from;
+		if (r.empty) {
+			const f = state.doc.sliceString(u.from, o).match(/^\s*/);
+			if (f) o = u.from + f[0].length;
+			else {
+				o = u.from;
+				c = u.to;
+			}
+		}
+		const m = state.sliceDoc(d, c).match(/^(\s*)(=+)/);
+		if (m) {
+			if (!r.empty) {
+				const g = state.doc.sliceString(u.from, o).match(/^\s*/);
+				if (g) o = u.from + g[0].length;
+				else o = u.from;
+			}
+			const f = m[2].length;
+			return f < 6 ? {
+				range: EditorSelection.range(r.from + 1, r.to + 1),
+				changes: [{
+					from: o + f,
+					insert: "="
+				}]
+			} : {
+				range: EditorSelection.range(r.from - f - 1, r.to - f - 1),
+				changes: [{
+					from: o,
+					to: o + f + 1,
+					insert: ""
+				}]
+			};
+		}
+		const f = state.doc.lineAt(o);
+		let g;
+		const v = f.from === 0 ? void 0 : state.doc.lineAt(f.from - 1), y = v === void 0 || state.sliceDoc(v.from, v.to).trim().length === 0;
+		if (f.from === o || state.sliceDoc(f.from, o).trim().length === 0) g = y ? 0 : 1;
+		else {
+			g = 2;
+			if (!y) g++;
+		}
+		const E = f.text.match(/^\s*/)?.[0] ?? "", N = state.sliceDoc(o, c).split("\n"), _ = N.length > 1 && !N[0].startsWith("#[") && !N[N.length - 1].endsWith("]"), T = (g > 0 ? "\n".repeat(g) + E : "") + "= ", M = E + "  ";
+		let O = N.map((U, J) => J === 0 ? _ ? "#[\n" + E + "  " + U : U : U.trim() != "]" && !U.startsWith(M) ? M + U : U).join("\n");
+		if (_) O += "\n" + E + "]";
+		let W = T + O;
+		const P = state.doc.length === c ? void 0 : state.doc.lineAt(c + 1);
+		if (!P || P.from >= c) {
+			if (P && state.sliceDoc(P.from, P.to).match(/^\s*$/) === null) W += "\n";
+		}
+		return {
+			range: r.empty ? EditorSelection.cursor(o + T.length + O.length) : EditorSelection.range(o + T.length, o + T.length + O.length),
+			changes: [{
+				from: o,
+				to: c,
+				insert: W
+			}]
+		};
+	})), view.focus(), true;
+}
+function insertAtCursor(n, e) {
+	const r = n.state.selection.main.head;
+	n.dispatch({
+		selection: EditorSelection.cursor(r + e.length),
+		changes: ChangeSet.of({
+			from: r,
+			insert: e
+		}, n.state.doc.length)
+	});
+}
+function wrapOrInsert(view, prefix, suffix, insert) {
+	if (view.state.facet(EditorState.readOnly)) return;
+	const c = view.state;
+	if (c.selection.main.empty) view.dispatch(c.changeByRange((u) => ({
+		range: EditorSelection.cursor(u.from + insert.length),
+		changes: [{
+			from: u.from,
+			insert
+		}]
+	})));
+	else toggleAroundSelection(view, [prefix], [suffix]);
+}
+function toggleAroundSelection(view, prefixes, suffixes, preferNextLevel) {
+	if (view.state.facet(EditorState.readOnly)) return null;
+	const { state } = view, { doc } = state;
+	let matchIndex = null;
+	return view.dispatch(state.changeByRange((range) => {
+		let selRange = range;
+		if (range.empty) {
+			const line = doc.lineAt(range.from), wordMatches = line.text.matchAll(/[\p{L},.]+/gu);
+			for (const match of wordMatches) {
+				const wordStart = line.from + (match.index ?? 0), wordEnd = wordStart + match[0].length;
+				if (wordStart <= range.from && range.from <= wordEnd) selRange = EditorSelection.range(wordStart, wordEnd);
+			}
+		}
+		const matchResults = [];
+		for (let i = 0; i < prefixes.length; i++) {
+			const prefix = prefixes[i], suffix = suffixes[i];
+			let isMatch, beforeText = "", afterText = "";
+			const CONTEXT_SIZE = 50;
+			let beforeOffset = 0, afterOffset = 0;
+			if (typeof prefix === "string") {
+				beforeText = state.sliceDoc(Math.max(selRange.from - prefix.length, 0), selRange.from);
+				isMatch = beforeText === prefix;
+			} else {
+				const beforeContext = state.sliceDoc(Math.max(selRange.from - CONTEXT_SIZE, 0), selRange.from);
+				const prefixMatch = beforeContext.match(prefix.regex);
+				if (prefixMatch) {
+					beforeText = prefixMatch[1];
+					beforeOffset = beforeContext.length - (beforeText.length + beforeContext.indexOf(beforeText));
+					isMatch = true;
+				} else isMatch = false;
+			}
+			if (typeof suffix === "string") {
+				afterText = state.sliceDoc(selRange.to, Math.min(selRange.to + suffix.length, doc.length));
+				isMatch = isMatch && afterText === suffix;
+			} else {
+				const afterContext = state.sliceDoc(selRange.to, Math.min(selRange.to + CONTEXT_SIZE, doc.length));
+				const suffixMatch = afterContext.match(suffix.regex);
+				if (suffixMatch) {
+					afterText = suffixMatch[1];
+					afterOffset = afterContext.indexOf(afterText);
+					isMatch = isMatch && true;
+				}
+			}
+			if (isMatch && (beforeOffset > 0 || afterOffset > 0)) selRange = EditorSelection.range(selRange.from - beforeOffset, selRange.to + afterOffset);
+			matchResults.push({
+				before: beforeText,
+				after: afterText,
+				match: isMatch
+			});
+		}
+		for (let i = 0; i < matchResults.length; i++) {
+			if (matchResults[i].match && preferNextLevel && matchResults.slice(i + 1).some((result) => result.match)) continue;
+			const { before, after, match } = matchResults[i];
+			if (match) {
+				matchIndex = i;
+				if (i + 1 < prefixes.length) {
+					const nextPrefix = prefixes[i + 1], nextSuffix = suffixes[i + 1], newPrefix = typeof nextPrefix === "string" ? nextPrefix : nextPrefix.replacement, newSuffix = typeof nextSuffix === "string" ? nextSuffix : nextSuffix.replacement, prefixOffset = newPrefix.length - before.length;
+					return {
+						range: preferNextLevel && range.empty && i === 0 ? EditorSelection.cursor(selRange.from + prefixOffset - 1) : EditorSelection.range(selRange.from + prefixOffset, selRange.to + prefixOffset),
+						changes: [{
+							from: selRange.from - before.length,
+							to: selRange.from,
+							insert: newPrefix
+						}, {
+							from: selRange.to,
+							to: selRange.to + before.length,
+							insert: newSuffix
+						}]
+					};
+				}
+				return {
+					range: EditorSelection.range(selRange.from - before.length, selRange.to - before.length),
+					changes: [{
+						from: selRange.from - before.length,
+						to: selRange.from,
+						insert: ""
+					}, {
+						from: selRange.to,
+						to: selRange.to + after.length,
+						insert: ""
+					}]
+				};
+			}
+		}
+		const firstPrefix = prefixes[0], firstSuffix = suffixes[0], prefixText = typeof firstPrefix === "string" ? firstPrefix : firstPrefix.replacement, suffixText = typeof firstSuffix === "string" ? firstSuffix : firstSuffix.replacement;
+		return {
+			range: EditorSelection.range(selRange.from + prefixText.length, selRange.to + prefixText.length),
+			changes: [{
+				from: selRange.from,
+				insert: prefixText
+			}, {
+				from: selRange.to,
+				insert: suffixText
+			}]
+		};
+	})), state.selection.ranges.length > 1 && (matchIndex = null), view.focus(), matchIndex;
+}
+function toggleList(n) {
+	toggleListLike(n, "- ");
+	return true;
+}
+function toggleEnum(n) {
+	toggleListLike(n, "+ ");
+	return true;
+}
+function toggleListLike(view, prefix) {
+	if (view.state.facet(EditorState.readOnly)) return;
+	const { doc } = view.state;
+	view.dispatch(view.state.changeByRange((range) => {
+		const changes = [];
+		let fromOffset = 0, toOffset = 0;
+		const calculateOffset = (pos, change) => change.from <= pos ? change.insert.length - (Math.min(change.to, pos) - change.from) : 0;
+		const addChange = (change) => {
+			changes.push(change);
+			fromOffset += calculateOffset(range.from, change);
+			toOffset += calculateOffset(range.to, change);
+		};
+		const getLineStart = (lineNum) => {
+			const line = doc.line(lineNum);
+			const indentMatch = line.text.match(/^\s*/);
+			return line.from + (indentMatch?.[0].length ?? 0);
+		};
+		const startLine = doc.lineAt(range.from), endLine = doc.lineAt(range.to), listMarkers = [];
+		let currentLineNum = startLine.number, hasListMarkers = false;
+		const lineIter = doc.iterLines(startLine.number, endLine.number + 1);
+		while (lineIter.next() && !lineIter.done) {
+			const listMatch = lineIter.value.trimStart().match(/^(-|\+|\d*\.)\s?/);
+			if (listMatch !== null) {
+				listMarkers.push([currentLineNum, listMatch[0].length]);
+				hasListMarkers = true;
+			}
+			currentLineNum++;
+		}
+		if (hasListMarkers) for (const [lineNum, markerLength] of listMarkers) {
+			const lineStart = getLineStart(lineNum);
+			addChange({
+				from: lineStart,
+				to: lineStart + markerLength,
+				insert: ""
+			});
+		}
+		else for (let lineNum = startLine.number; lineNum <= endLine.number; lineNum++) {
+			const lineStart = getLineStart(lineNum);
+			addChange({
+				from: lineStart,
+				to: lineStart,
+				insert: prefix
+			});
+		}
+		return {
+			range: EditorSelection.range(range.from + fromOffset, range.to + toOffset),
+			changes
+		};
+	}));
+	view.focus();
+}
+function cursorAddVertical(view, offset) {
+	const { state } = view, newCursors = [];
+	for (const range of state.selection.ranges) {
+		const currentLine = state.doc.lineAt(range.from), currentColumn = countColumn(currentLine.text, state.tabSize, range.from - currentLine.from), targetLineNum = currentLine.number + offset;
+		if (targetLineNum >= 1 && targetLineNum <= state.doc.lines) {
+			const targetLine = state.doc.line(currentLine.number + offset), targetPos = targetLine.from + findColumn(targetLine.text, currentColumn, state.tabSize);
+			newCursors.push(EditorSelection.cursor(targetPos));
+		}
+	}
+	if (offset > 0) newCursors.reverse();
+	newCursors.push(...state.selection.ranges);
+	view.dispatch({
+		selection: EditorSelection.create(newCursors),
+		scrollIntoView: true,
+		userEvent: "select"
+	});
+	return true;
+}
+//#endregion
+//#region src/keymap.ts
+const typstKeymap = keymap.of([
+	...completionKeymap,
+	...closeBracketsKeymap,
+	{
+		key: "Tab",
+		run: acceptCompletion
+	},
+	{
+		key: "Mod-z",
+		run: undo,
+		preventDefault: true
+	},
+	{
+		key: "Mod-y",
+		mac: "Mod-Shift-z",
+		run: redo,
+		preventDefault: true
+	},
+	{
+		key: "Mod-Shift-z",
+		run: redo,
+		preventDefault: true
+	},
+	{
+		key: "Mod-u",
+		run: undoSelection,
+		preventDefault: true
+	},
+	{
+		key: "Alt-u",
+		mac: "Mod-Shift-u",
+		run: redoSelection,
+		preventDefault: true
+	},
+	{
+		key: "Mod-/",
+		run: toggleLineComment
+	},
+	{
+		mac: "Cmd-Alt-/",
+		win: "Shift-Alt-a",
+		linux: "Ctrl+Shift+a",
+		run: toggleBlockComment
+	},
+	{
+		key: "Mod-#",
+		run: toggleLineComment
+	},
+	{
+		key: "Mod-Shift-7",
+		run: toggleLineComment
+	},
+	{
+		key: "Mod-Shift-/",
+		run: toggleLineComment
+	},
+	{
+		key: "Shift-Alt-a",
+		run: toggleBlockComment
+	},
+	{
+		key: "Mod-b",
+		run: toggleStrong
+	},
+	{
+		key: "Mod-Shift-f",
+		run: toggleStrong
+	},
+	{
+		key: "Mod-i",
+		run: toggleEmph
+	},
+	{
+		key: "Mod-Shift-K",
+		run: toggleEmph
+	},
+	{
+		key: "Mod-u",
+		run: toggleUnderline
+	},
+	{
+		key: "Alt-ArrowUp",
+		run: moveLineUp
+	},
+	{
+		key: "Shift-Alt-ArrowUp",
+		run: copyLineUp
+	},
+	{
+		key: "Alt-ArrowDown",
+		run: moveLineDown
+	},
+	{
+		key: "Shift-Alt-ArrowDown",
+		run: copyLineDown
+	},
+	{
+		key: "Tab",
+		run: insertTabLike,
+		shift: indentLess
+	},
+	{
+		key: "Mod-Enter",
+		run: insertBlankLine
+	},
+	{
+		key: "F8",
+		run: nextDiagnostic
+	},
+	{
+		key: "Mod-g",
+		run: gotoLine,
+		scope: "editor goto-panel search-panel"
+	},
+	{
+		key: "Escape",
+		run: simplifySelection
+	},
+	{
+		key: "Mod-Alt-ArrowUp",
+		run: (n) => cursorAddVertical(n, -1)
+	},
+	{
+		key: "Mod-Alt-ArrowDown",
+		run: (n) => cursorAddVertical(n, 1)
+	},
+	{
+		key: "Mod-f",
+		run: openSearchPanel,
+		scope: "editor search-panel goto-panel"
+	},
+	{
+		key: "F3",
+		run: findNext,
+		shift: findPrevious,
+		scope: "editor search-panel",
+		preventDefault: true
+	},
+	{
+		key: "Escape",
+		run: closeSearchPanel,
+		scope: "editor search-panel"
+	},
+	{
+		key: "Mod-Shift-l",
+		run: selectSelectionMatches
+	},
+	{
+		key: "Mod-d",
+		run: selectNextOccurrence,
+		preventDefault: true
+	},
+	...standardKeymap
+]);
+//#endregion
+//#region src/language.ts
+async function autocomplete(context, fileId, typstState) {
+	const { pos, explicit } = context;
+	let result;
+	try {
+		result = typstState.autocomplete(fileId, pos, explicit);
+	} catch (error) {
+		console.error("[typst] autocomplete panicked:", error);
+		return null;
+	}
+	if (!result) return null;
+	const { offset, completions } = result;
+	return {
+		from: offset,
+		options: completions.map((completion) => {
+			const complete = {
+				type: typeof completion.type === "object" ? "symbol" : completion.type,
+				apply: completion.apply,
+				label: completion.label,
+				info: completion.detail
+			};
+			if (completion.apply?.includes("$")) {
+				const tt = completion.apply.match(/\$\{\w*\}/)?.at(0) == "${}" && (completion.type !== "syntax" || completion.label != "linebreak"), applySnippet = snippet(completion.apply);
+				complete.apply = (applyView, applyCompletion, from, to) => {
+					applySnippet(applyView, applyCompletion, from, to);
+					if (tt) startCompletion(applyView);
+				};
+			}
+			return complete;
+		})
+	};
+}
+const typstLanguageData = EditorState.languageData.of(() => [{
+	closeBrackets: {
+		brackets: [
+			"(",
+			"[",
+			"{",
+			"\"",
+			"`",
+			"$"
+		],
+		before: ")]}\"`$,;"
+	},
+	commentTokens: {
+		line: "//",
+		block: {
+			open: "/*",
+			close: "*/"
+		}
+	},
+	wordChars: "-_",
+	indentOnInput: /^\s*[[\]{}()$]$/
+}]);
+//#endregion
+//#region src/notebook.ts
+/** The options of the notebook extension active in this state, if any. */
+const notebookOptionsFacet = Facet.define({ combine: (values) => values.at(-1) });
+function notebookOptions(state) {
+	return state.facet(notebookOptionsFacet);
+}
+/** Re-renders notebooks from cached frames without recompiling. */
+const notebookRefreshEffect = StateEffect.define();
+/** Asks the plugin to recompile and report the result through `onRun`. */
+const notebookRunEffect = StateEffect.define();
+/** First position that belongs to the cell (marker line, or content). */
+function cellStart(cell) {
+	return cell.marker_end > cell.marker_start ? cell.marker_start : cell.content_start;
+}
+function hasMarker(cell) {
+	return cell.marker_end > cell.marker_start;
+}
+/** Index of the cell containing `pos`; gaps belong to the cell above. */
+function cellIndexAt(cells, pos) {
+	let index = cells.length ? 0 : -1;
+	for (let i = 0; i < cells.length; i++) if (pos >= cellStart(cells[i])) index = i;
+	else break;
+	return index;
+}
+function cellsOf(state) {
+	const options = notebookOptions(state);
+	return options ? options.cells(state.doc.toString()) : [];
+}
+/** Position just past a cell's block, including the gap before the next one. */
+function blockEnd(cells, index, text) {
+	const next = cells[index + 1];
+	return next ? cellStart(next) : text.length;
+}
+/** The marker line for a cell type. Markup is the unlabeled default. */
+function markerText(type) {
+	return type === "code" ? "// %% [code]" : "// %%";
+}
+function insertCellText(text, cells, index, where, type, content = "") {
+	const marker = markerText(type);
+	if (where === "end" || cells.length === 0) {
+		const from = text.length;
+		const insert = `${from === 0 || text.endsWith("\n\n") ? "" : text.endsWith("\n") ? "\n" : "\n\n"}${marker}\n${content ? `${content}\n` : ""}`;
+		return {
+			changes: {
+				from,
+				insert
+			},
+			anchor: from + insert.length
+		};
+	}
+	const cell = cells[index];
+	const from = where === "above" ? cellStart(cell) : blockEnd(cells, index, text);
+	return {
+		changes: {
+			from,
+			insert: `${marker}\n${content ? `${content}\n` : ""}\n`
+		},
+		anchor: from + marker.length + 1 + content.length
+	};
+}
+function duplicateCellText(text, cells, index) {
+	const cell = cells[index];
+	return insertCellText(text, cells, index, "below", cell.kind, text.slice(cell.content_start, cell.content_end));
+}
+function deleteCellText(text, cells, index) {
+	const cell = cells[index];
+	if (cells.length <= 1) return {
+		changes: {
+			from: 0,
+			to: text.length,
+			insert: ""
+		},
+		anchor: 0
+	};
+	const from = cellStart(cell);
+	return {
+		changes: {
+			from,
+			to: blockEnd(cells, index, text),
+			insert: ""
+		},
+		anchor: from
+	};
+}
+function moveCellText(text, cells, index, delta) {
+	const target = index + delta;
+	if (target < 0 || target >= cells.length) return null;
+	const aStart = cellStart(cells[index]);
+	const aEnd = blockEnd(cells, index, text);
+	const bStart = cellStart(cells[target]);
+	const bEnd = blockEnd(cells, target, text);
+	const from = Math.min(aStart, bStart);
+	const to = Math.max(aEnd, bEnd);
+	const a = text.slice(aStart, aEnd).trimEnd();
+	const b = text.slice(bStart, bEnd).trimEnd();
+	return {
+		changes: {
+			from,
+			to,
+			insert: `${delta < 0 ? `${a}\n\n${b}` : `${b}\n\n${a}`}${to < text.length ? "\n\n" : "\n"}`
+		},
+		anchor: delta < 0 ? bStart : bStart + b.length + 2
+	};
+}
+function splitCellText(text, cells, index, pos) {
+	const cell = cells[index];
+	if (pos < cell.content_start || pos > cell.content_end) return null;
+	return {
+		changes: {
+			from: pos,
+			insert: `\n\n${markerText(cell.kind)}\n\n`
+		},
+		anchor: pos
+	};
+}
+function mergeCellText(text, cells, index) {
+	const cell = cells[index];
+	if (index === 0 || !hasMarker(cell)) return null;
+	return {
+		changes: {
+			from: cell.marker_start,
+			to: cell.content_start,
+			insert: ""
+		},
+		anchor: cell.marker_start
+	};
+}
+function setCellTypeText(text, cells, index, type) {
+	const cell = cells[index];
+	const marker = markerText(type);
+	if (hasMarker(cell)) return {
+		changes: {
+			from: cell.marker_start,
+			to: cell.marker_end,
+			insert: marker
+		},
+		anchor: cell.content_start + (marker.length - (cell.marker_end - cell.marker_start))
+	};
+	return {
+		changes: {
+			from: cellStart(cell),
+			insert: `${marker}\n`
+		},
+		anchor: cell.content_start + marker.length + 1
+	};
+}
+/** Matches a whole cell marker line, indentation and newline included. */
+const MARKER_LINE = /^[ \t]*\/\/[ \t]*%%(?:[ \t]*\[(?:code|markup|text)\])?[ \t]*\r?\n?/gm;
+/**
+* Removes `// %%` cell markers. Notebooks are comments-plus-content, so a
+* cleaned file is the same document for anyone who does not know the
+* convention.
+*/
+function stripCellMarkers(text) {
+	return text.replace(MARKER_LINE, "");
+}
+function dispatchEdit(view, edit) {
+	view.dispatch({
+		changes: edit.changes,
+		selection: { anchor: edit.anchor },
+		scrollIntoView: true
+	});
+	return true;
+}
+/** Compiles and reports through `onRun`; does not move the cursor. */
+function runCell(view, index) {
+	if (!notebookOptions(view.state) || index < 0) return false;
+	view.dispatch({ effects: notebookRunEffect.of({ index }) });
+	return true;
+}
+function runAllCells(view) {
+	if (!notebookOptions(view.state)) return false;
+	view.dispatch({ effects: notebookRunEffect.of({ index: "all" }) });
+	return true;
+}
+function focusCell(view, index, edge = "start") {
+	const cell = cellsOf(view.state)[index];
+	if (!cell) return false;
+	view.dispatch({
+		selection: { anchor: edge === "start" ? cell.content_start : cell.content_end },
+		scrollIntoView: true
+	});
+	view.focus();
+	return true;
+}
+function currentCell(view) {
+	return cellIndexAt(cellsOf(view.state), view.state.selection.main.head);
+}
+function insertCell(view, where) {
+	return insertCellAt(view, currentCell(view), where);
+}
+function insertCellAt(view, index, where) {
+	const cells = cellsOf(view.state);
+	if (index < 0 || !cells[index]) return false;
+	const type = cells[index]?.kind ?? "markup";
+	return dispatchEdit(view, insertCellText(view.state.doc.toString(), cells, index, where, type));
+}
+function duplicateCell(view) {
+	return duplicateCellAt(view, currentCell(view));
+}
+function duplicateCellAt(view, index) {
+	const cells = cellsOf(view.state);
+	if (index < 0 || !cells[index]) return false;
+	return dispatchEdit(view, duplicateCellText(view.state.doc.toString(), cells, index));
+}
+function deleteCell(view) {
+	return deleteCellAt(view, currentCell(view));
+}
+function deleteCellAt(view, index) {
+	const cells = cellsOf(view.state);
+	if (index < 0 || !cells[index]) return false;
+	return dispatchEdit(view, deleteCellText(view.state.doc.toString(), cells, index));
+}
+function moveCell(view, delta) {
+	return moveCellAt(view, currentCell(view), delta);
+}
+function moveCellAt(view, index, delta) {
+	const cells = cellsOf(view.state);
+	if (index < 0 || !cells[index]) return false;
+	const edit = moveCellText(view.state.doc.toString(), cells, index, delta);
+	if (!edit) return false;
+	return dispatchEdit(view, edit);
+}
+function splitCell(view) {
+	const cells = cellsOf(view.state);
+	const index = currentCell(view);
+	if (index < 0) return false;
+	const edit = splitCellText(view.state.doc.toString(), cells, index, view.state.selection.main.head);
+	if (!edit) return false;
+	return dispatchEdit(view, edit);
+}
+function mergeCell(view) {
+	const cells = cellsOf(view.state);
+	const index = currentCell(view);
+	if (index < 0) return false;
+	const edit = mergeCellText(view.state.doc.toString(), cells, index);
+	if (!edit) return false;
+	return dispatchEdit(view, edit);
+}
+function toggleCellType(view, index) {
+	const cells = cellsOf(view.state);
+	const cell = cells[index];
+	if (!cell) return false;
+	const next = cell.kind === "code" ? "markup" : "code";
+	return dispatchEdit(view, setCellTypeText(view.state.doc.toString(), cells, index, next));
+}
+function setCellType(view, index, type) {
+	const cells = cellsOf(view.state);
+	if (!cells[index]) return false;
+	return dispatchEdit(view, setCellTypeText(view.state.doc.toString(), cells, index, type));
+}
+function runAndAdvance(view) {
+	const cells = cellsOf(view.state);
+	const index = currentCell(view);
+	if (index < 0) return false;
+	runCell(view, index);
+	if (cells[index + 1]) focusCell(view, index + 1);
+	else dispatchEdit(view, insertCellText(view.state.doc.toString(), cells, index, "below", cells[index]?.kind ?? "markup"));
+	return true;
+}
+function runAndInsert(view) {
+	const cells = cellsOf(view.state);
+	const index = currentCell(view);
+	if (index < 0) return false;
+	runCell(view, index);
+	return dispatchEdit(view, insertCellText(view.state.doc.toString(), cells, index, "below", cells[index]?.kind ?? "markup"));
+}
+function runCurrent(view) {
+	const index = currentCell(view);
+	return index < 0 ? false : runCell(view, index);
+}
+/** Arrow keys at a cell's first or last line move between cells. */
+function boundaryMove(view, direction) {
+	const { state } = view;
+	const range = state.selection.main;
+	if (!range.empty) return false;
+	const cells = cellsOf(state);
+	const index = cellIndexAt(cells, range.head);
+	const cell = cells[index];
+	if (!cell) return false;
+	if (direction === -1) {
+		const first = state.doc.lineAt(cell.content_start);
+		if (range.head < first.from || range.head > first.to || index === 0) return false;
+		return focusCell(view, index - 1, "end");
+	}
+	const last = state.doc.lineAt(cell.content_end);
+	if (range.head < last.from || range.head > last.to || index >= cells.length - 1) return false;
+	return focusCell(view, index + 1);
+}
+/**
+* Notebook keymap. Mounted with high precedence so Alt-ArrowUp/Down move
+* cells instead of lines and Escape reaches command mode.
+*/
+const notebookKeymap = Prec.high(keymap.of([
+	{
+		key: "Shift-Enter",
+		run: runAndAdvance
+	},
+	{
+		key: "Mod-Enter",
+		run: runCurrent
+	},
+	{
+		key: "Alt-Enter",
+		run: runAndInsert
+	},
+	{
+		key: "Alt-ArrowUp",
+		run: (view) => moveCell(view, -1)
+	},
+	{
+		key: "Alt-ArrowDown",
+		run: (view) => moveCell(view, 1)
+	},
+	{
+		key: "Escape",
+		run: (view) => {
+			notebookOptions(view.state)?.onCommandMode?.();
+			return true;
+		}
+	},
+	{
+		key: "ArrowUp",
+		run: (view) => boundaryMove(view, -1)
+	},
+	{
+		key: "ArrowDown",
+		run: (view) => boundaryMove(view, 1)
+	}
+]));
+//#endregion
+//#region src/diagnostics.ts
+/**
+* Latest Typst diagnostics per page path. The WYSIWYG plugin caches the
+* diagnostics of every compile here, so the linter source can reuse them
+* instead of compiling the same text a second time.
+*/
+const diagnosticsCache = /* @__PURE__ */ new Map();
+function rememberDiagnostics(path, text, diagnostics) {
+	diagnosticsCache.set(path, {
+		text,
+		diagnostics
+	});
+}
+function cachedDiagnostics(path, text) {
+	const entry = diagnosticsCache.get(path);
+	return entry && entry.text === text ? entry.diagnostics : void 0;
+}
+/** Converts engine diagnostics into CodeMirror lint diagnostics. */
+function toLintDiagnostics(typstDiagnostics) {
+	return typstDiagnostics.map((diagnostic) => ({
+		from: diagnostic.range.start,
+		to: diagnostic.range.end,
+		severity: diagnostic.severity,
+		message: diagnostic.message,
+		renderMessage() {
+			const fragment = document.createDocumentFragment();
+			const paragraph = document.createElement("p");
+			parseBackticks(diagnostic.message, paragraph);
+			fragment.append(paragraph);
+			if (diagnostic.hints.length) {
+				const list = document.createElement("ul");
+				list.className = "typst-hints";
+				for (const hint of diagnostic.hints) {
+					const item = document.createElement("li");
+					parseBackticks(hint, item);
+					list.append(item);
+				}
+				fragment.append(list);
+			}
+			return fragment;
+		}
+	}));
+}
+/**
+* Typst diagnostics as a CodeMirror linter source.
+*
+* This runs in every editor mode and combines with other sources (the
+* spellcheck linter), so neither one replaces the other. The WYSIWYG plugin's
+* compile feeds the cache; split and source mode fall back to a compile here
+* so they get diagnostics too.
+*/
+const typstLinter = (fileId, spaceId, path, prelude, typstState, options = {}) => linter(async (view) => {
+	const text = view.state.doc.toString();
+	const cached = cachedDiagnostics(path, text);
+	if (cached) return toLintDiagnostics(cached);
+	let result;
+	try {
+		result = typstState.compilePaged(fileId, text, prelude.value);
+	} catch (error) {
+		console.error("[typst] diagnostics compile panicked:", error);
+		options.onPanic?.(fileId);
+		return [];
+	}
+	if (result.requests.length > 0 && options.onRequests) {
+		if (await options.onRequests(result.requests, spaceId)) result = typstState.compilePaged(fileId, text, prelude.value);
+	}
+	rememberDiagnostics(path, text, result.diagnostics);
+	options.onCompile?.();
+	return toLintDiagnostics(result.diagnostics);
+}, { delay: 400 });
+//#endregion
+//#region src/frames.ts
+const containerCache = new LRUCache({ max: 128 });
+const openInNewTab = (url) => {
+	window.open(url, "_blank", "noopener,noreferrer");
+};
+/**
+* The compiled size of an SVG frame, from the markup's viewBox. The viewBox
+* is the page width the engine laid out at (pt), and the app renders one
+* Typst point per CSS pixel, so the numbers map to px directly.
+*
+* `frame.render.width` is the chunk's bounding-box width, which does not
+* change with the pane for fixed-size blocks (images, boxes). The viewBox
+* width is the correct resize key and the size to pin: a render laid out
+* for a wider pane must keep its size, not be stretched by CSS while a
+* resize is in flight.
+*/
+function frameSize(frame) {
+	const match = frame.render.svg.match(/viewBox="0 0 ([\d.]+) ([\d.]+)"/);
+	return {
+		width: match ? Number(match[1]) : frame.render.width,
+		height: match ? Number(match[2]) : frame.render.height
+	};
+}
+/**
+* Pins a container's SVG to the compiled frame size (via CSS variables). The
+* container keeps max-width: 100% so it never exceeds the line. An explicit
+* container width would make CodeMirror's flex layout grow the content width
+* forever (resize -> wider widget -> wider content). The pinned SVG overflows
+* the clamped container while the pane is narrower than the compiled width;
+* the scroller clips it, so the render stays its size instead of scaling.
+*/
+function syncFrameContainer(container, frame) {
+	const size = frameSize(frame);
+	const sizeKey = `${Math.round(size.width)}x${Math.round(size.height)}`;
+	if (container.dataset.renderSize === sizeKey) return;
+	container.dataset.renderSize = sizeKey;
+	container.style.setProperty("--render-w", size.width + "px");
+	container.style.setProperty("--render-h", size.height + "px");
+	container.style.height = size.height + "px";
+	container.setHTMLUnsafe(frame.render.svg);
+}
+/** Fresh frame container for widgets that own their DOM (notebook outputs). */
+function createFrameContainer(frame) {
+	const container = document.createElement("div");
+	container.dataset.hash = frame.render.hash.toString();
+	container.classList.add("typst-render");
+	syncFrameContainer(container, frame);
+	return container;
+}
+/**
+* Click handling shared by inline widgets and notebook outputs: typbase://
+* links are left for the host's anchor router, external links confirm first
+* and go through `openExternal`, anything else maps back into the compiled
+* document and moves the cursor. Alt-click edits the link instead of
+* following it.
+*/
+function attachFrameInteractions(container, view, frame, fileId, typstState, openExternal = openInNewTab) {
+	const handle = (event) => {
+		event.preventDefault();
+		const anchor = event.target?.closest?.("a[href]");
+		if (anchor && !event.altKey) {
+			if (event.type !== "click") return;
+			const href = anchor.getAttribute("href") ?? "";
+			if (href.startsWith("typbase://")) return;
+			if (window.confirm(`Open external link?\n\n${href}\n\nIt opens in a new tab.`)) openExternal(href);
+			return;
+		}
+		const { top, left } = container.getBoundingClientRect();
+		const x = event.clientX - left;
+		const y = event.clientY - top + frame.render.yOffset;
+		const jump = (() => {
+			try {
+				return typstState.jumpPaged(fileId, x, y);
+			} catch (error) {
+				console.error("[typst] jump panicked:", error);
+				return;
+			}
+		})();
+		const position = jump ? jump.position : frame.range.end;
+		view.focus();
+		view.dispatch({ selection: { anchor: position } });
+	};
+	container.addEventListener("click", handle);
+	container.addEventListener("mousedown", handle);
+}
+/**
+* True when the selection does not touch `start..end`, so the frame can render
+* as a widget instead of showing source. Shared by the inline WYSIWYG pass and
+* the notebook markup cells.
+*/
+function frameIsInactive(view, state, start, end) {
+	return !view.hasFocus || state.selection.ranges.every((range) => (range.from < start || range.from > end) && (range.to < start || range.to > end) && (start < range.from || start > range.to) && (end < range.from || end > range.to));
+}
+/**
+* Line decorations that stand in for a frame while the cursor is inside it:
+* the source stays visible with the frame's height reserved, so the pane does
+* not jump between render and source. Matches the inline WYSIWYG behavior.
+*
+* `lineHeights` carries measured source heights from the remeasure pass; when
+* it is absent the view still reports the widget's height for those lines.
+*/
+function frameActiveDecorations(view, state, frame, lineHeights) {
+	const decorations = [];
+	let lineHeight = 0;
+	const { number: startLine } = state.doc.lineAt(frame.range.start);
+	const { number: endLine } = state.doc.lineAt(frame.range.end);
+	for (let currentLine = startLine; currentLine <= endLine; currentLine++) {
+		const line = state.doc.line(currentLine);
+		let style = "";
+		if (currentLine == startLine) style += "border-top-left-radius:0.25rem;border-top-right-radius:0.25rem;";
+		if (currentLine == endLine) style += `border-bottom-left-radius:0.25rem;border-bottom-right-radius:0.25rem;min-height:${Math.max(0, frame.render.height - lineHeight)}px`;
+		else lineHeight += lineHeights?.get(line.from) ?? view.lineBlockAt(line.from).height;
+		decorations.push(Decoration.line({
+			class: "cm-activeLine",
+			attributes: { style }
+		}).range(line.from));
+	}
+	return decorations;
+}
+var TypstWidget = class extends WidgetType {
+	view;
+	frame;
+	locked;
+	fileId;
+	typstState;
+	openExternal;
+	container;
+	size;
+	constructor(view, frame, locked, fileId, typstState, openExternal) {
+		super();
+		this.view = view;
+		this.frame = frame;
+		this.locked = locked;
+		this.fileId = fileId;
+		this.typstState = typstState;
+		this.openExternal = openExternal;
+		this.size = frameSize(frame);
+		const cached = containerCache.get(frame.render.hash);
+		if (cached?.isConnected) {
+			this.container = cached;
+			syncFrameContainer(cached, frame);
+		} else {
+			const container = document.createElement("div");
+			container.dataset.hash = frame.render.hash.toString();
+			container.classList.add("typst-render");
+			if (!locked) attachFrameInteractions(container, view, frame, fileId, typstState, this.openExternal);
+			containerCache.set(frame.render.hash, container);
+			this.container = container;
+			syncFrameContainer(container, frame);
+		}
+	}
+	eq(other) {
+		return other.frame.render.hash === this.frame.render.hash && other.size.width === this.size.width && other.size.height === this.size.height;
+	}
+	toDOM() {
+		return this.container;
+	}
+	get estimatedHeight() {
+		return this.frame.render.height;
+	}
+};
+//#endregion
+//#region src/notebook-widgets.ts
+function iconSpan(name) {
+	const span = document.createElement("span");
+	span.className = "ms-icon material-symbols-rounded";
+	span.textContent = name;
+	span.setAttribute("aria-hidden", "true");
+	return span;
+}
+/** Fallback labels for consumers that enable cells without i18n strings. */
+const FALLBACK_LABELS = {
+	run: "Run cell",
+	code: "Code",
+	markup: "Text",
+	moveUp: "Move cell up",
+	moveDown: "Move cell down",
+	duplicate: "Duplicate cell",
+	remove: "Delete cell",
+	clearOutput: "Clear output",
+	toggleSource: "Collapse cell",
+	noOutput: "No output",
+	error: "Cell error"
+};
+/** Buttons must not hand the mousedown to CodeMirror's selection handling. */
+function actionButton(icon, label, onClick, className = "") {
+	const button = document.createElement("button");
+	button.type = "button";
+	button.className = `tb-cell-btn ${className}`.trim();
+	button.title = label;
+	button.setAttribute("aria-label", label);
+	button.append(iconSpan(icon));
+	button.addEventListener("mousedown", (event) => event.preventDefault());
+	button.addEventListener("click", (event) => {
+		event.preventDefault();
+		event.stopPropagation();
+		onClick(event);
+	});
+	return button;
+}
+var NotebookHeaderWidget = class extends WidgetType {
+	view;
+	args;
+	constructor(view, args) {
+		super();
+		this.view = view;
+		this.args = args;
+	}
+	eq(other) {
+		const a = this.args;
+		const b = other.args;
+		return a.index === b.index && a.kind === b.kind && a.counter === b.counter && a.count === b.count && a.collapsed === b.collapsed && a.labels === b.labels;
+	}
+	toDOM() {
+		const { index, kind, labels } = this.args;
+		const header = document.createElement("div");
+		header.className = "tb-cell-header";
+		header.dataset.kind = kind;
+		header.dataset.cell = String(index);
+		const run = actionButton("play_arrow", labels.run, () => runCell(this.view, index));
+		run.classList.add("tb-cell-btn--run");
+		header.append(run);
+		if (this.args.counter) {
+			const chip = document.createElement("span");
+			chip.className = "tb-cell-counter";
+			chip.textContent = this.args.count === void 0 ? "[ ]" : `[${this.args.count}]`;
+			header.append(chip);
+		}
+		header.append(actionButton(kind === "code" ? "code" : "notes", kind === "code" ? labels.code : labels.markup, () => toggleCellType(this.view, index), "tb-cell-btn--type"));
+		const spacer = document.createElement("span");
+		spacer.className = "tb-cell-spacer";
+		header.append(spacer);
+		const actions = document.createElement("span");
+		actions.className = "tb-cell-actions";
+		actions.append(actionButton("arrow_upward", labels.moveUp, () => moveCellAt(this.view, index, -1)), actionButton("arrow_downward", labels.moveDown, () => moveCellAt(this.view, index, 1)), actionButton("content_copy", labels.duplicate, () => duplicateCellAt(this.view, index)), actionButton(this.args.collapsed ? "unfold_more" : "unfold_less", labels.toggleSource, () => {
+			notebookOptions(this.view.state)?.onToggleCollapse?.(index);
+			this.view.dispatch({ effects: notebookRefreshEffect.of(null) });
+		}), actionButton("delete_sweep", labels.clearOutput, () => {
+			notebookOptions(this.view.state)?.onClearOutput?.(index);
+			this.view.dispatch({ effects: notebookRefreshEffect.of(null) });
+		}), actionButton("delete", labels.remove, () => deleteCellAt(this.view, index)));
+		header.append(actions);
+		header.addEventListener("mousedown", (event) => {
+			if (event.target?.closest("button")) return;
+			event.preventDefault();
+			focusCell(this.view, index);
+		});
+		return header;
+	}
+	get estimatedHeight() {
+		return 24;
+	}
+};
+var NotebookOutputWidget = class extends WidgetType {
+	view;
+	fileId;
+	typstState;
+	args;
+	openExternal;
+	constructor(view, fileId, typstState, args, openExternal) {
+		super();
+		this.view = view;
+		this.fileId = fileId;
+		this.typstState = typstState;
+		this.args = args;
+		this.openExternal = openExternal;
+	}
+	/** Hash of everything the DOM depends on; DOM identity is expensive. */
+	get key() {
+		const frames = this.args.frames.map((frame) => {
+			const size = frameSize(frame);
+			return `${frame.render.hash}:${Math.round(size.width)}x${Math.round(size.height)}`;
+		}).join(",");
+		const diagnostics = this.args.diagnostics.map((diagnostic) => diagnostic.message).join("|");
+		return `${this.args.index}:${this.args.cleared}:${this.args.hasRun}:${frames}:${diagnostics}`;
+	}
+	eq(other) {
+		return this.key === other.key;
+	}
+	toDOM() {
+		const root = document.createElement("div");
+		const { cleared, labels } = this.args;
+		root.className = "tb-cell-output";
+		if (cleared) {
+			root.classList.add("tb-cell-output--cleared");
+			return root;
+		}
+		if (!(this.args.frames.length > 0 || this.args.diagnostics.length > 0 || this.args.hasRun)) {
+			root.classList.add("tb-cell-output--empty");
+			return root;
+		}
+		const body = document.createElement("div");
+		body.className = "tb-cell-output-body";
+		for (const diagnostic of this.args.diagnostics) {
+			const item = document.createElement("div");
+			item.className = `tb-cell-diagnostic tb-cell-diagnostic--${diagnostic.severity}`;
+			item.textContent = diagnostic.message;
+			if (diagnostic.hints.length) {
+				const hints = document.createElement("ul");
+				for (const hint of diagnostic.hints) {
+					const entry = document.createElement("li");
+					entry.textContent = hint;
+					hints.append(entry);
+				}
+				item.append(hints);
+			}
+			body.append(item);
+		}
+		for (const frame of this.args.frames) {
+			const holder = document.createElement("div");
+			holder.className = "tb-cell-frame";
+			const container = createFrameContainer(frame);
+			attachFrameInteractions(container, this.view, frame, this.fileId, this.typstState, this.openExternal);
+			holder.append(container);
+			body.append(holder);
+		}
+		if (!this.args.frames.length && !this.args.diagnostics.length && this.args.hasRun) {
+			const empty = document.createElement("div");
+			empty.className = "tb-cell-empty";
+			empty.textContent = labels.noOutput;
+			body.append(empty);
+		}
+		root.append(body);
+		return root;
+	}
+	get estimatedHeight() {
+		let height = 0;
+		for (const frame of this.args.frames) height += frameSize(frame).height;
+		return height + 16;
+	}
+};
+function decorateNotebook(args) {
+	const { view, state, cells, frames, diagnostics, fileId, typstState, locked, onExternalLink, options } = args;
+	const decorations = [];
+	const byCell = cells.map(() => []);
+	for (const frame of frames) {
+		const index = cellIndexAt(cells, frame.range.start);
+		if (index >= 0) byCell[index].push(frame);
+	}
+	const counter = options.counters?.() ?? false;
+	cells.forEach((cell, index) => {
+		const cellState = options.state?.(index) ?? {};
+		const headerPos = state.doc.lineAt(cellStart(cell)).from;
+		decorations.push(Decoration.widget({
+			widget: new NotebookHeaderWidget(view, {
+				index,
+				kind: cell.kind,
+				counter,
+				count: cellState.count,
+				collapsed: cellState.collapsed ?? false,
+				labels: options.labels ?? FALLBACK_LABELS
+			}),
+			side: -1
+		}).range(headerPos));
+		if (hasMarker(cell)) decorations.push(Decoration.line({ class: "tb-cell-marker" }).range(state.doc.lineAt(cell.marker_start).from));
+		if (cellState.collapsed && cell.content_end > cell.content_start) decorations.push(Decoration.replace({}).range(cell.content_start, cell.content_end));
+		if (cell.kind === "markup") {
+			if (cellState.collapsed) return;
+			for (const frame of byCell[index] ?? []) {
+				const { start, end } = frame.range;
+				if (!frame.render || end <= start) continue;
+				if (frameIsInactive(view, state, start, end)) decorations.push(Decoration.replace({ widget: new TypstWidget(view, frame, locked, fileId, typstState, onExternalLink) }).range(start, end));
+				else decorations.push(...frameActiveDecorations(view, state, frame));
+			}
+			return;
+		}
+		const outputPos = cell.content_end > cell.content_start ? state.doc.lineAt(cell.content_end).to : cell.content_start;
+		const cellDiagnostics = diagnostics.filter((diagnostic) => diagnostic.range.start >= cell.content_start && diagnostic.range.start <= cell.content_end);
+		decorations.push(Decoration.widget({
+			widget: new NotebookOutputWidget(view, fileId, typstState, {
+				index,
+				frames: byCell[index] ?? [],
+				diagnostics: cellDiagnostics,
+				cleared: cellState.cleared ?? false,
+				hasRun: cellState.count !== void 0,
+				labels: options.labels ?? FALLBACK_LABELS
+			}, onExternalLink),
+			block: true,
+			side: 1
+		}).range(outputPos));
+	});
+	return decorations;
+}
+//#endregion
+//#region src/widgets.ts
+const compileCache = new LRUCache({ max: 8 });
+const updateFlagStore = /* @__PURE__ */ new Set();
+/**
+* Dispatch this to recompile even when the document did not change. Used when
+* app data changed (fonts installed, workspace data, query results).
+*/
+const typstRecompileEffect = StateEffect.define({});
+/** Compile cache keys include the wasm revision so new fonts re-render. */
+function compileCacheKey(path, typstState, revision) {
+	return `${path}:${typstState.revision()}:${revision?.() ?? ""}`;
+}
+const SCROLLBAR_ALLOWANCE = 12;
+function editorRenderWidth(scrollDOM, contentDOM) {
+	const pane = scrollDOM.getBoundingClientRect();
+	const gutters = scrollDOM.querySelector(".cm-gutters");
+	const style = getComputedStyle(contentDOM);
+	return Math.max(0, pane.width - (gutters?.getBoundingClientRect().width ?? 0) - parseFloat(style.paddingLeft) - parseFloat(style.paddingRight) - SCROLLBAR_ALLOWANCE);
+}
+const tooltipsStateEffect = StateEffect.define();
+const tooltipsStateField = StateField.define({
+	create() {
+		return [];
+	},
+	update(frames, transaction) {
+		const effect = transaction.effects.find((e) => e.is(tooltipsStateEffect));
+		return effect ? effect.value : frames;
+	}
+});
+/**
+* Builds the decoration set for a compile result: rendered blocks become
+* replace widgets, the block the cursor is in shows its source and stretches
+* its last line to the render's height. Returns the frames that show source,
+* for the remeasure pass.
+*/
+function buildDecorations$1({ state, view, frames, locked, fileId, typstState, openExternal, lineHeights }) {
+	const decorations = [];
+	const active = [];
+	for (const frame of frames) {
+		const { start, end } = frame.range;
+		if (!frame.render) continue;
+		if (frameIsInactive(view, state, start, end)) {
+			const widget = new TypstWidget(view, frame, locked, fileId, typstState, openExternal);
+			decorations.push(Decoration.replace({ widget }).range(start, end));
+			continue;
+		}
+		active.push(frame);
+		decorations.push(...frameActiveDecorations(view, state, frame, lineHeights));
+	}
+	return {
+		decorations: Decoration.set(decorations, true),
+		active
+	};
+}
+/**
+* Source line heights for the blocks whose widgets were just removed. Runs
+* inside the view's measure pass, after the source lines are in the DOM, so
+* the heights are the text's and not the widget's.
+*/
+function measureLineHeights(view, frames) {
+	const heights = /* @__PURE__ */ new Map();
+	const { state } = view;
+	for (const frame of frames) {
+		const { number: startLine } = state.doc.lineAt(frame.range.start);
+		const { number: endLine } = state.doc.lineAt(frame.range.end);
+		for (let currentLine = startLine; currentLine <= endLine; currentLine++) {
+			const line = state.doc.line(currentLine);
+			if (!heights.has(line.from)) heights.set(line.from, view.lineBlockAt(line.from).height);
+		}
+	}
+	return heights;
+}
+function decorate({ fileId, spaceId, path, prelude, locked, update, updateInWidget: _updateInWidget, widthChanged, forced, typstState, revision, onRequests, onPanic, onCompile, onExternalLink, notebook }) {
+	const text = update.state.doc.toString();
+	const isFlaggedForUpdate = updateFlagStore.has(path);
+	const cacheKey = compileCacheKey(path, typstState, revision);
+	let frames;
+	let tooltips;
+	let diagnostics;
+	if (forced || update.docChanged || widthChanged || !compileCache.has(cacheKey)) {
+		if (isFlaggedForUpdate) updateFlagStore.delete(path);
+		else updateFlagStore.add(path);
+		let compileResult;
+		try {
+			compileResult = typstState.compilePaged(fileId, text, prelude);
+		} catch (error) {
+			console.error("[typst] compile panicked:", error);
+			onPanic?.(fileId);
+			return {
+				decorations: Decoration.none,
+				tooltips: [],
+				frames: [],
+				active: []
+			};
+		}
+		dispatchDiagnostics(compileResult.diagnostics, update.state, update.view);
+		rememberDiagnostics(path, text, compileResult.diagnostics);
+		onCompile?.();
+		if (compileResult.requests.length > 0 && onRequests) Promise.resolve(onRequests(compileResult.requests, spaceId)).then((wasUpdated) => {
+			if (wasUpdated) {
+				const doc = update.view.state.doc.toString();
+				update.view.dispatch({
+					changes: {
+						from: 0,
+						to: doc.length,
+						insert: doc
+					},
+					effects: typstRecompileEffect.of(null)
+				});
+			}
+		});
+		({frames, tooltips} = compileResult);
+		diagnostics = compileResult.diagnostics;
+		compileCache.set(cacheKey, {
+			frames,
+			tooltips,
+			diagnostics
+		});
+		notebook?.onCompile?.({
+			text,
+			frames,
+			diagnostics
+		});
+	} else {
+		const cached = compileCache.get(cacheKey);
+		({frames, tooltips, diagnostics} = cached);
+	}
+	const { view, state } = update;
+	if (notebook) {
+		let cells;
+		try {
+			cells = notebook.cells(text);
+		} catch (error) {
+			console.error("[typst] cell extraction panicked:", error);
+			onPanic?.(fileId);
+			return {
+				decorations: Decoration.none,
+				tooltips: [],
+				frames: [],
+				active: []
+			};
+		}
+		notebook.onCells?.(cells);
+		notebook.onActiveCell?.(cells.length ? cellIndexAt(cells, state.selection.main.head) : null);
+		return {
+			decorations: Decoration.set(decorateNotebook({
+				view,
+				state,
+				cells,
+				frames,
+				diagnostics,
+				fileId,
+				typstState,
+				locked,
+				onExternalLink,
+				options: notebook
+			}), true),
+			tooltips,
+			frames,
+			active: []
+		};
+	}
+	const built = buildDecorations$1({
+		state,
+		view,
+		frames,
+		locked,
+		fileId,
+		typstState,
+		openExternal: onExternalLink
+	});
+	return {
+		decorations: built.decorations,
+		tooltips,
+		frames,
+		active: built.active
+	};
+}
+const typstStateEffect = StateEffect.define({});
+const typstStateField = StateField.define({
+	create() {
+		return Decoration.none;
+	},
+	update(decorations, transaction) {
+		const effect = transaction.effects.find((e) => e.is(typstStateEffect));
+		if (effect) return effect.value.decorations;
+		return decorations.map(transaction.changes);
+	},
+	provide: (field) => [EditorView.decorations.from(field)]
+});
+const typstViewPlugin = (fileId, spaceId, path, text, prelude, locked, typstState, options = {}) => ViewPlugin.define((_view) => {
+	let firstUpdate = true;
+	let resizeTimer;
+	const remeasureKey = {};
+	/**
+	* A pass that shows a block's source runs while the block's widget is still
+	* mounted, so the view reports the widget's height for those lines and the
+	* min-height that should keep the render's height comes out as zero. Once
+	* the source lines are in the DOM and measured, rebuild the active
+	* decorations with the real text heights. The measure pass runs before
+	* paint, so the rebuild is not visible.
+	*/
+	const remeasureActive = (update, result) => {
+		if (result.active.length === 0) return;
+		const { view, state } = update;
+		const focused = view.hasFocus;
+		const stale = () => view.state.doc !== state.doc || !view.state.selection.eq(state.selection) || view.hasFocus !== focused;
+		view.requestMeasure({
+			key: remeasureKey,
+			read: (readView) => stale() ? null : measureLineHeights(readView, result.active),
+			write: (heights) => {
+				if (!heights) return;
+				queueMicrotask(() => {
+					if (stale()) return;
+					const rebuilt = buildDecorations$1({
+						state: view.state,
+						view,
+						frames: result.frames,
+						locked,
+						fileId,
+						typstState,
+						openExternal: options.onExternalLink,
+						lineHeights: heights
+					});
+					view.dispatch({ effects: typstStateEffect.of({ decorations: rebuilt.decorations }) });
+				});
+			}
+		});
+	};
+	return {
+		update(update) {
+			let widthChanged = false;
+			const effects = update.transactions.flatMap((transaction) => transaction.effects);
+			const run = effects.find((effect) => effect.is(notebookRunEffect));
+			const refresh = effects.some((effect) => effect.is(notebookRefreshEffect));
+			const forced = firstUpdate || update.transactions.some((transaction) => transaction.effects.some((effect) => effect.is(typstRecompileEffect)));
+			firstUpdate = false;
+			if (run) options.notebook?.onRun?.(run.value.index);
+			if (update.geometryChanged) {
+				const { scrollDOM, contentDOM } = update.view;
+				try {
+					widthChanged = typstState.resize(fileId, editorRenderWidth(scrollDOM, contentDOM), locked ? scrollDOM.clientHeight : void 0);
+				} catch (error) {
+					console.error("[typst] resize panicked:", error);
+					options.onPanic?.(fileId);
+					return;
+				}
+			}
+			if (widthChanged) {
+				clearTimeout(resizeTimer);
+				resizeTimer = window.setTimeout(() => {
+					update.view.dispatch({ effects: typstRecompileEffect.of(null) });
+				}, 150);
+			}
+			if (update.docChanged || update.selectionSet || update.focusChanged || forced || run || refresh) {
+				queueMicrotask(() => {
+					let result;
+					try {
+						result = decorate({
+							fileId,
+							spaceId,
+							path,
+							prelude: prelude.value,
+							locked,
+							update,
+							updateInWidget: false,
+							widthChanged,
+							forced: forced || Boolean(run),
+							typstState,
+							revision: options.revision,
+							onRequests: options.onRequests,
+							onPanic: options.onPanic,
+							onCompile: options.onCompile,
+							onExternalLink: options.onExternalLink,
+							notebook: options.notebook
+						});
+					} catch (error) {
+						console.error("[typst] decorate panicked:", error);
+						options.onPanic?.(fileId);
+						return;
+					}
+					if (result) {
+						const stateEffects = [typstStateEffect.of({ decorations: result.decorations }), tooltipsStateEffect.of(result.tooltips)];
+						update.view.dispatch({ effects: stateEffects });
+						remeasureActive(update, result);
+					}
+				});
+				if (update.docChanged) text.value = update.state.doc.toString();
+			}
+		},
+		destroy() {
+			clearTimeout(resizeTimer);
+		}
+	};
+});
+function dispatchDiagnostics(typstDiagnostics, state, view) {
+	view.dispatch(setDiagnostics(state, toLintDiagnostics(typstDiagnostics)));
+}
+//#endregion
+//#region src/tooltip.ts
+const tooltipStateEffect = StateEffect.define();
+const tooltipStateField = StateField.define({
+	create() {
+		return null;
+	},
+	update(tooltip, transaction) {
+		const effect = transaction.effects.find((e) => e.is(tooltipStateEffect));
+		if (effect) return effect.value;
+		return tooltip;
+	},
+	provide: (field) => showTooltip.from(field)
+});
+const tooltipViewPlugin = () => ViewPlugin.define((view) => ({ update(update) {
+	if (!update.selectionSet && !update.docChanged && !update.focusChanged) return;
+	queueMicrotask(() => {
+		if (!view.hasFocus) {
+			view.dispatch({ effects: tooltipStateEffect.of(null) });
+			return;
+		}
+		const state = view.state;
+		const pos = state.selection.main.from;
+		const tooltips = state.field(tooltipsStateField);
+		let tooltip = null;
+		for (const { render, range } of tooltips) {
+			const { start, end } = range;
+			if (pos >= start && pos <= end && render) {
+				const container = document.createElement("div");
+				container.classList.add("typst-popup-render");
+				const svg = document.createElement("div");
+				svg.style.width = render.width + "px";
+				svg.style.height = render.height + "px";
+				svg.style.transform = `translateX(-${render.xOffset}px)`;
+				svg.setHTMLUnsafe(render.svg);
+				container.append(svg);
+				tooltip = {
+					pos: start + 1,
+					end: end - 1,
+					create(tooltipView) {
+						return {
+							dom: container,
+							getCoords(_pos) {
+								const startCoords = tooltipView.coordsAtPos(start);
+								const endCoords = tooltipView.coordsAtPos(end);
+								return {
+									left: startCoords.left,
+									right: startCoords.right,
+									top: endCoords.top,
+									bottom: endCoords.bottom
+								};
+							}
+						};
+					}
+				};
+				break;
+			}
+		}
+		view.dispatch({ effects: tooltipStateEffect.of(tooltip) });
+	});
+} }));
+//#endregion
+//#region src/plugin.ts
+const typstPlugin = (fileId, spaceId, path, text, prelude, locked, typstState, options = {}) => {
+	const extensions = [
+		typstStateField,
+		tooltipsStateField,
+		typstViewPlugin(fileId, spaceId, path, text, prelude, locked, typstState, options),
+		tooltipViewPlugin(),
+		tooltipStateField,
+		autocompletion({ override: [(context) => autocomplete(context, fileId, typstState)] }),
+		typstKeymap,
+		typstLanguageData,
+		typstSyntaxHighlighting(fileId, typstState),
+		typstHoverTooltip(fileId, typstState),
+		addSpaceBeforeClosingBracket,
+		indentService.of((ctx, pos) => {
+			const last = Math.max(0, pos - 1);
+			const prev = ctx.lineAt(last).text;
+			if (prev.endsWith("$") && prev !== "$") return 0;
+			const indent = /[{[($]\s*$/.test(prev);
+			return ctx.lineIndent(last) + (indent ? ctx.unit : 0);
+		})
+	];
+	if (options.notebook) extensions.push(notebookOptionsFacet.of(options.notebook), notebookKeymap);
+	return extensions;
+};
+const addSpaceBeforeClosingBracket = EditorView.inputHandler.of((view, from, to, text) => {
+	if (text === " ") {
+		const { state } = view;
+		const pos = from;
+		const bracketPairs = {
+			"(": ")",
+			"[": "]",
+			"{": "}",
+			$: "$"
+		};
+		const before = state.doc.sliceString(pos - 1, pos);
+		const after = state.doc.sliceString(pos, pos + 1);
+		if (bracketPairs[before] && after === bracketPairs[before]) view.dispatch({
+			changes: {
+				from: pos,
+				to: pos,
+				insert: " "
+			},
+			selection: { anchor: pos + 1 }
+		});
+	}
+	return false;
+});
+//#endregion
+//#region src/static-highlight.ts
+const KEYWORDS = /* @__PURE__ */ new Set([
+	"and",
+	"as",
+	"auto",
+	"break",
+	"context",
+	"continue",
+	"else",
+	"false",
+	"for",
+	"if",
+	"import",
+	"in",
+	"include",
+	"let",
+	"none",
+	"not",
+	"or",
+	"return",
+	"set",
+	"show",
+	"true",
+	"while"
+]);
+const IDENT = /^[A-Za-z_][\w-]*/;
+/** Math identifiers cannot start with `_`, which is the attach operator. */
+const MATH_IDENT = /^[A-Za-z][A-Za-z0-9-]*/;
+function classForIdent(ident, rest) {
+	if (KEYWORDS.has(ident)) return "typ-key";
+	if (/^\s*[([{]/.test(rest)) return "typ-func";
+	return "typ-pol";
+}
+function runLength(text, from) {
+	let end = from;
+	while (end < text.length && text[end] === "`") end += 1;
+	return end - from;
+}
+/** Start of the first backtick run of at least `fence` at or after `from`. */
+function findFence(text, fence, from) {
+	let index = text.indexOf("`", from);
+	while (index >= 0) {
+		const run = runLength(text, index);
+		if (run >= fence) return index;
+		index = text.indexOf("`", index + run);
+	}
+	return -1;
+}
+const typstStaticHighlighting = StateField.define({
+	create(state) {
+		return buildDecorations(state.doc);
+	},
+	update(decorations, transaction) {
+		if (transaction.docChanged) return buildDecorations(transaction.state.doc);
+		return decorations;
+	},
+	provide: (field) => EditorView.decorations.from(field)
+});
+function buildDecorations(doc) {
+	const builder = new RangeSetBuilder();
+	const state = {
+		mode: "markup",
+		mathReturn: "markup",
+		fence: 0,
+		depth: 0
+	};
+	const add = (from, to, cls) => {
+		if (to > from) builder.add(from, to, Decoration.mark({ class: cls }));
+	};
+	for (let lineNo = 1; lineNo <= doc.lines; lineNo++) {
+		const line = doc.line(lineNo);
+		scanLine(line.text, state, (from, to, cls) => add(line.from + from, line.from + to, cls));
+	}
+	return builder.finish();
+}
+function scanLine(line, state, emit) {
+	let i = 0;
+	if (state.mode === "comment") {
+		const close = line.indexOf("*/");
+		if (close < 0) {
+			emit(0, line.length, "typ-comment");
+			return;
+		}
+		emit(0, close + 2, "typ-comment");
+		state.mode = "markup";
+		i = close + 2;
+	} else if (state.mode === "raw") {
+		const close = findFence(line, state.fence, 0);
+		if (close < 0) {
+			emit(0, line.length, "typ-raw");
+			return;
+		}
+		const run = runLength(line, close);
+		emit(0, close + run, "typ-raw");
+		state.mode = "markup";
+		state.fence = 0;
+		i = close + run;
+	} else if (state.mode === "code" && state.depth === 0) state.mode = "markup";
+	if (state.mode === "markup" && i === 0) i = markupLineStart(line, emit);
+	while (i < line.length) if (state.mode === "markup") i = markupToken(line, i, state, emit);
+	else if (state.mode === "code") i = codeToken(line, i, state, emit);
+	else i = mathToken(line, i, state, emit);
+	if (state.mode === "code" && state.depth === 0) state.mode = "markup";
+}
+/** Headings, list markers, and term text, which only count at line start. */
+function markupLineStart(line, emit) {
+	const indent = /^\s*/.exec(line)?.[0].length ?? 0;
+	const rest = line.slice(indent);
+	const heading = /^(=+)(\s|$)/.exec(rest);
+	if (heading) {
+		const level = Math.min(heading[1].length, 6);
+		emit(indent, line.length, `typ-heading typ-heading-level-${level}`);
+		return line.length;
+	}
+	const marker = /^([-+/]|\d+\.)(\s|$)/.exec(rest);
+	if (marker) {
+		const end = indent + marker[1].length;
+		emit(indent, end, "typ-marker");
+		if (marker[1] === "/") {
+			const colon = line.indexOf(":", end + 1);
+			if (colon > 0) {
+				emit(end + 1, colon, "typ-term");
+				return colon + 1;
+			}
+		}
+		return end;
+	}
+	return indent;
+}
+function markupToken(line, i, state, emit) {
+	const rest = line.slice(i);
+	const ch = line[i];
+	if (rest.startsWith("//")) {
+		emit(i, line.length, "typ-comment");
+		return line.length;
+	}
+	if (rest.startsWith("/*")) {
+		const close = line.indexOf("*/", i + 2);
+		if (close < 0) {
+			emit(i, line.length, "typ-comment");
+			state.mode = "comment";
+			return line.length;
+		}
+		emit(i, close + 2, "typ-comment");
+		return close + 2;
+	}
+	if (ch === "`") {
+		const run = runLength(line, i);
+		const close = findFence(line, run, i + run);
+		if (close < 0) {
+			emit(i + run, line.length, "typ-raw");
+			if (run >= 3) {
+				state.mode = "raw";
+				state.fence = run;
+			}
+			return line.length;
+		}
+		emit(i + run, close, "typ-raw");
+		return close + runLength(line, close);
+	}
+	if (ch === "$") {
+		emit(i, i + 1, "typ-math-delim");
+		state.mode = "math";
+		state.mathReturn = "markup";
+		return i + 1;
+	}
+	if (ch === "#") {
+		const ident = IDENT.exec(line.slice(i + 1));
+		if (ident) {
+			const end = i + 1 + ident[0].length;
+			emit(i, end, classForIdent(ident[0], line.slice(end)));
+			if (KEYWORDS.has(ident[0])) {
+				state.mode = "code";
+				state.depth = 0;
+			}
+			return end;
+		}
+		emit(i, i + 1, "typ-punct");
+		return i + 1;
+	}
+	if (ch === "<") {
+		const label = /^<[A-Za-z_][\w:.-]*>/.exec(rest);
+		if (label) {
+			emit(i, i + label[0].length, "typ-label");
+			return i + label[0].length;
+		}
+	}
+	if (ch === "@") {
+		const ref = /^@[\w:.-]+/.exec(rest);
+		if (ref) {
+			emit(i, i + ref[0].length, "typ-ref");
+			return i + ref[0].length;
+		}
+	}
+	if (ch === "\\") {
+		emit(i, Math.min(i + 2, line.length), "typ-escape");
+		return i + 2;
+	}
+	if (ch === "*" || ch === "_") {
+		const before = i === 0 ? "" : line[i - 1];
+		const close = line.indexOf(ch, i + 1);
+		const after = close < 0 ? "" : line[close + 1] ?? "";
+		if (close > i + 1 && !/\w/.test(before) && !/\s/.test(line[i + 1]) && !/\s/.test(line[close - 1]) && !/\w/.test(after)) {
+			emit(i, close + 1, ch === "*" ? "typ-strong" : "typ-emph");
+			return close + 1;
+		}
+	}
+	const link = /^(https?:\/\/|www\.)\S+/.exec(rest);
+	if (link) {
+		emit(i, i + link[0].length, "typ-link");
+		return i + link[0].length;
+	}
+	return i + 1;
+}
+function codeToken(line, i, state, emit) {
+	const rest = line.slice(i);
+	const ch = line[i];
+	if (rest.startsWith("//")) {
+		emit(i, line.length, "typ-comment");
+		return line.length;
+	}
+	if (rest.startsWith("/*")) {
+		const close = line.indexOf("*/", i + 2);
+		if (close < 0) {
+			emit(i, line.length, "typ-comment");
+			state.mode = "comment";
+			return line.length;
+		}
+		emit(i, close + 2, "typ-comment");
+		return close + 2;
+	}
+	if (ch === "\"") {
+		const end = stringEnd(line, i);
+		emit(i, end, "typ-str");
+		return end;
+	}
+	if (ch === "$") {
+		emit(i, i + 1, "typ-math-delim");
+		state.mode = "math";
+		state.mathReturn = "code";
+		return i + 1;
+	}
+	if (/[0-9]/.test(ch)) {
+		const number = /^[0-9][\w.]*/.exec(rest);
+		emit(i, i + number[0].length, "typ-num");
+		return i + number[0].length;
+	}
+	if (/[A-Za-z_]/.test(ch)) {
+		const ident = IDENT.exec(rest);
+		emit(i, i + ident[0].length, classForIdent(ident[0], line.slice(i + ident[0].length)));
+		return i + ident[0].length;
+	}
+	if ("([{".includes(ch)) {
+		state.depth += 1;
+		emit(i, i + 1, "typ-punct");
+		return i + 1;
+	}
+	if (")]}".includes(ch)) {
+		state.depth = Math.max(0, state.depth - 1);
+		emit(i, i + 1, "typ-punct");
+		return i + 1;
+	}
+	if (".,;:".includes(ch)) {
+		emit(i, i + 1, "typ-punct");
+		return i + 1;
+	}
+	const operator = /^(==|!=|<=|>=|=>|\.\.\.|\.\.|[+\-*/=!<>&|])/.exec(rest);
+	if (operator) {
+		emit(i, i + operator[0].length, "typ-op");
+		return i + operator[0].length;
+	}
+	return i + 1;
+}
+function mathToken(line, i, state, emit) {
+	const rest = line.slice(i);
+	const ch = line[i];
+	if (ch === "$") {
+		emit(i, i + 1, "typ-math-delim");
+		state.mode = state.mathReturn;
+		return i + 1;
+	}
+	if (ch === "\"") {
+		const end = stringEnd(line, i);
+		emit(i, end, "typ-str");
+		return end;
+	}
+	if (/[0-9]/.test(ch)) {
+		const number = /^[0-9][\w.]*/.exec(rest);
+		emit(i, i + number[0].length, "typ-num");
+		return i + number[0].length;
+	}
+	if (/[A-Za-z_]/.test(ch)) {
+		const ident = MATH_IDENT.exec(rest);
+		if (ident) {
+			emit(i, i + ident[0].length, classForIdent(ident[0], line.slice(i + ident[0].length)));
+			return i + ident[0].length;
+		}
+	}
+	if (ch === "(" || ch === ")") {
+		emit(i, i + 1, "typ-math-group");
+		return i + 1;
+	}
+	if ("[]{}.,;:".includes(ch)) {
+		emit(i, i + 1, "typ-punct");
+		return i + 1;
+	}
+	if ("^_&/".includes(ch)) {
+		emit(i, i + 1, "typ-math-op");
+		return i + 1;
+	}
+	if ("+-*=<>.!|".includes(ch)) {
+		emit(i, i + 1, "typ-op");
+		return i + 1;
+	}
+	return i + 1;
+}
+/** End of a string literal starting at `from`, or the line end. */
+function stringEnd(line, from) {
+	let index = from + 1;
+	while (index < line.length) {
+		if (line[index] === "\\") {
+			index += 2;
+			continue;
+		}
+		if (line[index] === "\"") return index + 1;
+		index += 1;
+	}
+	return line.length;
+}
+//#endregion
+export { TypstWidget, attachFrameInteractions, autocomplete, cellIndexAt, cellStart, cellsOf, compileCache, createFrameContainer, cursorAddVertical, cycleHeading, deleteCell, deleteCellAt, deleteCellText, duplicateCell, duplicateCellAt, duplicateCellText, focusCell, frameActiveDecorations, frameIsInactive, frameSize, hasMarker, insertAtCursor, insertCell, insertCellAt, insertCellText, insertFontFamily, insertTabLike, markerText, mergeCell, mergeCellText, moveCell, moveCellAt, moveCellText, notebookKeymap, notebookOptions, notebookOptionsFacet, notebookRefreshEffect, notebookRunEffect, parseBackticks, rememberDiagnostics, runAllCells, runCell, setCellType, setCellTypeText, splitCell, splitCellText, stripCellMarkers, syncFrameContainer, toLintDiagnostics, toggleAroundSelection, toggleCellType, toggleCode, toggleEmph, toggleEnum, toggleList, toggleListLike, toggleMath, toggleStrike, toggleStrong, toggleUnderline, tooltipStateField, tooltipViewPlugin, tooltipsStateEffect, tooltipsStateField, typstHoverTooltip, typstKeymap, typstLanguageData, typstLinter, typstPlugin, typstRecompileEffect, typstStateField, typstStaticHighlighting, typstSyntaxHighlighting, typstViewPlugin, wrapOrInsert };