@aicayzer/inkkit 0.6.1 → 0.7.0

package/dist/chunks/{core-CbHV2KPY.js → core-B7CD5hsd.js}

@@ -28448,6 +28448,7 @@ var editorErrorCodes = [
 	"invalid-range",
 	"preservation",
 	"image-unavailable",
+	"image-unsupported",
 	"diagram-unavailable",
 	"file-unavailable",
 	"clipboard-unavailable",
@@ -33178,6 +33179,13 @@ A command function that redoes the last undone change, if any.
 */
 var redo = buildCommand(true, true);
 /**
+The amount of undoable events available in a given state.
+*/
+function undoDepth(state) {
+	let hist = historyKey.getState(state);
+	return hist ? hist.done.eventCount : 0;
+}
+/**
 The amount of redoable events available in a given editor state.
 */
 function redoDepth(state) {
@@ -40553,7 +40561,7 @@ function parseLinkedSyntax(raw, inTable = false) {
 	let section = "target", hasFragment = false, hasAlias = false;
 	for (let index = 0; index < content.length; index++) {
 		const character = content[index];
-		if (character === "\\") {
+		if (character === "\\" && embed) {
 			const escaped = content[++index];
 			if (!escaped || !"[]|#\\".includes(escaped)) return void 0;
 			parts[section] += escaped;
@@ -40604,7 +40612,7 @@ function linkedTokenizer(embed) {
 		function body(code) {
 			if (code === null || code < 32 && code !== -2 && code !== -1 && code !== 9 || code === 91) return nok(code);
 			consume(code);
-			if (code === 92) return escaped;
+			if (code === 92 && embed) return escaped;
 			return code === 93 ? closing : body;
 		}
 		function escaped(code) {
@@ -40621,6 +40629,39 @@ function linkedTokenizer(embed) {
 		}
 	};
 }
+/**
+* Looks ahead from a backslash for a wiki link that starts right after it. CommonMark reads `\[`
+* as an escaped bracket, which would hide the link, but a backslash before a wiki link is only
+* text, as it is inside one.
+*/
+var backslashBeforeWikiLink = {
+	name: "inkkitWikiBackslash",
+	tokenize(effects, ok, nok) {
+		return function start(code) {
+			if (code !== 92) return nok(code);
+			return effects.check(wikiLinkAhead, literal, nok)(code);
+		};
+		function literal(code) {
+			effects.enter("data");
+			effects.consume(code);
+			effects.exit("data");
+			return ok;
+		}
+	}
+};
+var wikiLinkAhead = {
+	partial: true,
+	tokenize(effects, ok, nok) {
+		const link = linkedTokenizer(false).call(this, effects, ok, nok);
+		return function start(code) {
+			if (code !== 92) return nok(code);
+			effects.enter("data");
+			effects.consume(code);
+			effects.exit("data");
+			return link;
+		};
+	}
+};
 function tableForm(raw, authoredInTable, outputInTable) {
 	if (authoredInTable === outputInTable) return raw;
 	return outputInTable ? toTable(raw) : fromTable(raw);
@@ -40872,14 +40913,14 @@ var referenceTableContext = $prose(() => new Plugin({
 * brackets, is never changed, and that includes the run of every rule when a
 * composition ends.
 */
-var wikiLinkInputRule = $inputRule(() => new InputRule(/\[\[(?:\\.|[^[\]\\\ufffc])*\]\]$/, (state, match, start, end) => {
+var wikiLinkInputRule = $inputRule(() => new InputRule(/\[\[[^[\]\ufffc]*\]\]$/, (state, match, start, end) => {
 	const { schema, doc } = state;
 	const type = schema.nodes.inkkit_wiki_link;
 	const caret = state.selection.from;
 	if (start + match[0].length - 1 !== caret && !(start + match[0].length === caret && composed.getState(state)?.closing === caret)) return null;
 	const $start = doc.resolve(start);
 	const parent = $start.parent;
-	if (!type || !parent.inlineContent || !parent.canReplaceWith($start.index(), $start.index(), type) || /[!\\[]/.test(doc.textBetween(Math.max($start.start(), start - 1), start))) return null;
+	if (!type || !parent.inlineContent || !parent.canReplaceWith($start.index(), $start.index(), type) || /[![]/.test(doc.textBetween(Math.max($start.start(), start - 1), start))) return null;
 	let marks;
 	let plain = true;
 	doc.nodesBetween(start, end, (node) => {
@@ -40908,6 +40949,7 @@ function linkedSyntax(wikiLinks, files) {
 		tokenize: linkedTokenizer(false),
 		previous: (code) => code !== 33 && code !== 91
 	};
+	if (wikiLinks) syntax.text[92] = backslashBeforeWikiLink;
 	if (files) syntax.text[33] = {
 		name: "inkkitNamedFile",
 		tokenize: linkedTokenizer(true)
@@ -40967,7 +41009,7 @@ function linkedSyntax(wikiLinks, files) {
 //#endregion
 //#region src/wiki-suggestions.ts
 function rawName(name) {
-	return `[[${name.replace(/[\\[\]|#]/g, "\\$&")}]]`;
+	return `[[${name}]]`;
 }
 function validName(value) {
 	if (typeof value !== "string") return false;
@@ -46968,12 +47010,29 @@ function caretState(state) {
 		const type = state.schema.marks[name];
 		if (type && state.doc.rangeHasMark($from.pos, $to.pos, type)) active.add(mark);
 	}
+	const href = active.has("link") ? linkAddress(state, marks) : void 0;
 	return {
 		marks: [...active],
 		block: blockAt($from.parent, $from),
-		quoted: quoted($from, $to)
+		quoted: quoted($from, $to),
+		...href != null ? { href } : {}
 	};
 }
+/** The address of the first link at the caret, or in the selection, in document order. */
+function linkAddress(state, caretMarks) {
+	const type = state.schema.marks.link;
+	if (!type) return void 0;
+	const { empty } = state.selection;
+	if (empty) return type.isInSet(caretMarks)?.attrs.href;
+	const { $from, $to } = textBounds(state);
+	let href;
+	state.doc.nodesBetween($from.pos, $to.pos, (node) => {
+		if (href != null) return false;
+		href = type.isInSet(node.marks)?.attrs.href;
+		return true;
+	});
+	return href;
+}
 function terminalSelection(doc) {
 	const $end = doc.resolve(doc.content.size);
 	const gap = GapCursor;
@@ -53333,6 +53392,29 @@ var EditorDocument = class {
 //#region src/editor-history.ts
 var sourceGroupDelay = 500;
 var sourceStepLimit = 100;
+var isHistoryState = (value) => typeof value === "object" && value !== null && "done" in value && "undone" in value && typeof value.undone?.constructor?.empty === "object";
+/**
+* Empties the formatted document's redo stack and keeps every undo step. ProseMirror's history
+* clears the stack only when an edit lands, and offers no call for it, so this replaces the
+* plugin's state through the plugin's own transaction meta. It checks the result against
+* `undoDepth` and `redoDepth` before it changes anything, so a ProseMirror update that changes
+* the state's shape fails here, in `test/discard-undone.test.ts`, and not silently.
+*/
+function discardFormattedRedo(view) {
+	const { state } = view;
+	if (redoDepth(state) === 0) return;
+	const plugin = state.plugins.find((candidate) => /^history\$/.test(candidate.spec.key?.key ?? "") && isHistoryState(candidate.getState(state)));
+	const previous = plugin?.getState(state);
+	if (!plugin || !previous) throw new InkKitError("internal", "The undo history could not be found");
+	const historyState = Object.assign(Object.create(Object.getPrototypeOf(previous)), previous, { undone: previous.undone.constructor.empty });
+	const tr = state.tr.setMeta(plugin.spec.key, {
+		redo: false,
+		historyState
+	});
+	const next = state.apply(tr);
+	if (redoDepth(next) !== 0 || undoDepth(next) !== undoDepth(state)) throw new InkKitError("internal", "The redo steps could not be discarded");
+	view.dispatch(tr);
+}
 var SourceHistory = class {
 	runtime;
 	pendingSource;
@@ -53363,6 +53445,11 @@ var SourceHistory = class {
 		this.undoneSteps = [];
 		this.formattedUndone = 0;
 	}
+	/** Drops the redo steps of typed source, and the count of formatted ones that wait behind them. */
+	discardUndone() {
+		this.undoneSteps = [];
+		this.formattedUndone = 0;
+	}
 	canUndo(state) {
 		return !!this.pendingSource || undo(state);
 	}
@@ -57281,7 +57368,7 @@ async function createMilkdownEditor(root, options, runtime) {
 				return true;
 			}
 		}));
-	}).use(labelsCtx).use(linkSchemesCtx).use(formatInputCtx).use(richTextGuard).use(runtime.plugins.paste).use(visibleClipboard).use(runtime.plugins.suggestions).use(runtime.plugins.keymap).use(createDialect(Boolean(options.images || options.files), Boolean(options.wikiLinks), Boolean(options.files))).use(codeControlCtx).use(codeControlsPlugin(() => runtime.visibleRect())).use(tablePlugins).use(tableBlock).use(runtime.plugins.change).use(runtime.plugins.historyInput).use(history).use(clipboard).use(cursor).use(taskListPlugin((operation) => runtime.mutate(operation))).use(undoTypedRule).use(quoteBackspace).use(calloutEnter).use(literalEnter).use(literalReread).use(listItemBackspace).use(nestedItemEnter).use(rejoinLists).use(movedListItems).use(textInputPolicy).use(runtime.copy ? codeCopyPlugin((text) => runtime.copy?.(text)) : []).use(placeholderPlugin).use(options.rendering?.codeHighlighting === false ? [] : (await import("./highlight-C-9lbVMU.js")).highlightPlugin).use(options.rendering?.diagramPreview === false || !diagramsAvailable() ? [] : mermaidPreview(runtime.diagrams, (error) => runtime.report(error))).use(selectionPlugin).use($prose(() => search())).use(runtime.plugins.policy).use(options.wikiLinks ? wikiLinkView(options.wikiLinks, {
+	}).use(labelsCtx).use(linkSchemesCtx).use(formatInputCtx).use(richTextGuard).use(runtime.plugins.paste).use(visibleClipboard).use(runtime.plugins.suggestions).use(runtime.plugins.keymap).use(createDialect(Boolean(options.images || options.files), Boolean(options.wikiLinks), Boolean(options.files))).use(codeControlCtx).use(codeControlsPlugin(() => runtime.visibleRect())).use(tablePlugins).use(tableBlock).use(runtime.plugins.change).use(runtime.plugins.historyInput).use(history).use(clipboard).use(cursor).use(taskListPlugin((operation) => runtime.mutate(operation))).use(undoTypedRule).use(quoteBackspace).use(calloutEnter).use(literalEnter).use(literalReread).use(listItemBackspace).use(nestedItemEnter).use(rejoinLists).use(movedListItems).use(textInputPolicy).use(runtime.copy ? codeCopyPlugin((text) => runtime.copy?.(text)) : []).use(placeholderPlugin).use(options.rendering?.codeHighlighting === false ? [] : (await import("./highlight-B_juJyDH.js")).highlightPlugin).use(options.rendering?.diagramPreview === false || !diagramsAvailable() ? [] : mermaidPreview(runtime.diagrams, (error) => runtime.report(error))).use(selectionPlugin).use($prose(() => search())).use(runtime.plugins.policy).use(options.wikiLinks ? wikiLinkView(options.wikiLinks, {
 		capture: () => runtime.capture(),
 		active: () => runtime.active(),
 		labels: {
@@ -58840,6 +58927,11 @@ var PasteController = class {
 					},
 					drop: (view, event) => {
 						const data = event.dataTransfer;
+						if (!this.options.adapter && !this.options.files && !data?.getData("text/html") && view.editable && !view.dragging && imageFiles(data?.files ?? []).length) {
+							event.preventDefault();
+							options.onError?.(imagesRefused());
+							return true;
+						}
 						if (!data?.getData("text/html") || !view.editable || view.dragging) return false;
 						event.preventDefault();
 						const target = blockDropRange(view, event.clientX, event.clientY);
@@ -58848,7 +58940,7 @@ var PasteController = class {
 							text: data.getData("text/plain"),
 							html: data.getData("text/html"),
 							plainText: this.options.literalText?.() ?? false
-						}, [...data.files].filter((file) => file.type.startsWith("image/")), target).catch((error) => options.onError?.(error));
+						}, imageFiles(data.files), target).catch((error) => options.onError?.(error));
 						return true;
 					}
 				},
@@ -58875,7 +58967,7 @@ var PasteController = class {
 						}).catch((error) => options.onError?.(error));
 						return true;
 					}
-					const files = [...data.files].filter((file) => file.type.startsWith("image/"));
+					const files = imageFiles(data.files);
 					this.run({
 						text,
 						html,
@@ -58969,6 +59061,7 @@ var PasteController = class {
 		};
 		const rich = this.options.richText?.();
 		if (rich) {
+			if (!this.options.adapter && (files.length || input.images?.length)) throw imagesRefused();
 			const anchor = operation;
 			const state = view.state;
 			const slice = input.plainText ? rich.paste({ text: input.text }, state, this.options.linkSchemes ?? /* @__PURE__ */ new Set()) : rich.paste(input, state, this.options.linkSchemes ?? /* @__PURE__ */ new Set());
@@ -58991,6 +59084,12 @@ var PasteController = class {
 			this.assertContext(context, operation);
 			const schema = view.state.schema;
 			let slice;
+			const placeholders = [];
+			const placeholder = (name) => {
+				const text = `[${name}: image unavailable]`;
+				placeholders.push(text);
+				return text;
+			};
 			let source;
 			const plainText = input.plainText || this.options.literalText?.() || inCode();
 			if (!plainText && input.markdown == null && this.commit(() => pasteSpreadsheet(ctx, {
@@ -59032,8 +59131,8 @@ var PasteController = class {
 						element.removeAttribute("srcset");
 					} catch (error) {
 						if (error instanceof InkKitError && error.code !== "image-unavailable") throw error;
-						element.replaceWith(document.createTextNode(`[${alt}: image unavailable]`));
-						this.options.onError?.(coded(error, "image-unavailable", error instanceof Error ? error.message : "The pasted image is unavailable."));
+						element.replaceWith(document.createTextNode(placeholder(alt)));
+						if (this.options.adapter) this.options.onError?.(coded(error, "image-unavailable", error instanceof Error ? error.message : "The pasted image is unavailable."));
 					}
 				}
 				let imageIndex = 0;
@@ -59043,7 +59142,7 @@ var PasteController = class {
 						const position = slot ? Number(slot[1]) : imageIndex++;
 						const element = elements.some((element) => element.hasAttribute("data-inkkit-image-slot")) ? elements.find((element) => Number(element.getAttribute("data-inkkit-authored-image-slot") ?? element.getAttribute("data-inkkit-image-slot")) === position) : elements[position];
 						if (!element || !container.contains(element)) {
-							const text = schema.text(`[${node.attrs.alt || "Image"}: image unavailable]`);
+							const text = schema.text(placeholder(node.attrs.alt || "Image"));
 							return node.isBlock ? schema.nodes.paragraph.create(null, text) : text;
 						}
 						return node.type.create({
@@ -59072,6 +59171,7 @@ var PasteController = class {
 					}
 				}
 			} else if (images.length) {
+				if (!this.options.adapter) throw imagesRefused();
 				const nodes = [];
 				if (input.text) nodes.push(schema.nodes.paragraph.create(null, schema.text(input.text)));
 				for (const image of images) try {
@@ -59086,7 +59186,7 @@ var PasteController = class {
 					nodes.push(schema.nodes.paragraph.create(null, imageNode));
 				} catch (error) {
 					if (error instanceof InkKitError && error.code !== "image-unavailable") throw error;
-					nodes.push(schema.nodes.paragraph.create(null, schema.text(`[${image.filename ?? "Image"}: image unavailable]`)));
+					nodes.push(schema.nodes.paragraph.create(null, schema.text(placeholder(image.filename ?? "Image"))));
 					this.options.onError?.(coded(error, "image-unavailable", error instanceof Error ? error.message : "The pasted image is unavailable."));
 				}
 				slice = new Slice(Fragment.fromArray(nodes), 1, 1);
@@ -59103,6 +59203,10 @@ var PasteController = class {
 				source = markdown ?? input.text;
 				slice = joinable(ctx.get(parserCtx)(source).content);
 			}
+			if (!this.options.adapter && placeholders.length) {
+				const shown = slice.content.textBetween(0, slice.content.size, "\n", "\n");
+				if (placeholders.some((text) => shown.includes(text))) throw imagesRefused();
+			}
 			this.assertContext(context, operation);
 			if (!view.editable || this.options.editable?.() === false) return;
 			const anchor = this.anchor(operation);
@@ -59368,6 +59472,12 @@ function dropRange(doc, range) {
 * keeps the provider's code-language behaviour; invalid metadata pastes plain
 * text.
 */
+function imageFiles(files) {
+	return [...files].filter((file) => file.type.startsWith("image/"));
+}
+function imagesRefused() {
+	return new InkKitError("image-unsupported", "The images were not inserted because no image adapter is configured.");
+}
 function claimsPaste(view, event) {
 	const data = event.clipboardData;
 	if (!data || !view.editable) return false;
@@ -59425,6 +59535,210 @@ function dataImage(source) {
 	};
 }
 //#endregion
+//#region src/find-session.ts
+/** The codes of failures that mean the editor cannot answer now, not that the session is wrong. */
+var transient = [
+	"not-ready",
+	"stale-document",
+	"composition",
+	"operation-pending"
+];
+/** The editor refreshes each open session after every edit, selection change, load and mode change. */
+var EditorFindSession = class {
+	host;
+	onChange;
+	detach;
+	text = "";
+	reported = "";
+	closed = false;
+	busy = false;
+	cached;
+	constructor(host, onChange, detach) {
+		this.host = host;
+		this.onChange = onChange;
+		this.detach = detach;
+	}
+	state(expectedGeneration) {
+		this.assertOpen();
+		return this.measure(expectedGeneration);
+	}
+	find(query, options, expectedGeneration) {
+		this.assertOpen();
+		return this.command(expectedGeneration, () => this.select(query, options?.direction, expectedGeneration));
+	}
+	next(expectedGeneration) {
+		this.assertOpen();
+		return this.command(expectedGeneration, () => this.select(this.text, "next", expectedGeneration));
+	}
+	previous(expectedGeneration) {
+		this.assertOpen();
+		return this.command(expectedGeneration, () => this.select(this.text, "previous", expectedGeneration));
+	}
+	replace(query, replacement, expectedGeneration) {
+		this.assertOpen();
+		return this.command(expectedGeneration, () => {
+			const changed = this.restoring(expectedGeneration, () => {
+				this.select(query, void 0, expectedGeneration);
+				return this.host.replace(query, replacement, expectedGeneration);
+			});
+			const snapshot = this.host.textSnapshot(expectedGeneration);
+			const matches = this.matches(query, snapshot.snapshotId, expectedGeneration);
+			const following = matches.find((range) => range.from >= snapshot.selection.to) ?? matches[0];
+			if (following) this.host.selectTextRange(following, { reveal: true });
+			return changed;
+		});
+	}
+	replaceAll(query, replacement, expectedGeneration) {
+		this.assertOpen();
+		return this.command(expectedGeneration, () => this.restoring(expectedGeneration, () => {
+			this.select(query, void 0, expectedGeneration);
+			return this.host.replaceAll(query, replacement, expectedGeneration);
+		}));
+	}
+	clear(expectedGeneration) {
+		this.assertOpen();
+		this.command(expectedGeneration, () => {
+			this.text = "";
+			this.host.find("", expectedGeneration);
+		});
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.detach(this);
+		if (!this.text) return;
+		try {
+			this.host.find("");
+		} catch (error) {
+			if (!(error instanceof InkKitError) || !transient.includes(error.code)) throw error;
+		}
+	}
+	/** Reports the state if it changed. The editor calls this after each of its own updates; nothing
+	*  it cannot answer now is reported. */
+	refresh(expectedGeneration) {
+		if (this.closed || this.busy) return;
+		let state;
+		try {
+			state = this.measure(expectedGeneration);
+		} catch (error) {
+			if (error instanceof InkKitError && transient.includes(error.code)) return;
+			throw error;
+		}
+		const key = JSON.stringify([
+			state.documentId,
+			state.generation,
+			state.query,
+			state.current,
+			state.total
+		]);
+		if (key === this.reported) return;
+		this.reported = key;
+		this.onChange(state);
+	}
+	/** Forgets the query after a new document loads. */
+	reset() {
+		this.text = "";
+		this.cached = void 0;
+	}
+	/** Highlights the query again where the editor dropped its highlights, such as after a reload or
+	*  a mode change, and leaves the selection where it was. */
+	reapply() {
+		if (this.closed) return;
+		this.cached = void 0;
+		if (!this.text) return;
+		this.busy = true;
+		try {
+			const { selection } = this.host.textSnapshot();
+			this.host.find(this.text);
+			this.host.selectTextRange(selection);
+		} catch (error) {
+			if (!(error instanceof InkKitError) || !transient.includes(error.code)) throw error;
+		} finally {
+			this.busy = false;
+		}
+	}
+	assertOpen() {
+		if (this.closed) throw new InkKitError("destroyed", "The find session was closed");
+	}
+	/** Runs a command without reporting the editor's intermediate states, then reports the result. */
+	command(expectedGeneration, run) {
+		this.busy = true;
+		let failed = true;
+		try {
+			const result = run();
+			failed = false;
+			return result;
+		} finally {
+			this.busy = false;
+			if (!failed) this.refresh(expectedGeneration);
+			else try {
+				this.refresh(expectedGeneration);
+			} catch {}
+		}
+	}
+	select(query, direction, expectedGeneration) {
+		const snapshot = this.host.textSnapshot(expectedGeneration);
+		const matches = this.matches(query, snapshot.snapshotId, expectedGeneration);
+		const changedQuery = query !== this.text;
+		let index = matches.findIndex((range) => sameRange(range, snapshot.selection));
+		if (changedQuery || index < 0) {
+			if (direction === "previous") {
+				index = -1;
+				for (let at = matches.length - 1; at >= 0; at -= 1) if (matches[at].to <= snapshot.selection.from) {
+					index = at;
+					break;
+				}
+				if (index < 0) index = matches.length - 1;
+			} else {
+				index = matches.findIndex((range) => range.from >= snapshot.selection.from);
+				if (index < 0) index = 0;
+			}
+		} else if (direction) index = (index + (direction === "next" ? 1 : -1) + matches.length) % matches.length;
+		if (changedQuery || !query) this.host.find(query, expectedGeneration);
+		this.text = query;
+		const match = matches[index];
+		if (match) this.host.selectTextRange(match, { reveal: true });
+		return !!match;
+	}
+	/** Runs an edit and, if it fails, puts the query, highlights and selection back. */
+	restoring(expectedGeneration, run) {
+		const before = this.host.textSnapshot(expectedGeneration);
+		const previous = this.text;
+		try {
+			return run();
+		} catch (error) {
+			this.text = previous;
+			this.host.find(previous, expectedGeneration);
+			this.host.selectTextRange(before.selection);
+			throw error;
+		}
+	}
+	measure(expectedGeneration) {
+		const snapshot = this.host.textSnapshot(expectedGeneration);
+		const matches = this.matches(this.text, snapshot.snapshotId, expectedGeneration);
+		return {
+			documentId: snapshot.documentId,
+			generation: snapshot.generation,
+			revision: snapshot.revision,
+			query: this.text,
+			current: matches.findIndex((range) => sameRange(range, snapshot.selection)) + 1,
+			total: matches.length
+		};
+	}
+	matches(query, snapshotId, expectedGeneration) {
+		if (!query) return [];
+		if (this.cached?.snapshotId !== snapshotId || this.cached.query !== query) this.cached = {
+			snapshotId,
+			query,
+			matches: this.host.searchMatches(query, expectedGeneration)
+		};
+		return this.cached.matches;
+	}
+};
+function sameRange(left, right) {
+	return left.snapshotId === right.snapshotId && left.from === right.from && left.to === right.to;
+}
+//#endregion
 //#region src/session.ts
 /**
 * The loaded document's identity and counters. Each load must bring a greater `generation` than
@@ -59998,6 +60312,9 @@ var InkKitEditor = class InkKitEditor {
 	ownsRootClass = false;
 	activation;
 	reportingSuppressed = false;
+	/** A reload keeps each find session's query; a load starts without one. */
+	reloading = false;
+	findSessions = /* @__PURE__ */ new Set();
 	loading = false;
 	call;
 	writable = true;
@@ -60402,6 +60719,14 @@ var InkKitEditor = class InkKitEditor {
 		this.suggestions?.refresh();
 		if (!this.ready || this.loading || this.reportingSuppressed || this.destroyed) return;
 		this.events.commandStateChanged?.(this.commandState());
+		this.refreshFindSessions();
+	}
+	refreshFindSessions() {
+		for (const session of [...this.findSessions]) try {
+			session.refresh();
+		} catch (error) {
+			this.report(error);
+		}
 	}
 	/** What the editor can do now, for enabling host controls. Unlike `snapshot`, it works during
 	*  composition. */
@@ -60482,7 +60807,7 @@ var InkKitEditor = class InkKitEditor {
 		expectOneOf(mode, editingModes, "mode");
 		this.assertCurrent(expectedGeneration);
 		if (!this.document.handler.sourceMode || this.mode === mode) return false;
-		return this.source.setMode(mode, {
+		const switched = this.source.setMode(mode, {
 			ctx: this.editor.ctx,
 			wasSource: this.literalSurface,
 			container: this.geometry.container,
@@ -60508,6 +60833,8 @@ var InkKitEditor = class InkKitEditor {
 			},
 			reveal: () => this.revealCurrentSelection()
 		});
+		if (switched) for (const session of this.findSessions) session.reapply();
+		return switched;
 	}
 	updateSurface() {
 		this.source.element.hidden = !this.literalSurface;
@@ -60537,6 +60864,19 @@ var InkKitEditor = class InkKitEditor {
 		this.assertMutation(expectedGeneration);
 		return this.history.redo();
 	}
+	/** Drops the steps that `undo` took off the history, so `redo` has nothing to bring back. For a
+	*  host that adds content after an undo and must not let a redo resurrect what was undone.
+	*  Returns whether a redo was available. The document, selection, revision and undo steps stay
+	*  as they are, and no `changed` event is sent. */
+	discardUndone(expectedGeneration) {
+		this.assertMutation(expectedGeneration);
+		const view = this.editor.ctx.get(editorViewCtx);
+		const available = this.history.canRedo(view.state);
+		this.history.discardUndone();
+		discardFormattedRedo(view);
+		if (available) this.publishCommandState();
+		return available;
+	}
 	/** The complete current document, which is what a host saves. It throws rather than return a
 	*  partial document. */
 	snapshot(expectedGeneration) {
@@ -60675,6 +61015,7 @@ var InkKitEditor = class InkKitEditor {
 		if (this.destroyed) return;
 		this.diagnostics.destroy(this.editor.ctx);
 		this.destroyed = true;
+		this.findSessions.clear();
 		this.clipboard.clear();
 		this.ready = false;
 		this.session.close();
@@ -60739,6 +61080,7 @@ var InkKitEditor = class InkKitEditor {
 			ctx: () => instance.editor.ctx,
 			context: () => instance.context(),
 			adapter: options.images,
+			files: !!options.files,
 			onError: (error) => instance.report(error),
 			commit: (apply) => instance.facadeCall(apply),
 			literalText: () => instance.literalSurface,
@@ -60864,6 +61206,7 @@ var InkKitEditor = class InkKitEditor {
 		this.mode = "formatted";
 		this.source.reset();
 		this.search.reset();
+		if (!this.reloading) for (const session of this.findSessions) session.reset();
 		this.document.handler = handler;
 		this.source.setSourceValue(handler.richText ? "" : input.text);
 		this.source.element.setSelectionRange(this.source.element.value.length, this.source.element.value.length);
@@ -60895,11 +61238,14 @@ var InkKitEditor = class InkKitEditor {
 		const previous = this.document.handler;
 		const saved = captureReloadSurface(view, this.source.element, this.geometry.container, wasLiteral);
 		this.reportingSuppressed = true;
+		this.reloading = true;
 		try {
 			this.loadDocument(document);
 			if (previous.sourceMode && this.document.handler.sourceMode && previousMode === "source") this.setEditingMode("source", input.generation);
 			restoreReloadSurface(view, this.source.element, () => this.literalSurface, saved);
+			for (const session of this.findSessions) session.reapply();
 		} finally {
+			this.reloading = false;
 			this.reportingSuppressed = false;
 			this.publishCommandState();
 		}
@@ -61052,6 +61398,24 @@ var InkKitEditor = class InkKitEditor {
 		const count = this.search.replace(search, replacement, true);
 		return count && replacement !== search && this.refusedRichEdit(doc) ? 0 : count;
 	}
+	/**
+	* Opens a find session, which keeps a query and reports its match count and position to
+	* `onChange` whenever they change. Open one session per editor: the editor has one set of
+	* highlights.
+	*/
+	findSession(onChange) {
+		this.assertAlive();
+		if (typeof onChange !== "function") throw invalidArgument("onChange must be a function");
+		const session = new EditorFindSession(this, (state) => {
+			try {
+				onChange(state);
+			} catch (error) {
+				if (typeof globalThis.reportError === "function") globalThis.reportError(error);
+			}
+		}, (closed) => this.findSessions.delete(closed));
+		this.findSessions.add(session);
+		return session;
+	}
 	outlineContext() {
 		const { documentId, generation, revision, key } = this.session.capture();
 		return {
@@ -61361,8 +61725,10 @@ var InkKitEditor = class InkKitEditor {
 			"replaceSource",
 			"undo",
 			"redo",
+			"discardUndone",
 			"find",
 			"searchMatches",
+			"findSession",
 			"replace",
 			"replaceAll",
 			"format",
@@ -61456,4 +61822,45 @@ var InkKitEditor = class InkKitEditor {
 	}
 };
 //#endregion
-export { Decoration as a, PluginKey as c, __toESM as d, $prose as i, ok$1 as l, registerDiagram as n, DecorationSet as o, InkKitError as r, Plugin as s, InkKitEditor as t, __commonJSMin as u };
+//#region src/link-address.ts
+var openable = /* @__PURE__ */ new Set([
+	"http",
+	"https",
+	"mailto",
+	"tel"
+]);
+var schemePrefix = /^(?:[a-z][a-z0-9+.-]*:\/\/|(?:mailto|tel):)/i;
+/**
+* The address a Link field should write for what the person typed, or `undefined` when it is not
+* a web, mail or phone address. See the reference, which describes each rule.
+*/
+function normalizeLinkAddress(input) {
+	const text = input.trim();
+	if (!text || /[\s\u0000-\u001f\u007f]/.test(text)) return void 0;
+	const prefix = schemePrefix.exec(text);
+	let address;
+	if (prefix) address = prefix[0].toLowerCase() + text.slice(prefix[0].length);
+	else if (text.startsWith("/")) return void 0;
+	else if (text.includes("@") && !text.includes("/")) address = `mailto:${text}`;
+	else address = `https://${text}`;
+	const scheme = address.slice(0, address.indexOf(":"));
+	if (scheme === "http" || scheme === "https") try {
+		return new URL(address).hostname ? address : void 0;
+	} catch {
+		return;
+	}
+	if (scheme === "mailto" || scheme === "tel") return address.length > scheme.length + 1 ? address : void 0;
+}
+/**
+* Whether a host may open `address` for the person. Only `http`, `https`, `mailto` and `tel`
+* qualify, whatever the letter case. An address with no scheme, an unknown scheme such as
+* `javascript:` or `file:`, or a control character does not.
+*/
+function canOpenLink(address) {
+	const text = address.replace(/^[ \t\n\f\r]+|[ \t\n\f\r]+$/g, "");
+	if (/[\u0000-\u001f\u007f]/.test(text)) return false;
+	const colon = text.search(/[:/?#\\]|$/);
+	return text[colon] === ":" && openable.has(text.slice(0, colon).toLowerCase());
+}
+//#endregion
+export { InkKitError as a, DecorationSet as c, ok$1 as d, __commonJSMin as f, registerDiagram as i, Plugin as l, normalizeLinkAddress as n, $prose as o, __toESM as p, InkKitEditor as r, Decoration as s, canOpenLink as t, PluginKey as u };

package/dist/chunks/{highlight-C-9lbVMU.js → highlight-B_juJyDH.js}

@@ -1,4 +1,4 @@
-import { a as Decoration, c as PluginKey, d as __toESM, i as $prose, o as DecorationSet, s as Plugin, u as __commonJSMin } from "./core-CbHV2KPY.js";
+import { c as DecorationSet, f as __commonJSMin, l as Plugin, o as $prose, p as __toESM, s as Decoration, u as PluginKey } from "./core-B7CD5hsd.js";
 //#region node_modules/.pnpm/highlight.js@11.11.2/node_modules/highlight.js/es/languages/arduino.js
 /** @type LanguageFn */
 function cPlusPlus(hljs) {

package/dist/core.d.ts

@@ -1,6 +1,7 @@
 export { InkKitEditor } from './editor.js';
 export type { EditorEvents, EditorOptions, TextInputPreferences, CommandState, EditingMode, CaretState, Mark, Block, FormatCommand, FormatOptions, KeyInput, ImageInsertion, ShortcutName, Keymap, } from './editor.js';
 export { InkKitError } from './types.js';
-export type { DocumentFormat, TextDocumentFormat, TextDocumentInput, RichTextDocumentInput, TextDocumentSnapshot, RichTextDocumentSnapshot, RichTextDocument, RichTextBlock, RichTextListItem, RichTextTableCell, RichTextInline, RichTextMark, FormatLoss, FormatLossCode, ConvertedDocument, FormatPromise, OfferedFormat, EditorLabels, Heading, TableCommand, TableOptions, BlockMoveDirection, DocumentContext, DocumentInput, DocumentSnapshot, DocumentVersion, EditorErrorCode, ImageAdapter, ImageImportContext, WikiLinkReference, WikiLinkAdapter, FileReference, ClientPoint, FileContext, FilePresentation, FileAdapter, CapturedImage, PortableImage, ClipboardInput, ClipboardOutput, ClipboardScope, ClipboardImage, ClipboardDiagram, PrintableDocument, PrintableWarning, TextRange, ReadableTextSnapshot, TextRect, ViewportInsets, ViewportOptions, ViewportSnapshot, } from './types.js';
+export { normalizeLinkAddress, canOpenLink } from './link-address.js';
+export type { DocumentFormat, TextDocumentFormat, TextDocumentInput, RichTextDocumentInput, TextDocumentSnapshot, RichTextDocumentSnapshot, RichTextDocument, RichTextBlock, RichTextListItem, RichTextTableCell, RichTextInline, RichTextMark, FormatLoss, FormatLossCode, ConvertedDocument, FormatPromise, OfferedFormat, EditorLabels, Heading, TableCommand, TableOptions, BlockMoveDirection, DocumentContext, DocumentInput, DocumentSnapshot, DocumentVersion, EditorErrorCode, ImageAdapter, ImageImportContext, WikiLinkReference, WikiLinkAdapter, FileReference, ClientPoint, FileContext, FilePresentation, FileAdapter, CapturedImage, PortableImage, ClipboardInput, ClipboardOutput, ClipboardScope, ClipboardImage, ClipboardDiagram, PrintableDocument, PrintableWarning, TextRange, FindState, FindSession, ReadableTextSnapshot, TextRect, ViewportInsets, ViewportOptions, ViewportSnapshot, } from './types.js';
 export type { SlashMenuOptions, SlashCommandName, SlashCommand } from './types.js';
 export type { DiagnosticReport, DiagnosticEvent, DiagnosticState, DiagnosticPresentation, } from './diagnostics.js';

package/dist/core.js

@@ -1,2 +1,2 @@
-import { r as InkKitError, t as InkKitEditor } from "./chunks/core-CbHV2KPY.js";
-export { InkKitEditor, InkKitError };
+import { a as InkKitError, n as normalizeLinkAddress, r as InkKitEditor, t as canOpenLink } from "./chunks/core-B7CD5hsd.js";
+export { InkKitEditor, InkKitError, canOpenLink, normalizeLinkAddress };

package/dist/editor.d.ts

@@ -1,6 +1,6 @@
 import { type DiagnosticReport } from './diagnostics.js';
 import type { SlashMenuOptions } from './types.js';
-import { InkKitError, type ClientPoint, type DocumentFormat, type DocumentInput, type DocumentSnapshot, type ConvertedDocument, type TextDocumentFormat, type ImageAdapter, type FileAdapter, type WikiLinkAdapter, type ClipboardInput, type ClipboardOutput, type ClipboardScope, type DocumentVersion, type PrintableDocument, type TextRange, type ReadableTextSnapshot, type TextRect, type ViewportOptions, type ViewportSnapshot, type EditorLabels, type Heading, type TableCommand, type TableOptions, type BlockMoveDirection, type OfferedFormat } from './types.js';
+import { InkKitError, type ClientPoint, type DocumentFormat, type DocumentInput, type DocumentSnapshot, type ConvertedDocument, type TextDocumentFormat, type ImageAdapter, type FileAdapter, type WikiLinkAdapter, type ClipboardInput, type ClipboardOutput, type ClipboardScope, type DocumentVersion, type PrintableDocument, type TextRange, type ReadableTextSnapshot, type FindSession, type FindState, type TextRect, type ViewportOptions, type ViewportSnapshot, type EditorLabels, type Heading, type TableCommand, type TableOptions, type BlockMoveDirection, type OfferedFormat } from './types.js';
 /** An inline format that `CaretState` can report. */
 export type Mark = 'bold' | 'italic' | 'strikethrough' | 'highlight' | 'underline' | 'superscript' | 'subscript' | 'code' | 'link';
 /** The kind of block that holds the start of the selection. Any other block reports `paragraph`. */
@@ -27,6 +27,10 @@ export interface CaretState {
     block: Block;
     /** One quote holds the whole selection; the block is what sits inside it. */
     quoted: boolean;
+    /** The address of the link at the caret or, for a range, of the first link in it, as the
+     *  document holds it. Present exactly when `marks` includes `'link'`. For a reference link, it
+     *  is the address its definition gives. A host's Link sheet starts from it. */
+    href?: string;
     /** In an RTF document, the alignment of the paragraph that holds the start of the selection. */
     align?: 'left' | 'center' | 'right' | 'justify';
 }
@@ -178,6 +182,9 @@ export declare class InkKitEditor<F extends DocumentFormat = TextDocumentFormat>
     private ownsRootClass;
     private activation;
     private reportingSuppressed;
+    /** A reload keeps each find session's query; a load starts without one. */
+    private reloading;
+    private readonly findSessions;
     private loading;
     private call?;
     private writable;
@@ -268,6 +275,7 @@ export declare class InkKitEditor<F extends DocumentFormat = TextDocumentFormat>
     setTextInputPreferences(preferences: TextInputPreferences): void;
     private applyInputPolicy;
     private publishCommandState;
+    private refreshFindSessions;
     /** What the editor can do now, for enabling host controls. Unlike `snapshot`, it works during
      *  composition. */
     commandState(expectedGeneration?: number): CommandState;
@@ -289,6 +297,11 @@ export declare class InkKitEditor<F extends DocumentFormat = TextDocumentFormat>
     undo(expectedGeneration?: number): boolean;
     /** Returns whether a history step applied. */
     redo(expectedGeneration?: number): boolean;
+    /** Drops the steps that `undo` took off the history, so `redo` has nothing to bring back. For a
+     *  host that adds content after an undo and must not let a redo resurrect what was undone.
+     *  Returns whether a redo was available. The document, selection, revision and undo steps stay
+     *  as they are, and no `changed` event is sent. */
+    discardUndone(expectedGeneration?: number): boolean;
     /** The complete current document, which is what a host saves. It throws rather than return a
      *  partial document. */
     snapshot(expectedGeneration?: number): DocumentSnapshot<F>;
@@ -379,6 +392,12 @@ export declare class InkKitEditor<F extends DocumentFormat = TextDocumentFormat>
     replace(search: string, replacement: string, expectedGeneration?: number): boolean;
     /** Replaces every non-overlapping match once and returns how many. */
     replaceAll(search: string, replacement: string, expectedGeneration?: number): number;
+    /**
+     * Opens a find session, which keeps a query and reports its match count and position to
+     * `onChange` whenever they change. Open one session per editor: the editor has one set of
+     * highlights.
+     */
+    findSession(onChange: (state: FindState) => void): FindSession;
     private outlineContext;
     /** The outline in document order. Entries go stale when the document changes. */
     headings(expectedGeneration?: number): readonly Heading[];

package/dist/index.js

@@ -1,4 +1,4 @@
-import { n as registerDiagram, r as InkKitError, t as InkKitEditor } from "./chunks/core-CbHV2KPY.js";
+import { a as InkKitError, i as registerDiagram, n as normalizeLinkAddress, r as InkKitEditor, t as canOpenLink } from "./chunks/core-B7CD5hsd.js";
 //#region node_modules/.pnpm/dompurify@3.4.17/node_modules/dompurify/dist/purify.es.mjs
 /*! @license DOMPurify 3.4.17 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.4.17/LICENSE */
 function _OverloadYield(e, d) {
@@ -32790,4 +32790,4 @@ function renderPele(source) {
 //#region src/index.ts
 registerDiagram(renderPele);
 //#endregion
-export { InkKitEditor, InkKitError };
+export { InkKitEditor, InkKitError, canOpenLink, normalizeLinkAddress };

package/dist/link-address.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The address a Link field should write for what the person typed, or `undefined` when it is not
+ * a web, mail or phone address. See the reference, which describes each rule.
+ */
+export declare function normalizeLinkAddress(input: string): string | undefined;
+/**
+ * Whether a host may open `address` for the person. Only `http`, `https`, `mailto` and `tel`
+ * qualify, whatever the letter case. An address with no scheme, an unknown scheme such as
+ * `javascript:` or `file:`, or a control character does not.
+ */
+export declare function canOpenLink(address: string): boolean;

package/dist/types.d.ts

@@ -120,7 +120,7 @@ export interface RichTextDocumentSnapshot extends RichTextDocumentInput, Documen
     dirty: boolean;
 }
 /** The closed list of failure codes. The API reference describes each one. */
-export declare const editorErrorCodes: readonly ['not-ready', 'destroyed', 'stale-document', 'composition', 'operation-pending', 'read-only', 'invalid-argument', 'invalid-range', 'preservation', 'image-unavailable', 'diagram-unavailable', 'file-unavailable', 'clipboard-unavailable', 'slash-command-failed', 'internal'];
+export declare const editorErrorCodes: readonly ['not-ready', 'destroyed', 'stale-document', 'composition', 'operation-pending', 'read-only', 'invalid-argument', 'invalid-range', 'preservation', 'image-unavailable', 'image-unsupported', 'diagram-unavailable', 'file-unavailable', 'clipboard-unavailable', 'slash-command-failed', 'internal'];
 export type EditorErrorCode = (typeof editorErrorCodes)[number];
 /** Every failure InkKit reports. Hosts branch on `code`; `message` is for logs. When the failure
  *  started elsewhere, such as in an adapter, the host clipboard or the renderer, `cause` holds the
@@ -310,6 +310,44 @@ export interface ReadableTextSnapshot extends DocumentVersion {
     text: string;
     selection: TextRange;
 }
+/** What a find session shows: how many matches the query has and which one the selection is on. */
+export interface FindState extends DocumentVersion {
+    /** The query, or an empty string when there is none. */
+    query: string;
+    /** The position, from 1, of the match that the selection covers exactly, or 0 when the selection
+     *  is not on a match. */
+    current: number;
+    /** The number of matches. */
+    total: number;
+}
+/**
+ * A find bar's state and commands: the query, the match count, the match the selection is on, and
+ * navigation that wraps. Open one with `InkKitEditor.findSession`.
+ */
+export interface FindSession {
+    /** The current state. It does not call the change handler. */
+    state(expectedGeneration?: number): FindState;
+    /** Sets the query, highlights its matches and selects one. A new query selects the first match
+     *  at or after the selection, or the last one before it with `direction: 'previous'`. With the
+     *  same query, the selection moves to the next or previous match and wraps at the ends; without
+     *  a direction, a selection on a match stays there. Returns whether there is a match. */
+    find(query: string, options?: {
+        direction?: 'next' | 'previous';
+    }, expectedGeneration?: number): boolean;
+    /** Moves to the next match, wrapping at the end. Returns whether there is a match. */
+    next(expectedGeneration?: number): boolean;
+    /** Moves to the previous match, wrapping at the start. Returns whether there is a match. */
+    previous(expectedGeneration?: number): boolean;
+    /** Replaces the selected match, or the next one, and selects the match after it. Returns whether
+     *  the text changed. A match that already reads as the replacement is skipped without a change. */
+    replace(query: string, replacement: string, expectedGeneration?: number): boolean;
+    /** Replaces every match and returns how many were replaced. */
+    replaceAll(query: string, replacement: string, expectedGeneration?: number): number;
+    /** Clears the query and the highlights. */
+    clear(expectedGeneration?: number): void;
+    /** Stops the session: it clears the highlights and its handler is not called again. */
+    close(): void;
+}
 /** A rectangle in CSS pixels in the web view's client coordinate space. */
 export interface TextRect {
     left: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aicayzer/inkkit",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "A preserving Markdown editor for offline web views and the web",
   "license": "MIT",
   "type": "module",
@@ -55,6 +55,8 @@
     "test:package": "node scripts/test-package.mjs",
     "check": "pnpm typecheck && pnpm test && pnpm build && pnpm test:docs && pnpm test:package",
     "test:browser": "playwright test --project=chromium",
+    "test:playground": "playwright test --config playwright.playground.config.ts --project=chromium",
+    "measure:browser": "playwright test --config playwright.measure.config.ts",
     "test:built-playground": "playwright test --config playwright.built.config.ts"
   },
   "devDependencies": {