@aicayzer/inkkit 0.3.0 → 0.3.2

package/dist/chunks/{core-DrVCeBzK.js → core-DTew7k7c.js}

@@ -2214,7 +2214,7 @@ function tokenizeCharacterEscape(effects, ok, nok) {
 * } from 'micromark-util-types'
 */
 /** @type {Construct} */
-var characterReference = {
+var characterReference$1 = {
 	name: "characterReference",
 	tokenize: tokenizeCharacterReference
 };
@@ -7349,7 +7349,7 @@ var flow = {
 };
 /** @satisfies {Extension['string']} */
 var string = {
-	[38]: characterReference,
+	[38]: characterReference$1,
 	[92]: characterEscape
 };
 /** @satisfies {Extension['text']} */
@@ -7358,7 +7358,7 @@ var text$4 = {
 	[-4]: lineEnding$1,
 	[-3]: lineEnding$1,
 	[33]: labelStartImage,
-	[38]: characterReference,
+	[38]: characterReference$1,
 	[42]: attention$2,
 	[60]: [autolink$1, htmlText],
 	[91]: labelStartLink,
@@ -7916,7 +7916,7 @@ function postprocess(events) {
 * @returns {Array<Chunk>}
 *   Chunks.
 */
-var search$1 = /[\0\t\n\r]/g;
+var search$2 = /[\0\t\n\r]/g;
 /**
 * @returns {Preprocessor}
 *   Preprocess a value.
@@ -7941,8 +7941,8 @@ function preprocess() {
 			start = void 0;
 		}
 		while (startPosition < value.length) {
-			search$1.lastIndex = startPosition;
-			const match = search$1.exec(value);
+			search$2.lastIndex = startPosition;
+			const match = search$2.exec(value);
 			const endPosition = match && match.index !== void 0 ? match.index : value.length;
 			const code = value.charCodeAt(endPosition);
 			if (!match) {
@@ -22734,7 +22734,7 @@ var SerializerState = class extends Stack {
 	#closeMark;
 };
 //#endregion
-//#region node_modules/.pnpm/prosemirror-view@1.42.6_patch_hash=808819d35255b79fc131ebc4873ab2fbcd47cd8f5bc05cd11e8caab02ecee548/node_modules/prosemirror-view/dist/index.js
+//#region node_modules/.pnpm/prosemirror-view@1.42.6_patch_hash=f2853b430244e6a0ce28d0ee793854c199c3f40279a807cb6690af21fae2d25e/node_modules/prosemirror-view/dist/index.js
 var domIndex = function(node) {
 	for (var index = 0;; index++) {
 		node = node.previousSibling;
@@ -23907,7 +23907,7 @@ var NodeViewDesc = class NodeViewDesc extends ViewDesc {
 		this.children = replaceNodes(this.children, pos, pos + text.length, view, desc);
 	}
 	update(node, outerDeco, innerDeco, view) {
-		if (this.dirty == NODE_DIRTY || !node.sameMarkup(this.node)) return false;
+		if (this.dirty == NODE_DIRTY || (this.parent ? !node.sameMarkup(this.node) : node.type != this.node.type)) return false;
 		this.updateInner(node, outerDeco, innerDeco, view);
 		return true;
 	}
@@ -31817,21 +31817,51 @@ var linkSchemes = /* @__PURE__ */ new Set([
 	"mailto",
 	"tel"
 ]);
+/** Schemes a host may never add: each runs code or reads local data. */
+var refusedSchemes = /* @__PURE__ */ new Set([
+	"javascript",
+	"data",
+	"vbscript",
+	"file"
+]);
+var noSchemes = /* @__PURE__ */ new Set();
 /**
 * Whether a link address may be kept. Relative paths, queries and fragments
 * pass, and so does an address whose scheme is listed, in any letter case.
-* Spaces, tabs and line breaks at the ends are ignored, as in a browser. Any
-* other control character makes the address unsafe, because a browser may skip
-* it while it reads the scheme. The scheme is the text before the first `:` in
-* the part before the first `/`, `?`, `#` or `\`, so an unknown or malformed
-* scheme is refused.
-*/
-function isSafeLinkTarget(value) {
+* `extra` holds the lower-case schemes one editor's host added. Spaces, tabs
+* and line breaks at the ends are ignored, as in a browser. Any other control
+* character makes the address unsafe, because a browser may skip it while it
+* reads the scheme. The scheme is the text before the first `:` in the part
+* before the first `/`, `?`, `#` or `\`, so an unknown or malformed scheme is
+* refused.
+*/
+function isSafeLinkTarget(value, extra = noSchemes) {
 	const target = value.replace(/^[ \t\n\f\r]+|[ \t\n\f\r]+$/g, "");
 	if (/[\u0000-\u001f\u007f]/.test(target)) return false;
 	const head = target.slice(0, target.search(/[/?#\\]|$/));
 	const colon = head.indexOf(":");
-	return colon < 0 || linkSchemes.has(head.slice(0, colon).toLowerCase());
+	if (colon < 0) return true;
+	const scheme = head.slice(0, colon).toLowerCase();
+	return linkSchemes.has(scheme) || extra.has(scheme);
+}
+/**
+* Checks the host's `linkSchemes` option and returns its entries in lower
+* case. An entry is a scheme name, and `javascript`, `data`, `vbscript` and
+* `file` are never accepted.
+*/
+function extraLinkSchemes(value, name) {
+	if (!Array.isArray(value)) throw invalidArgument(`${name} must be a list`);
+	return value.map((entry, index) => {
+		if (typeof entry !== "string" || !/^[a-z][a-z0-9+.-]*$/i.test(entry)) throw invalidArgument(`${name}[${index}] must be a scheme name of letters, digits, +, - and ., starting with a letter`);
+		const scheme = entry.toLowerCase();
+		if (refusedSchemes.has(scheme)) throw invalidArgument(`${name}[${index}] cannot be ${scheme}`);
+		return scheme;
+	});
+}
+/** The extra schemes of one editor, so that two editors on a page keep their own. */
+var linkSchemesCtx = $ctx(noSchemes, "inkkitLinkSchemes");
+function editorLinkSchemes(ctx) {
+	return ctx.isInjected(linkSchemesCtx.key) ? ctx.get(linkSchemesCtx.key) : noSchemes;
 }
 /**
 * Whether an image source would run script if a renderer treated it as an
@@ -34914,6 +34944,7 @@ var referenceLinks = linkSchema.extendSchema((base) => (ctx) => {
 	const schema = base(ctx);
 	return {
 		...schema,
+		inclusive: false,
 		priority: 40,
 		attrs: {
 			...schema.attrs,
@@ -34942,7 +34973,9 @@ var referenceLinks = linkSchema.extendSchema((base) => (ctx) => {
 		}],
 		toDOM(mark) {
 			const attrs = { ...schema.toDOM(mark, false)[1] };
-			if (!isSafeLinkTarget(String(mark.attrs.href ?? ""))) attrs.href = "";
+			const href = String(mark.attrs.href ?? "");
+			if (!isSafeLinkTarget(href, editorLinkSchemes(ctx))) attrs.href = "";
+			else if (!attrs.href) attrs.href = href.trim();
 			delete attrs.label;
 			delete attrs.identifier;
 			delete attrs.referenceType;
@@ -35387,6 +35420,10 @@ var undoSmartPunctuation = (state, dispatch) => {
 //#region src/linked-syntax.ts
 var fromTable = (raw) => raw.replace(/(\\*)\|/g, (_match, escapes) => `${"\\".repeat(Math.floor(escapes.length / 2))}|`);
 var toTable = (raw) => raw.replace(/(\\*)\|/g, (_match, escapes) => `${"\\".repeat(escapes.length * 2 + 1)}|`);
+function pathTableForm(raw, inTable) {
+	if (!inTable) return raw;
+	return raw.replace(/(\\*)\|/g, (_match, escapes) => escapes.length % 2 ? escapes + "|" : escapes + "\\|");
+}
 function parseLinkedSyntax(raw, inTable = false) {
 	const source = inTable ? fromTable(raw) : raw;
 	const embed = source.startsWith("!");
@@ -35473,7 +35510,25 @@ function tableForm(raw, authoredInTable, outputInTable) {
 	if (authoredInTable === outputInTable) return raw;
 	return outputInTable ? toTable(raw) : fromTable(raw);
 }
+function wikiMarkdown(node, inTable = false) {
+	return tableForm(String(node.attrs.raw), Boolean(node.attrs.inTable), inTable);
+}
+function wikiReference(node) {
+	return {
+		raw: wikiMarkdown(node, Boolean(node.attrs.inTable)),
+		target: String(node.attrs.target),
+		...node.attrs.fragment != null ? { fragment: String(node.attrs.fragment) } : {},
+		label: String(node.attrs.label)
+	};
+}
 function fileReference(node) {
+	return {
+		...fileFields(node),
+		raw: fileSource(node)
+	};
+}
+/** `fileReference` without the embed's text, which takes writing it. */
+function fileFields(node) {
 	const reference = String(node.attrs.src ?? "");
 	const named = node.attrs.inkkitFileRaw != null;
 	const alt = String(node.attrs.alt ?? "");
@@ -35492,11 +35547,49 @@ function fileReference(node) {
 		...width != null ? { width } : {}
 	};
 }
+var writers = /* @__PURE__ */ new WeakMap();
+/** Sets how an image of `schema` is written when it has no authored text. */
+function setImageWriter(schema, write) {
+	writers.set(schema, write);
+}
+/**
+* A file embed's Markdown as the document holds it: its authored text while
+* the embed is unchanged, otherwise the text InkKit writes for it.
+*/
+function fileSource(node) {
+	if (node.attrs.inkkitFileRaw != null) return namedFileMarkdown(node, Boolean(node.attrs.inkkitFileInTable)) ?? "";
+	const authored = authoredFileSource(node);
+	if (authored != null) return authored;
+	const write = writers.get(node.type.schema);
+	if (!write) throw new InkKitError("internal", "The image writer is not set");
+	return pathTableForm(write(node), Boolean(node.attrs.inkkitFileInTable));
+}
+/** Only reuse authored spelling while it still describes the image. */
+function authoredFileSource(node) {
+	const authored = node.attrs.inkkitFileSource;
+	return authored && authored.src === node.attrs.src && authored.alt === node.attrs.alt && authored.title === node.attrs.title ? authored.text : null;
+}
+/** Records each path image's Markdown as written, for `FileReference.raw`. */
+function remarkFileSources() {
+	return (tree, file) => {
+		const source = String(file.value ?? "").replace(/^\uFEFF/, "");
+		const visit = (node, inTable = false) => {
+			if (node.type === "image" && node.inkkitFileRaw == null) {
+				const start = node.position?.start.offset;
+				const end = node.position?.end.offset;
+				if (start != null && end != null) node.inkkitFileSource = source.slice(start, end);
+				node.inkkitFileInTable = inTable;
+			}
+			if ("children" in node) node.children.forEach((child) => visit(child, inTable || node.type === "tableCell"));
+		};
+		visit(tree);
+	};
+}
 function namedFileMarkdown(node, inTable = false) {
 	if (node.attrs.inkkitFileRaw == null) return void 0;
 	let raw = String(node.attrs.inkkitFileRaw);
 	const authoredInTable = Boolean(node.attrs.inkkitFileInTable);
-	const width = fileReference(node).width ?? null;
+	const width = fileFields(node).width ?? null;
 	const original = node.attrs.inkkitFileWidth ?? null;
 	if (width !== original) {
 		if (authoredInTable) raw = fromTable(raw);
@@ -35608,6 +35701,54 @@ var wikiLinkComposition = $prose(() => new Plugin({
 	} } }
 }));
 /**
+* A pasted or moved atom retains its original attributes. Stores the spelling
+* its new context saves before preservation and node views observe it, so
+* adapter references and clipboard metadata agree.
+*/
+var referenceTableContext = $prose(() => new Plugin({
+	key: new PluginKey("inkkitReferenceTableContext"),
+	appendTransaction(transactions, _before, state) {
+		if (!transactions.some((tr) => tr.docChanged)) return null;
+		let ranges = [];
+		for (const transaction of transactions) for (const map of transaction.mapping.maps) {
+			ranges = ranges.map(([from, to]) => [map.map(from, -1), map.map(to)]);
+			map.forEach((_from, _to, from, to) => ranges.push([from, to]));
+		}
+		const tr = state.tr;
+		const seen = /* @__PURE__ */ new Set();
+		for (const [from, to] of ranges) state.doc.nodesBetween(from, to, (node, pos) => {
+			if (![
+				"inkkit_wiki_link",
+				"image",
+				"image_block"
+			].includes(node.type.name) || seen.has(pos)) return;
+			seen.add(pos);
+			const $pos = state.doc.resolve(pos);
+			let inTable = false;
+			for (let depth = $pos.depth; depth > 0; depth--) if (["table_cell", "table_header"].includes($pos.node(depth).type.name)) inTable = true;
+			if (node.type.name === "inkkit_wiki_link") {
+				if (inTable !== Boolean(node.attrs.inTable)) tr.setNodeMarkup(pos, void 0, {
+					...node.attrs,
+					raw: wikiMarkdown(node, inTable),
+					inTable
+				});
+			} else if (inTable !== Boolean(node.attrs.inkkitFileInTable)) {
+				const authored = node.attrs.inkkitFileSource;
+				tr.setNodeMarkup(pos, void 0, {
+					...node.attrs,
+					inkkitFileRaw: namedFileMarkdown(node, inTable) ?? null,
+					inkkitFileSource: authored ? {
+						...authored,
+						text: pathTableForm(authored.text, inTable)
+					} : null,
+					inkkitFileInTable: inTable
+				});
+			}
+		});
+		return tr.steps.length ? tr : null;
+	}
+}));
+/**
 * Turns `[[target]]`, as the person types its last bracket, into the wiki link
 * it reads as when the note is opened, so the note keeps the characters that
 * were typed. Left as text, the brackets save as `\[\[target]]`, which no
@@ -35695,6 +35836,7 @@ function linkedSyntax(wikiLinks, files) {
 	const wiki = (node, _parent, state) => tableForm(String(node.raw), Boolean(node.inTable), state.stack.includes("tableCell"));
 	const named = (node, parent, state, info) => {
 		if (node.inkkitFileRaw != null) return tableForm(String(node.inkkitFileRaw), Boolean(node.inkkitFileInTable), state.stack.includes("tableCell"));
+		if (node.inkkitFileSource != null) return pathTableForm(node.inkkitFileSource, state.stack.includes("tableCell"));
 		return handle.image(node, parent, state, info);
 	};
 	return $remark("inkkitLinkedSyntax", () => function() {
@@ -35719,13 +35861,22 @@ function validName(value) {
 }
 function wikiSuggestionNode(state, name) {
 	if (!validName(name)) throw invalidArgument("A note suggestion must be a supported note name");
-	return state.schema.nodes.inkkit_wiki_link.create({
+	const { $from } = state.selection;
+	let inTable = false;
+	for (let depth = $from.depth; depth > 0; depth--) if (["table_cell", "table_header"].includes($from.node(depth).type.name)) inTable = true;
+	const node = state.schema.nodes.inkkit_wiki_link.create({
 		raw: rawName(name),
 		target: name,
 		label: name,
 		fragment: null,
 		inTable: false
-	}, void 0, state.selection.$from.marks());
+	}, void 0, $from.marks());
+	if (!inTable) return node;
+	return node.type.create({
+		...node.attrs,
+		raw: wikiMarkdown(node, true),
+		inTable
+	}, void 0, node.marks);
 }
 function wikiSuggestionTransaction(view, session, name) {
 	const { state } = view;
@@ -43197,17 +43348,28 @@ var imageAttrs = {
 		validate: "string"
 	},
 	inkkitFileRaw: { default: null },
+	inkkitFileSource: { default: null },
 	inkkitFileTarget: { default: null },
 	inkkitFileFragment: { default: null },
 	inkkitFileWidth: { default: null },
 	inkkitFileInTable: { default: false }
 };
 function markdownImageAttrs(node) {
+	const src = String(node.url ?? "");
+	const alt = String(node.alt ?? "");
+	const title = String(node.title ?? "");
+	const source = typeof node.inkkitFileSource === "string" ? {
+		text: node.inkkitFileSource,
+		src,
+		alt,
+		title
+	} : null;
 	return {
-		src: String(node.url ?? ""),
-		alt: String(node.alt ?? ""),
-		title: String(node.title ?? ""),
+		src,
+		alt,
+		title,
 		inkkitFileRaw: node.inkkitFileRaw ?? null,
+		inkkitFileSource: source,
 		inkkitFileTarget: node.inkkitFileTarget ?? null,
 		inkkitFileFragment: node.inkkitFileFragment ?? null,
 		inkkitFileWidth: node.inkkitFileWidth ?? null,
@@ -43603,14 +43765,15 @@ var from = {
 		}
 	}
 };
+var onThreeLines = (isBlock, block, value) => isBlock ? block !== false || /[\r\n]/.test(value) : Boolean(block);
 function commentSource(node) {
 	const body = node.textContent;
-	return node.attrs.syntax === "html" ? `<!--${body}-->` : node.type.name === "comment_block" || node.attrs.block ? `%%\n${body}\n%%` : `%%${body}%%`;
+	return node.attrs.syntax === "html" ? `<!--${body}-->` : onThreeLines(node.type.name === "comment_block", node.attrs.block, body) ? `%%\n${body}\n%%` : `%%${body}%%`;
 }
 var handler = (node) => {
 	const comment = node;
 	const value = comment.value ?? "";
-	return comment.syntax === "html" ? `<!--${value}-->` : comment.type === "inkkitCommentBlock" || comment.block ? `%%\n${value}\n%%` : `%%${value}%%`;
+	return comment.syntax === "html" ? `<!--${value}-->` : onThreeLines(comment.type === "inkkitCommentBlock", comment.block, value) ? `%%\n${value}\n%%` : `%%${value}%%`;
 };
 function htmlSpans(value) {
 	const spans = [];
@@ -43700,6 +43863,7 @@ function remarkComments() {
 			if (node.type === "paragraph" && parentType !== "listItem" && node.children.length === 1 && node.children[0]?.type === "inkkitCommentInline") return {
 				...node.children[0],
 				type: "inkkitCommentBlock",
+				block: false,
 				position: node.position
 			};
 			return node;
@@ -43739,7 +43903,7 @@ function commentNode(inline) {
 			runner: (state, node, type) => {
 				state.addNode(type, {
 					syntax: node.syntax,
-					block: inline ? Boolean(node.block) : true
+					block: inline ? Boolean(node.block) : node.block !== false
 				}, node.value ? [state.schema.text(String(node.value))] : void 0);
 			}
 		},
@@ -43963,50 +44127,116 @@ async function resolveFile(adapter, reference, context) {
 	].includes(presentation.kind)) throw new TypeError("File presentation needs a resource URL");
 	return Object.freeze({ ...presentation });
 }
+/** The event every reference view hears when the editor's media policy or references change. */
+var mediaPolicyEvent = "inkkit-media-policy";
+function requestRefresh(dom, refresh) {
+	dom.dispatchEvent(new CustomEvent(mediaPolicyEvent, { detail: { refresh } }));
+}
+/** The refresh a policy event carries. A plain event, such as a host's, carries none. */
+function refreshOf(event) {
+	const detail = event instanceof CustomEvent ? event.detail : null;
+	return detail && typeof detail === "object" && "refresh" in detail ? detail.refresh : void 0;
+}
+function refreshes(refresh, target) {
+	return !refresh.targets || refresh.targets.has(target);
+}
+function samePresentation(a, b) {
+	const left = a;
+	const right = b;
+	const keys = Object.keys(left);
+	return keys.length === Object.keys(right).length && keys.every((key) => left[key] === right[key]);
+}
 var FileResolution = class {
 	runtime;
 	changed;
+	cache;
 	state = { status: "idle" };
 	reference;
 	key = "";
 	request;
 	dead = false;
-	constructor(runtime, changed) {
+	constructor(runtime, changed, cache) {
 		this.runtime = runtime;
 		this.changed = changed;
+		this.cache = cache;
 	}
 	update(reference) {
 		const key = JSON.stringify([
+			reference.raw,
 			reference.reference,
 			reference.kind,
 			reference.fragment
 		]);
 		this.reference = Object.freeze({ ...reference });
 		if (this.key === key && this.request?.isCurrent()) return;
+		if (this.key !== key) this.cache?.release(this, this.key);
 		this.key = key;
+		this.cache?.retain(this, key);
+		const cached = this.cache?.get(key);
+		if (cached) {
+			if (this.request?.pending) this.request.controller.abort();
+			this.request = {
+				controller: cached.controller,
+				pending: false,
+				isCurrent: cached.isCurrent
+			};
+			this.state = {
+				status: "resolved",
+				presentation: cached.presentation
+			};
+			this.changed();
+			return;
+		}
 		this.retry();
 	}
+	/** Resolves again from a blank loading card. */
 	retry() {
+		this.cache?.delete(this.key);
 		this.cancel();
+		this.start(true);
+	}
+	/**
+	* Resolves again behind the current card, which stays until the answer differs, so a card that
+	* the host's change doesn't affect neither blanks nor moves.
+	*/
+	refresh() {
+		this.cache?.delete(this.key);
+		if (this.dead || !this.runtime.active()) return;
+		if (this.state.status === "idle") this.retry();
+		else this.start(false);
+	}
+	start(blank) {
+		if (!this.cache || this.request?.pending) this.request?.controller.abort();
+		this.request = void 0;
 		if (this.dead || !this.reference || !this.runtime.active()) return;
 		const captured = this.runtime.capture();
 		const request = {
 			controller: new AbortController(),
+			pending: true,
 			isCurrent: captured.isCurrent
 		};
 		this.request = request;
-		this.state = { status: "loading" };
-		this.changed();
+		if (blank) {
+			this.state = { status: "loading" };
+			this.changed();
+		}
 		resolveFile(this.runtime.adapter, this.reference, {
 			...captured.context,
 			signal: request.controller.signal
 		}).then((presentation) => {
 			if (!this.current(request)) return;
+			const before = this.state;
+			request.pending = false;
 			this.state = {
 				status: "resolved",
 				presentation
 			};
-			this.changed();
+			this.cache?.set(this.key, {
+				presentation,
+				isCurrent: request.isCurrent,
+				controller: request.controller
+			});
+			if (before.status !== "resolved" || !samePresentation(before.presentation, presentation)) this.changed();
 		}, (failure) => {
 			if (!this.current(request)) return;
 			const error = coded(failure, "file-unavailable");
@@ -44026,9 +44256,63 @@ var FileResolution = class {
 		this.request = void 0;
 		this.state = { status: "idle" };
 	}
+	/** Hidden views keep an answer for this document, but never accept a late answer. */
+	suspend() {
+		if (this.request?.pending || this.state.status === "idle") this.cancel();
+	}
+	invalidate() {
+		this.cache?.delete(this.key);
+		this.cancel();
+	}
 	destroy() {
 		this.dead = true;
-		this.cancel();
+		this.cache?.release(this, this.key);
+		if (!this.cache || this.request?.pending || this.state.status !== "resolved") this.cancel();
+	}
+};
+/** A source commit may replace a node view without changing its authored reference. */
+var FilePresentationCache = class {
+	entries = /* @__PURE__ */ new Map();
+	retain(owner, key) {
+		let entry = this.entries.get(key);
+		if (!entry) this.entries.set(key, entry = {
+			owners: /* @__PURE__ */ new Set(),
+			controllers: /* @__PURE__ */ new Set()
+		});
+		entry.owners.add(owner);
+	}
+	release(owner, key) {
+		const entry = this.entries.get(key);
+		if (!entry) return;
+		entry.owners.delete(owner);
+		queueMicrotask(() => {
+			if (this.entries.get(key) === entry && !entry.owners.size) {
+				for (const controller of entry.controllers) controller.abort();
+				this.entries.delete(key);
+			}
+		});
+	}
+	get(key) {
+		const value = this.entries.get(key)?.value;
+		if (value && !value.isCurrent()) {
+			this.delete(key);
+			return;
+		}
+		return value;
+	}
+	set(key, value) {
+		const entry = this.entries.get(key);
+		if (!entry) return;
+		entry.value = value;
+		entry.controllers.add(value.controller);
+	}
+	delete(key) {
+		const entry = this.entries.get(key);
+		if (entry) {
+			for (const controller of entry.controllers) controller.abort();
+			entry.controllers.clear();
+			entry.value = void 0;
+		}
 	}
 };
 //#endregion
@@ -44117,7 +44401,7 @@ function nodeText(node, missingImages, fileDescriptions) {
 	if (node.type.name === "image") {
 		const description = fileDescriptions.get(node.attrs);
 		if (description != null) return description;
-		const alt = fileReference(node).label || "Image";
+		const alt = fileFields(node).label || "Image";
 		return missingImages.has(String(node.attrs.src ?? "")) ? `[${alt}: image unavailable]` : alt;
 	}
 	if (node.type.name === "table") {
@@ -44131,7 +44415,9 @@ function nodeText(node, missingImages, fileDescriptions) {
 	}
 	return clipboardText(node.content, missingImages, fileDescriptions);
 }
-function clipboardDOM(content, schema) {
+/** `linkSchemes` are the schemes beyond the built-in ones that a copied link keeps. Print and paste
+*  leave it out, so they keep only the built-in ones. */
+function clipboardDOM(content, schema, linkSchemes) {
 	content = shareableFragment(content);
 	const container = document.createElement("div");
 	const serializer = DOMSerializer.fromSchema(schema);
@@ -44144,7 +44430,7 @@ function clipboardDOM(content, schema) {
 		}]
 	}, {
 		...serializer.marks,
-		link: (mark, inline) => isSafeLinkTarget(String(mark.attrs.href ?? "")) ? serializer.marks.link(mark, inline) : ["span", 0]
+		link: (mark, inline) => isSafeLinkTarget(String(mark.attrs.href ?? ""), linkSchemes) ? serializer.marks.link(mark, inline) : ["span", 0]
 	});
 	container.append(safe.serializeFragment(content));
 	if (!onlyDefinitions(content)) for (const definition of container.querySelectorAll("[data-inkkit-reference-definition]")) definition.remove();
@@ -44163,18 +44449,18 @@ function clipboardDOM(content, schema) {
 	}
 	return container;
 }
-function clipboardContent(content, schema) {
+function clipboardContent(content, schema, linkSchemes) {
 	return {
 		text: clipboardText(content),
-		html: clipboardDOM(content, schema).innerHTML
+		html: clipboardDOM(content, schema, linkSchemes).innerHTML
 	};
 }
-function clipboardSerializer(schema) {
+function clipboardSerializer(schema, linkSchemes) {
 	const serializer = DOMSerializer.fromSchema(schema);
 	const safe = new DOMSerializer(serializer.nodes, serializer.marks);
 	safe.serializeFragment = (content, options = {}, target) => {
 		const output = target ?? (options.document ?? document).createDocumentFragment();
-		output.append(...clipboardDOM(content, schema).childNodes);
+		output.append(...clipboardDOM(content, schema, linkSchemes).childNodes);
 		return output;
 	};
 	return safe;
@@ -44182,15 +44468,15 @@ function clipboardSerializer(schema) {
 var visibleClipboard = $prose((ctx) => new Plugin({
 	key: new PluginKey("visibleClipboard"),
 	props: {
-		clipboardSerializer: clipboardSerializer(ctx.get(schemaCtx)),
+		clipboardSerializer: clipboardSerializer(ctx.get(schemaCtx), editorLinkSchemes(ctx)),
 		clipboardTextSerializer: (slice) => clipboardText(slice.content)
 	}
 }));
 /** Export a frozen document fragment; presentation URLs never enter the clipboard. */
-async function portableClipboard(content, schema, markdown, adapter, context, completeDiagrams, files, signal = new AbortController().signal) {
+async function portableClipboard(content, schema, markdown, adapter, context, completeDiagrams, files, signal = new AbortController().signal, linkSchemes) {
 	signal.throwIfAborted();
 	content = shareableFragment(content);
-	const base = clipboardContent(content, schema);
+	const base = clipboardContent(content, schema, linkSchemes);
 	const container = document.createElement("div");
 	container.innerHTML = base.html;
 	const images = [];
@@ -44202,7 +44488,7 @@ async function portableClipboard(content, schema, markdown, adapter, context, co
 	const captured = [...container.querySelectorAll("img")].map((element, index) => {
 		const node = references[index];
 		const reference = String(node?.attrs.src ?? "");
-		const { label: authoredAlt, width } = fileReference(node);
+		const { label: authoredAlt, width } = fileFields(node);
 		const alt = authoredAlt || "Image";
 		if (width != null && width > 0) element.setAttribute("width", String(Math.min(4096, width)));
 		element.removeAttribute("src");
@@ -44805,10 +45091,82 @@ var cursor = [
 //#endregion
 //#region src/text-input.ts
 var isInputRules = (plugin) => plugin.spec.isInputRules === true;
+function heldLink(doc, from, to) {
+	const type = doc.type.schema.marks.link;
+	if (!type) return void 0;
+	let link;
+	let whole = true;
+	doc.nodesBetween(from, to, (node) => {
+		if (!node.isInline) return true;
+		const own = type.isInSet(node.marks);
+		if (!own || link && !own.eq(link)) whole = false;
+		link ??= own;
+		return false;
+	});
+	return whole ? link : void 0;
+}
 /**
-* Inserts text that arrives in one piece, such as buffered native typing,
-* dictation or a text replacement, at `from` to `to`, and returns whether it
-* did.
+* The marks that text put in place of `from` to `to` takes. Links are not
+* inclusive, so text typed at either end of a link stays outside it, but text
+* that replaces part or all of one link's text stays in that link. Marks
+* stored for the selection, such as a link started at the caret, come first.
+*/
+function replacementMarks(state, from, to) {
+	const { doc, selection, storedMarks } = state;
+	if (storedMarks && selection.from === from && selection.to === to) return storedMarks;
+	const $from = doc.resolve(from);
+	if (from === to) return $from.marks();
+	const $to = doc.resolve(to);
+	const marks = $from.marksAcross($to) ?? $from.marks();
+	const link = $from.sameParent($to) ? heldLink(doc, from, to) : void 0;
+	return link && !link.isInSet(marks) ? link.addToSet(marks) : marks;
+}
+/**
+* The link that typing over its end continues, after typing replaced the end
+* or all of its text. Its stored marks keep it for the next keystrokes until
+* the caret moves or another edit clears them.
+*/
+var typingKey = new PluginKey("inkkitTextInput");
+var typingState = {
+	init: () => null,
+	apply(tr, link, _old, state) {
+		const meta = tr.getMeta(typingKey);
+		if (meta !== void 0) return meta;
+		return link && link.isInSet(state.storedMarks ?? []) ? link : null;
+	}
+};
+function linkTyping(state, from, to, text) {
+	const type = state.schema.marks.link;
+	if (!type) return void 0;
+	const marks = replacementMarks(state, from, to);
+	const link = type.isInSet(marks);
+	if (!link) return void 0;
+	const stored = type.isInSet(state.storedMarks ?? []);
+	const continued = typingKey.getState(state);
+	const retyped = stored !== void 0 && continued?.eq(stored) || from < to && !type.isInSet(state.doc.resolve(from).marksAcross(state.doc.resolve(to)) ?? []);
+	if (!retyped && !stored) return void 0;
+	const space = retyped ? -1 : text.search(/\s/);
+	const linked = space < 0 ? text.length : space;
+	const address = link.attrs.form != null;
+	return {
+		marks,
+		link,
+		linked,
+		stored: address ? null : linked < text.length ? link.removeFromSet(marks) : marks,
+		retyped: retyped && !address
+	};
+}
+function continueLink(tr, from, text, typing) {
+	const linked = Math.min(typing.linked, text.length);
+	tr.removeMark(from, from + text.length, typing.link.type);
+	if (linked) tr.addMark(from, from + linked, typing.link);
+	if (typing.stored) tr.setStoredMarks(typing.stored);
+	return tr.setMeta(typingKey, typing.retyped ? typing.link : null);
+}
+/**
+* Inserts typed text at `from` to `to`, and returns whether it did. It handles
+* text that arrives in one piece, such as buffered native typing, dictation or
+* a text replacement, and typing that continues a link.
 *
 * Input rules are written for one typed character: Milkdown's take their
 * positions from the document before the text goes in, so given more than
@@ -44816,19 +45174,25 @@ var isInputRules = (plugin) => plugin.spec.isInputRules === true;
 * in except for its last character, and the input rules see that character
 * typed after the rest, all in one transaction.
 */
-function insertTextChunk(view, from, to, text, deflt) {
+function insertTypedText(view, from, to, text, deflt) {
 	const characters = Array.from(text);
-	if (characters.length < 2 || view.composing || /[\r\n]/.test(text)) return false;
+	if (!characters.length || view.composing || /[\r\n]/.test(text)) return false;
 	const { state } = view;
-	const $from = state.doc.resolve(from);
-	const $to = state.doc.resolve(to);
+	const typing = linkTyping(state, from, to, text);
+	if (characters.length < 2 && !typing) return false;
+	const fallback = () => {
+		const plain = deflt();
+		return typing ? continueLink(plain, from, text, typing) : plain;
+	};
+	const marks = typing?.marks ?? replacementMarks(state, from, to);
 	const last = characters.at(-1);
 	const rest = text.slice(0, -last.length);
-	const tr = state.tr.insertText(rest, from, to);
+	const tr = rest ? state.tr.setStoredMarks(marks).insertText(rest, from, to) : state.tr.delete(from, to);
+	if (typing) continueLink(tr, from, rest, typing);
 	const $at = Selection.near(tr.doc.resolve(tr.mapping.map(to)), -1).$head;
 	const at = $at.pos;
 	if (!$at.parent.inlineContent || $at.parent.type.spec.code || $at.parentOffset < rest.length || $at.parent.textBetween($at.parentOffset - rest.length, $at.parentOffset) !== rest) {
-		view.dispatch(deflt().scrollIntoView());
+		view.dispatch(fallback().scrollIntoView());
 		return true;
 	}
 	const rules = state.plugins.filter(isInputRules);
@@ -44836,7 +45200,7 @@ function insertTextChunk(view, from, to, text, deflt) {
 		schema: state.schema,
 		doc: tr.doc,
 		selection: TextSelection.create(tr.doc, at),
-		storedMarks: state.storedMarks ?? (from === to ? $from.marks() : $from.marksAcross($to))
+		storedMarks: typing && typing.linked < text.length ? typing.link.removeFromSet(marks) : marks
 	}, rest);
 	let ruled;
 	const preparedView = Object.create(view, {
@@ -44846,7 +45210,7 @@ function insertTextChunk(view, from, to, text, deflt) {
 		} }
 	});
 	if (!rules.some((rule) => rule.props.handleTextInput?.call(rule, preparedView, at, at, last, () => prepared.tr.insertText(last, at)))) {
-		const plain = deflt().scrollIntoView();
+		const plain = fallback().scrollIntoView();
 		view.dispatch(last === "-" ? insertedHyphen(plain) : plain);
 		return true;
 	}
@@ -44854,6 +45218,7 @@ function insertTextChunk(view, from, to, text, deflt) {
 		for (const step of ruled.steps) tr.step(step);
 		tr.setSelection(ruled.selection.map(tr.doc, StepMap.empty));
 		if (ruled.storedMarksSet) tr.setStoredMarks(ruled.storedMarks);
+		else if (typing?.stored) tr.setStoredMarks(typing.stored);
 		for (const rule of rules) {
 			const meta = ruled.getMeta(rule);
 			if (meta !== void 0) tr.setMeta(rule, meta);
@@ -44862,6 +45227,65 @@ function insertTextChunk(view, from, to, text, deflt) {
 	view.dispatch(tr.scrollIntoView());
 	return true;
 }
+function finishComposition(view, composing) {
+	const { state } = view;
+	const { start, link, retyped } = composing;
+	const end = state.selection.head;
+	if (view.isDestroyed || view.composing || state.doc !== composing.doc || !state.selection.empty || end <= start || !state.doc.resolve(start).sameParent(state.selection.$head)) return;
+	const text = state.doc.textBetween(start, end);
+	if (text.length !== end - start) return;
+	const space = retyped ? -1 : text.search(/\s/);
+	const linked = start + (space < 0 ? text.length : space);
+	const tr = state.tr;
+	if (linked > start) tr.addMark(start, linked, link);
+	const marks = link.type.removeFromSet(tr.doc.resolve(end).marks());
+	tr.setStoredMarks(linked === end ? link.addToSet(marks) : marks).setMeta(typingKey, retyped && linked === end ? link : null).setMeta("composition", composing.composition);
+	view.dispatch(tr);
+}
+var controlCharacters = /^[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]+$/;
+/** Typed text: chunks, control characters, and the link rule for typing and composition. */
+function textInputPlugin() {
+	let composing;
+	return new Plugin({
+		key: typingKey,
+		state: typingState,
+		props: {
+			handleTextInput: (view, from, to, text, deflt) => controlCharacters.test(text) || insertTypedText(view, from, to, text, deflt),
+			handleDOMEvents: {
+				compositionstart(view) {
+					if (view.composing) return false;
+					const { state } = view;
+					const { from, to } = state.selection;
+					const typing = linkTyping(state, from, to, "");
+					composing = typing?.stored && !view.isDestroyed ? {
+						link: typing.link,
+						retyped: typing.retyped,
+						start: from,
+						doc: state.doc
+					} : void 0;
+					return false;
+				},
+				compositionend(view) {
+					const ended = composing;
+					if (ended) setTimeout(() => {
+						if (composing !== ended) return;
+						composing = void 0;
+						finishComposition(view, ended);
+					});
+					return false;
+				}
+			}
+		},
+		appendTransaction(transactions, _old, state) {
+			if (composing && transactions.some((tr) => tr.docChanged)) for (const tr of transactions) {
+				composing.start = tr.mapping.map(composing.start, -1);
+				composing.composition ??= tr.getMeta("composition");
+			}
+			if (composing) composing.doc = state.doc;
+			return null;
+		}
+	});
+}
 //#endregion
 //#region src/drop-placement.ts
 /**
@@ -44977,6 +45401,95 @@ function caretAfterInsertion(tr, view) {
 	return tr.setSelection($end.parent.inlineContent ? TextSelection.create(tr.doc, end) : caretAfter(tr.doc, end, view && calloutFolds(view, tr)));
 }
 //#endregion
+//#region src/parser.ts
+/**
+* Milkdown's parser state, except that it throws where Milkdown would drop content. Milkdown
+* catches the failure to build a node (`createNodeInParserFail`), logs it and carries on without
+* the node and everything inside it, so the document it returns can silently lack part of its
+* source.
+*/
+var CheckedParserState = class extends ParserState {
+	constructor(schema) {
+		super(schema);
+		const closeNode = this.closeNode;
+		const addNode = this.addNode;
+		const unbuildable = (type, attrs, content) => {
+			try {
+				return !type.createAndFill(attrs, content);
+			} catch {
+				return true;
+			}
+		};
+		this.closeNode = () => {
+			const element = this.top();
+			if (!element || this.size() < 2 || unbuildable(element.type, element.attrs, element.content)) throw new Error(`Cannot build ${element?.type.name ?? "a node"}`);
+			return closeNode();
+		};
+		this.addNode = (type, attrs, content) => {
+			if (!this.top() || unbuildable(type, attrs, content)) throw new Error(`Cannot build ${type.name}`);
+			return addNode(type, attrs, content);
+		};
+	}
+};
+/** The document, or undefined when Milkdown cannot build all of it. */
+function build(schema, tree) {
+	try {
+		return new CheckedParserState(schema).next(tree).toDoc();
+	} catch {
+		return;
+	}
+}
+/**
+* Parses Markdown as Milkdown does, but never returns a document that lacks part of its source.
+* A top-level block that cannot be built is kept as its literal source, as unsupported syntax is,
+* so the rest of the document stays editable; when that is not enough, it throws `preservation`.
+*/
+function parseMarkdown(schema, remark, markdown, parsedTree) {
+	const tree = parsedTree ?? remark.runSync(remark.parse(markdown), markdown);
+	const doc = build(schema, tree);
+	if (doc) return doc;
+	const source = markdown.replace(/^\uFEFF/, "");
+	tree.children = tree.children.map((node) => {
+		if (build(schema, {
+			type: "root",
+			children: [node]
+		})) return node;
+		const start = node.position?.start.offset;
+		const end = node.position?.end.offset;
+		if (start == null || end == null) return node;
+		const value = source.slice(start, end);
+		return {
+			type: "inkkitLiteral",
+			value,
+			comments: literalCommentSpans(value),
+			position: node.position
+		};
+	});
+	const kept = build(schema, tree);
+	if (kept) return kept;
+	throw new InkKitError("preservation", "The Markdown cannot be shown without losing part of it");
+}
+/** Replaces Milkdown's parser with `parseMarkdown`, for every caller of `parserCtx`. */
+var checkedParser = (ctx) => async () => {
+	await ctx.wait(ParserReady);
+	const schema = ctx.get(schemaCtx);
+	ctx.set(parserCtx, (markdown) => parseMarkdown(schema, ctx.get(remarkCtx), markdown));
+};
+//#endregion
+//#region src/gutter.ts
+var listMarker = /(?:[-*+]|\d{1,9}[.)])(?=[ \t])/g;
+/**
+* What the lines of a block repeat before it: the quote markers and
+* indentation that open the line `offset` is on, up to `offset`, with a list
+* marker as the spaces it takes, which is how the lines after the item's first
+* are indented. Anything else before `offset` on its line is content, and ends
+* the gutter.
+*/
+function gutterAt(text, offset) {
+	const line = text.slice(text.lastIndexOf("\n", offset - 1) + 1, offset);
+	return /^(?:[ \t]|>|(?:[-*+]|\d{1,9}[.)])(?=[ \t]))*/.exec(line)[0].replace(listMarker, (marker) => " ".repeat(marker.length));
+}
+//#endregion
 //#region src/code-fences.ts
 function readFence(value) {
 	if (typeof value !== "object" || value == null) return null;
@@ -45368,10 +45881,11 @@ var formatting = /* @__PURE__ */ new Set([
 	"delete",
 	"highlight"
 ]);
+var linkTypes = /* @__PURE__ */ new Set(["link", "linkReference"]);
 function ordered(node) {
 	let current = node;
 	const inner = current.children?.[0];
-	if (current.type === "link" && current.children.length === 1 && formatting.has(inner.type)) current = {
+	if (linkTypes.has(current.type) && current.children.length === 1 && formatting.has(inner.type)) current = {
 		...inner,
 		children: [{
 			...current,
@@ -45383,6 +45897,32 @@ function ordered(node) {
 		children: current.children.map(ordered)
 	} : current;
 }
+function wrappers$1(node) {
+	const chain = [];
+	for (let at = node; at && (linkTypes.has(at.type) || formatting.has(at.type)); at = at.children?.length === 1 ? at.children[0] : void 0) chain.push(at);
+	return chain;
+}
+function authoredNesting(before, after) {
+	if (before.type === after.type || !formatting.has(before.type)) return after;
+	const authored = wrappers$1(before);
+	const written = wrappers$1(after);
+	const types = (chain) => chain.map((node) => node.type).sort().join();
+	const linksIn = (chain) => chain.filter((node) => linkTypes.has(node.type));
+	const shape = (node) => ownShape({
+		...node,
+		children: []
+	});
+	const [authoredLink] = linksIn(authored);
+	const [writtenLink] = linksIn(written);
+	if (linksIn(authored).length !== 1 || linksIn(written).length !== 1 || types(authored) !== types(written) || shape(authoredLink) !== shape(writtenLink) || authored.at(-1).children?.length !== written.at(-1).children?.length) return after;
+	const inner = written.at(-1).children;
+	const byType = new Map(written.map((node) => [node.type, node]));
+	return authored.reduceRight((child, node, level) => ({
+		...byType.get(node.type),
+		...level === 0 && { position: after.position },
+		children: child ? [child] : inner
+	}), void 0);
+}
 /** Where the delimiter row ends, given where the header row before it ends. */
 function delimiterRowEnd(text, headerEnd) {
 	const next = text.indexOf("\n", headerEnd);
@@ -45391,15 +45931,17 @@ function delimiterRowEnd(text, headerEnd) {
 	ending.lastIndex = next + 1;
 	return ending.exec(text)?.index ?? text.length;
 }
-function ownShape(node) {
+function ownShape(node, spreadless = false) {
 	return JSON.stringify(ordered(node), (key, value) => [
 		"position",
 		"data",
 		"children",
 		"value",
 		"marker"
-	].includes(key) ? void 0 : value);
+	].includes(key) || spreadless && key === "spread" ? void 0 : value);
 }
+var holdsLiteralBlock = (node) => (node.type === "listItem" || node.type === "list") && !!node.children?.some((child) => child.type === "inkkitLiteral" || literals$1.has(child) || holdsLiteralBlock(child));
+var sameShape = (before, after) => ownShape(before) === ownShape(after) || (holdsLiteralBlock(before) || holdsLiteralBlock(after)) && ownShape(before, true) === ownShape(after, true);
 var matchShape = (node) => ownShape({
 	...node,
 	checked: void 0
@@ -45456,10 +45998,25 @@ function authoredMarker(list, source) {
 	return at == null ? void 0 : markerAt(source, at)?.marker;
 }
 var sameList = (before, after) => before.type === "list" && after.type === "list" && before.ordered === after.ordered;
-function canonicalSlice(marker, children, canonical, from, to, previous, next) {
+function childGutters(before, after, source, canonical, fromStart = false) {
+	if (inlineParents.has(before.type) || before.type === "table") return void 0;
+	const [first, now] = [before, after].map((node) => fromStart ? node.position?.start.offset : node.children?.[0]?.position?.start.offset);
+	return first == null || now == null ? void 0 : [gutterAt(source, first), gutterAt(canonical, now)];
+}
+function regutter(text, gutters, open = false) {
+	if (!gutters || gutters[0] === gutters[1]) return text;
+	const [authored, canonical] = gutters;
+	const bare = canonical.trimEnd();
+	return text.replace(/(\r?\n)([^\r\n]*)/g, (match, ending, line, at) => {
+		if (open && at + match.length === text.length && (line === bare || line === canonical)) return ending + authored;
+		if (line === bare) return ending + authored.trimEnd();
+		return line.startsWith(canonical) ? ending + authored + line.slice(canonical.length) : match;
+	});
+}
+function canonicalSlice(marker, children, canonical, from, to, previous, next, gutters, open = false, inherited) {
 	let text = canonical.slice(from, to);
 	const offsets = (list) => (list.children ?? []).map((item) => item.position.start.offset - from);
-	if (marker) return relabel(text, children.map((item) => item.position.start.offset - from), marker);
+	if (marker) return regutter(relabel(text, children.map((item) => item.position.start.offset - from), marker), gutters, open);
 	children.forEach((child, index) => {
 		if (child.type !== "list") {
 			previous = void 0;
@@ -45467,19 +46024,24 @@ function canonicalSlice(marker, children, canonical, from, to, previous, next) {
 		}
 		const avoid = [previous, index === children.length - 1 ? next : void 0].filter((neighbour) => neighbour?.ordered === child.ordered).map((neighbour) => neighbour.marker);
 		const own = markerAt(canonical, child.children[0].position.start.offset)?.marker;
-		const choice = [own, ...child.ordered ? [".", ")"] : [
-			"-",
-			"*",
-			"+"
-		]].find((candidate) => candidate && !avoid.includes(candidate));
+		const choice = [
+			inherited && /[.)]/.test(inherited) === !!child.ordered ? inherited : void 0,
+			own,
+			...child.ordered ? [".", ")"] : [
+				"-",
+				"*",
+				"+"
+			]
+		].find((candidate) => candidate && !avoid.includes(candidate));
 		if (choice) text = relabel(text, offsets(child), choice);
 		previous = {
 			ordered: child.ordered,
 			marker: choice ?? own ?? ""
 		};
 	});
-	return text;
+	return regutter(text, gutters, open);
 }
+var itemMarker = (item, source) => item.type === "listItem" ? markerAt(source, item.position.start.offset)?.marker : void 0;
 function authoredNeighbour(before, after, source) {
 	if (!before || !after || !sameList(before, after)) return void 0;
 	const marker = authoredMarker(before, source);
@@ -45579,35 +46141,90 @@ function retainSplit(candidates, after, source, canonical, lineEnding, taken) {
 		text: retainSource(part, after, source, canonical, lineEnding)
 	};
 }
-function retainParts(marker, before, after, source, canonical, from, to, lineEnding, previous, next) {
-	let items;
+function liftedSource(blocks, after, source) {
+	if (after.type === "list" || after.type === "blockquote") return void 0;
+	const wanted = signature(after);
+	const found = [];
+	const visit = (node) => {
+		for (const child of node.children ?? []) if (child.type === "list" || child.type === "listItem" || child.type === "blockquote") visit(child);
+		else if ((node.type === "blockquote" || node.type === "listItem" && node.checked == null) && signature(child) === wanted) found.push(child);
+	};
+	blocks.forEach(visit);
+	if (found.length !== 1) return void 0;
+	const start = found[0].position?.start.offset;
+	const end = found[0].position?.end.offset;
+	if (start == null || end == null) return void 0;
+	return regutter(source.slice(start, end), ["", gutterAt(source, start)]);
+}
+function strayRun(strays, wanted, source, opening) {
+	const keys = wanted.map(opening);
+	for (const [at, stray] of strays.entries()) {
+		if (opening(stray) !== keys[0]) continue;
+		const run = [stray];
+		for (const next of strays.slice(at + 1)) {
+			if (opening(next) !== keys[run.length] || !/^[ \t>]*(\r?\n[ \t>]*)+$/.test(source.slice(run.at(-1).position.end.offset, next.position.start.offset))) break;
+			run.push(next);
+		}
+		return run;
+	}
+	return [];
+}
+function retainParts(marker, before, after, source, canonical, from, to, lineEnding, previous, next, gutters, open = false, inherited) {
 	const taken = /* @__PURE__ */ new Set();
 	const opening = (item) => item.children?.length ? matchShape(item) + signature(item.children[0]) : void 0;
-	const pieces = after.map((child) => {
+	const items = /* @__PURE__ */ new Map();
+	for (let row = before; row.length;) {
+		const deeper = [];
+		for (const node of row) {
+			if (node.type !== "listItem") continue;
+			const key = opening(node);
+			if (key) {
+				const same = items.get(key);
+				if (same) same.push(node);
+				else items.set(key, [node]);
+			}
+			for (const child of node.children ?? []) if (child.type === "list") deeper.push(...child.children ?? []);
+		}
+		row = deeper;
+	}
+	const isNumbered = (item) => /[.)]/.test(itemMarker(item, source) ?? "");
+	const originals = after.map((child) => {
+		const original = child.type === "listItem" ? items.get(opening(child) ?? "")?.shift() : void 0;
+		return original && marker && isNumbered(original) !== /[.)]/.test(marker) ? void 0 : original;
+	});
+	const ownLevel = new Set(before);
+	const strays = [...items.values()].flat().sort((left, right) => left.position.start.offset - right.position.start.offset);
+	const pieces = after.map((child, index) => {
 		const end = child.position.end.offset;
 		if (child.type === "list" || child.type === "blockquote") {
 			const part = retainSplit(before, child, source, canonical, lineEnding, taken);
 			if (part) return part.text + canonical.slice(child.children.at(-1).position.end.offset, end);
 			const lists = before.filter((node) => node.type === "list" && node.ordered === child.ordered);
-			return child.type === "list" && lists.length ? retainParts(authoredMarker(lists[0], source), lists.flatMap((list) => list.children ?? []), child.children, source, canonical, child.position.start.offset, end, lineEnding) : void 0;
-		}
-		if (child.type !== "listItem") return void 0;
-		if (!items) {
-			items = /* @__PURE__ */ new Map();
-			for (const node of before) {
-				const key = node.type === "listItem" ? opening(node) : void 0;
-				if (!key) continue;
-				const same = items.get(key);
-				if (same) same.push(node);
-				else items.set(key, [node]);
+			if (child.type === "list" && !lists.length) {
+				const run = strayRun(strays, child.children, source, opening);
+				if (!run.length) return void 0;
+				const first = run[0].position.start.offset;
+				return regutter(retainSource({
+					type: "list",
+					ordered: child.ordered,
+					start: child.ordered ? Number(/^\d+/.exec(source.slice(first))[0]) : null,
+					spread: false,
+					children: run,
+					position: {
+						start: { offset: first },
+						end: { offset: run.at(-1).position.end.offset }
+					}
+				}, child, source, canonical, lineEnding), gutters && [gutters[0], gutterAt(source, first)]) + canonical.slice(child.children.at(-1).position.end.offset, end);
 			}
+			return child.type === "list" && lists.length ? retainParts(authoredMarker(lists[0], source), lists.flatMap((list) => list.children ?? []), child.children, source, canonical, child.position.start.offset, end, lineEnding, void 0, void 0, childGutters(lists[0], child, source, canonical)) : void 0;
 		}
-		const original = items.get(opening(child) ?? "")?.shift();
-		const text = original ? retainSource(original, child, source, canonical, lineEnding) : child.children?.some((node) => node.type === "list" || node.type === "blockquote") ? retainParts(void 0, before.flatMap((node) => node.type === "listItem" ? node.children ?? [] : []), child.children, source, canonical, child.position.start.offset, end, lineEnding) : void 0;
+		if (child.type !== "listItem") return void 0;
+		const original = originals[index];
+		const text = original ? regutter(retainSource(original, child, source, canonical, lineEnding, false, void 0, void 0, strays), gutters && [gutters[0], gutterAt(source, original.position.start.offset)]) : child.children?.some((node) => node.type === "list" || node.type === "blockquote") ? retainParts(void 0, before.flatMap((node) => node.type === "listItem" ? node.children ?? [] : []), child.children, source, canonical, child.position.start.offset, end, lineEnding, void 0, void 0, childGutters(before.find((node) => node.type === "listItem"), child, source, canonical)) : void 0;
 		return text !== void 0 && marker ? relabel(text, [0], marker) : text;
 	});
 	if (pieces.every((piece) => piece === void 0)) return void 0;
-	let text = "", at = from;
+	let text = "", at = from, lastNumber;
 	after.forEach((child, index) => {
 		const childStart = child.position.start.offset;
 		const childEnd = child.position.end.offset;
@@ -45615,15 +46232,18 @@ function retainParts(marker, before, after, source, canonical, from, to, lineEnd
 		let piece = pieces[index];
 		const own = piece && markerAt(piece, 0)?.marker;
 		if (child.type === "list" && [previous, following].some((neighbour) => neighbour?.ordered === child.ordered && neighbour?.marker === own)) piece = void 0;
-		piece ??= canonicalSlice(marker, [child], canonical, childStart, childEnd, previous, following);
+		const number = /^\d+/.exec(piece ?? "")?.[0];
+		if (piece && number && marker && lastNumber !== void 0 && originals[index] && !ownLevel.has(originals[index]) && String(lastNumber + 1).length === number.length) piece = String(lastNumber + 1) + piece.slice(number.length);
+		piece ??= canonicalSlice(marker, [child], canonical, childStart, childEnd, previous, following, gutters, false, inherited);
+		lastNumber = child.type === "listItem" && /^\d/.test(piece) ? Number(/^\d+/.exec(piece)[0]) : void 0;
 		previous = child.type === "list" ? {
 			ordered: child.ordered,
 			marker: markerAt(piece, /^[ \t]*/.exec(piece)[0].length)?.marker ?? ""
 		} : void 0;
-		text += canonical.slice(at, childStart) + piece;
+		text += regutter(canonical.slice(at, childStart), gutters, true) + piece;
 		at = childEnd;
 	});
-	return text + canonical.slice(at, to);
+	return text + regutter(canonical.slice(at, to), gutters, open);
 }
 function decodedOffsets(raw, lines = false) {
 	const offsets = [0];
@@ -45631,7 +46251,7 @@ function decodedOffsets(raw, lines = false) {
 	for (let index = 0; index < raw.length;) {
 		const rest = raw.slice(index);
 		const line = /[ \t]/.test(raw[index - 1] ?? "") && /[ \t]/.test(raw[index]) ? void 0 : /^[ \t]*(?:\r\n?|\n)(?:[ \t]*>)*[ \t]*/.exec(rest)?.[0];
-		const token = line ?? /^\\[!"#$%&'()*+,\-./:;<=>?@[\]\\^_`{|}~]/.exec(rest)?.[0] ?? /^&(?:#[xX][\da-fA-F]+|#\d+|[A-Za-z][A-Za-z\d]+);/.exec(rest)?.[0];
+		let token = line ?? /^\\[!"#$%&'()*+,\-./:;<=>?@[\]\\^_`{|}~]/.exec(rest)?.[0] ?? /^&(?:#[xX][\da-fA-F]+|#\d+|[A-Za-z][A-Za-z\d]+);/.exec(rest)?.[0];
 		let value = raw[index];
 		if (line) {
 			if (!lines) return void 0;
@@ -45640,7 +46260,8 @@ function decodedOffsets(raw, lines = false) {
 		else if (token) {
 			const element = document.createElement("textarea");
 			element.innerHTML = token;
-			value = element.value;
+			if (element.value === token) token = void 0;
+			else value = element.value;
 		}
 		index += token?.length ?? 1;
 		decoded += value;
@@ -45757,7 +46378,10 @@ function retainRun(before, after, source, canonical, [from, to], [newFrom, newTo
 	}
 	return source.slice(from, old.offsets[prefix]) + canonical.slice(now.offsets[prefix], now.offsets[b.length - suffix]) + (now.breaks.has(b.length - suffix - 1) ? retainBoundaryText(source.slice(old.offsets[a.length - suffix], to), canonical.slice(now.offsets[b.length - suffix], newTo), true) : source.slice(old.offsets[a.length - suffix], to));
 }
-function retainText(raw, before, after, inTable = false, written, beside = [false, false]) {
+function retainText(raw, before, after, inTable = false, written, beside = [false, false], readGutters) {
+	let found;
+	const gutters = () => found ??= readGutters?.();
+	const guttered = (text) => text.includes("\n") ? regutter(text, gutters()) : text;
 	before = lf(before);
 	after = lf(after);
 	let prefix = 0;
@@ -45775,19 +46399,34 @@ function retainText(raw, before, after, inTable = false, written, beside = [fals
 			const marker = /^(?:\d+)?\\[#+.\->)]/.exec(opening)?.[0];
 			if (marker && prefix - lineStart <= decodedOffsets(marker).decoded.length) {
 				prefix = lineStart;
-				return raw.slice(0, offsets[prefix]) + written.slice(canonical.offsets[prefix], canonical.offsets[after.length - suffix]) + raw.slice(offsets[before.length - suffix]);
+				return raw.slice(0, offsets[prefix]) + guttered(written.slice(canonical.offsets[prefix], canonical.offsets[after.length - suffix])) + raw.slice(offsets[before.length - suffix]);
 			}
 		}
 	}
 	if (written !== void 0 && (beside[0] && prefix === 0 || beside[1] && suffix === 0)) {
 		const writtenOffsets = decodedOffsets(written);
-		if (writtenOffsets && writtenOffsets.decoded === after) return raw.slice(0, offsets[prefix]) + written.slice(writtenOffsets.offsets[prefix], writtenOffsets.offsets[after.length - suffix]) + raw.slice(offsets[before.length - suffix]);
+		if (writtenOffsets && writtenOffsets.decoded === after) return raw.slice(0, offsets[prefix]) + guttered(written.slice(writtenOffsets.offsets[prefix], writtenOffsets.offsets[after.length - suffix])) + raw.slice(offsets[before.length - suffix]);
 	}
 	const inserted = after.slice(prefix, after.length - suffix).split("").map((character, index) => {
 		const at = prefix + index;
-		return (character === "%" || character === "=") && (after[at - 1] === character || after[at + 1] === character) || /[\\`*_[\]<>]/.test(character) || inTable && character === "|" ? `\\${character}` : character;
+		return (character === "%" || character === "=") && (after[at - 1] === character || after[at + 1] === character) || /[\\`*_[\]<>]/.test(character) || inTable && character === "|" ? `\\${character}` : character === "\n" ? character + (gutters()?.[0] ?? "") : character;
 	}).join("");
-	return raw.slice(0, offsets[prefix]) + inserted + raw.slice(offsets[before.length - suffix]);
+	return escapeReferences(raw.slice(0, offsets[prefix]), inserted, raw.slice(offsets[before.length - suffix]));
+}
+var characterReference = /&(?:#[xX][\da-fA-F]+|#\d+|[A-Za-z][A-Za-z\d]*);/g;
+function escapeReferences(head, inserted, tail) {
+	const text = head + inserted + tail;
+	const from = head.length;
+	const to = from + inserted.length;
+	let output = "", at = 0;
+	for (const match of text.matchAll(characterReference)) {
+		const start = match.index;
+		const end = start + match[0].length;
+		if (start >= to || end <= from || (/\\*$/.exec(text.slice(0, start))[0].length & 1) === 1) continue;
+		output += text.slice(at, end - 1) + "\\";
+		at = end - 1;
+	}
+	return output + text.slice(at);
 }
 function retainBoundaryText(raw, canonical, afterBreak = false) {
 	if (afterBreak) {
@@ -45984,6 +46623,7 @@ function markLiterals(raw, transformed, blocks = []) {
 	raw.children.forEach(mark);
 }
 function retainSource(before, after, source, canonical, lineEnding, inTable = false, width, beside = [false, false], joined = [], reorder, afterBreak = false) {
+	after = authoredNesting(before, after);
 	if (literals$1.has(after)) return withEnding(retainLiteral(source.slice(before.position.start.offset, before.position.end.offset), literalForms.get(before), lf(canonical.slice(after.position.start.offset, after.position.end.offset))), lineEnding);
 	if (before.type === "list" && after.type === "list" && before.ordered && after.ordered && !numbered.has(before) && before.position?.start.offset != null) {
 		const own = {
@@ -46080,15 +46720,20 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
 		const to = first.position.end.offset - start;
 		return retained.startsWith(source.slice(start, before.children[1].position.start.offset)) ? retained.slice(0, from) + "<br />" + retained.slice(to) : retained;
 	}
-	if (before.type === "text" && after.type === "text") return retainBoundaryText(withEnding(retainText(raw, before.value, after.value, inTable, canonical.slice(newStart, newEnd), beside), lineEnding), canonical.slice(newStart, newEnd), afterBreak);
+	if (before.type === "text" && after.type === "text") return retainBoundaryText(withEnding(retainText(raw, before.value, after.value, inTable, canonical.slice(newStart, newEnd), beside, () => [gutterAt(source, start), gutterAt(canonical, newStart)]), lineEnding), canonical.slice(newStart, newEnd), afterBreak);
 	if (signature(before) === signature(after) && ownShape(before) === ownShape(after) && !holdsLiteral(after) && !reorderedWithin(before, reorder)) return raw;
+	if (before.type !== after.type) {
+		const lifted = liftedSource([before], after, source);
+		if (lifted !== void 0) return lifted;
+	}
 	const marker = sameList(before, after) ? authoredMarker(before, source) : void 0;
 	const located = (nodes) => nodes.every((node) => node.position?.start.offset != null);
-	if (before.type === after.type && ownShape(before) === ownShape(after) && before.children && after.children && before.children.length === after.children.length && located(before.children) && located(after.children)) {
+	if (before.type === after.type && sameShape(before, after) && before.children && after.children && before.children.length === after.children.length && located(before.children) && located(after.children)) {
 		let output = "", at = start;
 		let previous;
 		const same = (candidate, incoming) => signature(candidate) === signature(incoming) && ownShape(candidate) === ownShape(incoming);
 		const reorderable = before.type === "table" || before.type === "tableRow";
+		const gutters = childGutters(before, after, source, canonical);
 		const moves = reorder?.get(parentKey(before));
 		const retained = new Set(reorderable ? before.children.flatMap((child, index) => same(child, after.children[index]) ? [index] : []) : []);
 		before.children.forEach((child, index) => {
@@ -46099,7 +46744,7 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
 			if (movedIndex >= 0) retained.add(movedIndex);
 			const childStart = child.position?.start.offset, childEnd = child.position?.end.offset;
 			if (childStart == null || childEnd == null) throw new PreservationError("A source token has no location");
-			let retainedSource = rewrittenAddress(before.type, before.children, movedIndex < 0 ? index : movedIndex, after.children, index, source, canonical) ? canonical.slice(incoming.position.start.offset, incoming.position.end.offset) : incoming.type === "list" && !sameList(original, incoming) ? withEnding(canonicalSlice(void 0, [incoming], canonical, incoming.position.start.offset, incoming.position.end.offset, previous, authoredNeighbour(before.children[index + 1], after.children[index + 1], source)), lineEnding) : retainSource(original, incoming, source, canonical, lineEnding, inTable || before.type === "tableCell", before.type === "table" ? before.children[0]?.children?.length : void 0, [after.children[index - 1]?.type === "link", after.children[index + 1]?.type === "link"], [], reorder, after.children[index - 1]?.type === "break");
+			let retainedSource = rewrittenAddress(before.type, before.children, movedIndex < 0 ? index : movedIndex, after.children, index, source, canonical) ? regutter(canonical.slice(incoming.position.start.offset, incoming.position.end.offset), gutters) : incoming.type === "list" && !sameList(original, incoming) ? withEnding(canonicalSlice(void 0, [incoming], canonical, incoming.position.start.offset, incoming.position.end.offset, previous, authoredNeighbour(before.children[index + 1], after.children[index + 1], source), gutters), lineEnding) : retainSource(original, incoming, source, canonical, lineEnding, inTable || before.type === "tableCell", before.type === "table" ? before.children[0]?.children?.length : void 0, [after.children[index - 1]?.type === "link", after.children[index + 1]?.type === "link"], joined, reorder, after.children[index - 1]?.type === "break");
 			if (before.type === "tableRow" && movedIndex >= 0 && movedIndex !== index) {
 				const originalFrom = original.children?.[0]?.position?.start.offset;
 				const originalTo = original.children?.at(-1)?.position?.end.offset;
@@ -46118,7 +46763,7 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
 		});
 		return output + source.slice(at, end);
 	}
-	if (before.type === after.type && ownShape(before) === ownShape(after) && before.children && after.children) {
+	if (before.type === after.type && sameShape(before, after) && before.children && after.children) {
 		let prefix = 0, suffix = 0;
 		while (prefix < before.children.length && prefix < after.children.length && signature(before.children[prefix]) === signature(after.children[prefix])) prefix++;
 		while (suffix < before.children.length - prefix && suffix < after.children.length - prefix && signature(before.children[before.children.length - 1 - suffix]) === signature(after.children[after.children.length - 1 - suffix])) suffix++;
@@ -46143,13 +46788,15 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
 			const changes = after.children.slice(prefix, after.children.length - suffix);
 			const previous = authoredNeighbour(before.children[prefix - 1], after.children[prefix - 1], source);
 			const next = authoredNeighbour(before.children[before.children.length - suffix], after.children[after.children.length - suffix], source);
-			return source.slice(start, first) + retainBoundaryText(source.slice(first, from) + withEnding((inlineParents.has(before.type) ? retainRun(changed, changes, source, canonical, [from, to], [newFrom, newTo]) : retainParts(marker, [...changed, ...joined], changes, source, canonical, newFrom, newTo, lineEnding, previous, next)) ?? canonicalSlice(marker, changes, canonical, newFrom, newTo, previous, next), lineEnding) + (inlineParents.has(before.type) ? retainBoundaryText(source.slice(to, last), canonical.slice(newTo, newLast), after.children[after.children.length - suffix - 1]?.type === "break") : source.slice(to, last)), canonical.slice(newFirst, newLast)) + source.slice(last, end);
+			const gutters = childGutters(before, after, source, canonical, !prefix);
+			const inherited = itemMarker(before, source);
+			return source.slice(start, first) + retainBoundaryText(source.slice(first, from) + withEnding((inlineParents.has(before.type) ? retainRun(changed, changes, source, canonical, [from, to], [newFrom, newTo]) : retainParts(marker, [...changed, ...joined], changes, source, canonical, newFrom, newTo, lineEnding, previous, next, gutters, suffix > 0, inherited)) ?? canonicalSlice(marker, changes, canonical, newFrom, newTo, previous, next, gutters, suffix > 0, inherited), lineEnding) + (inlineParents.has(before.type) ? retainBoundaryText(source.slice(to, last), canonical.slice(newTo, newLast), after.children[after.children.length - suffix - 1]?.type === "break") : source.slice(to, last)), canonical.slice(newFirst, newLast)) + source.slice(last, end);
 		}
 	}
 	const lastAfter = after.children?.at(-1)?.position?.end.offset;
 	const lastBefore = before.children?.at(-1)?.position?.end.offset;
 	const trailing = marker != null && lastAfter != null && lastBefore != null && loose(before, source) === loose(after, canonical);
-	return withEnding(canonicalSlice(marker, after.children ?? [], canonical, newStart, trailing ? lastAfter : newEnd), lineEnding) + (trailing ? source.slice(lastBefore, end) : "");
+	return withEnding(canonicalSlice(marker, after.children ?? [], canonical, newStart, trailing ? lastAfter : newEnd, void 0, void 0, childGutters(before, after, source, canonical, true), false, itemMarker(before, source)), lineEnding) + (trailing ? source.slice(lastBefore, end) : "");
 }
 function loose(list, text) {
 	const blank = (from, to) => from != null && to != null && /\n[ \t>]*\r?\n/.test(text.slice(from, to));
@@ -46246,6 +46893,13 @@ function semanticSignature(doc) {
 				attrs
 			};
 		}
+		if (value.type === "comment_block" && value.attrs) {
+			const { block: _block, ...attrs } = value.attrs;
+			value = {
+				...value,
+				attrs
+			};
+		}
 		const content = value.content;
 		if (!content) return value;
 		const tokens = [];
@@ -46288,6 +46942,7 @@ function semanticSignature(doc) {
 		"authoredFence",
 		"form",
 		"inkkitFileRaw",
+		"inkkitFileSource",
 		"inkkitFileWidth",
 		"inkkitFileInTable"
 	].includes(key) ? void 0 : value));
@@ -46476,6 +47131,18 @@ var nothingCarried = {
 var Preservation = class Preservation {
 	ctx;
 	source;
+	static recent = /* @__PURE__ */ new WeakMap();
+	processor;
+	rawTree;
+	sourceTree;
+	static read(ctx, source) {
+		const cached = this.recent.get(ctx);
+		const previous = cached?.processor === ctx.get(remarkCtx) ? cached : void 0;
+		if (previous?.source === source) return previous;
+		const next = new Preservation(ctx, source, previous);
+		this.recent.set(ctx, next);
+		return next;
+	}
 	/** The document as loaded from `source`. */
 	baseline;
 	blocks = [];
@@ -46493,18 +47160,22 @@ var Preservation = class Preservation {
 	nestedLiterals = /* @__PURE__ */ new Set();
 	literalsRead = /* @__PURE__ */ new WeakSet();
 	definitionSources;
-	constructor(ctx, source) {
+	constructor(ctx, source, previous) {
 		this.ctx = ctx;
 		this.source = source;
 		try {
 			const parse = (text) => parseDoc(ctx, text);
-			this.baseline = parse(source);
-			this.lineEnding = source.includes("\r\n") && !source.replaceAll("\r\n", "").includes("\n") ? "\r\n" : "\n";
-			const processor = ctx.get(remarkCtx);
+			this.lineEnding = !source.includes("\n") ? source.includes("\r") ? "\r" : "\n" : source.includes("\r\n") && !source.replaceAll("\r\n", "").includes("\n") ? "\r\n" : "\n";
+			const processor = this.processor = ctx.get(remarkCtx);
 			const offset = source.startsWith("") ? 1 : 0;
 			const body = source.slice(offset);
-			const rawTree = parseTree(ctx, source);
-			const tree = processor.runSync(structuredClone(rawTree), { value: body });
+			const incremental = previous?.readEditedSource(source);
+			const rawTree = incremental?.raw ?? parseTree(ctx, source);
+			const tree = incremental?.tree ?? processor.runSync(structuredClone(rawTree), { value: body });
+			this.rawTree = rawTree;
+			this.sourceTree = tree;
+			this.baseline = incremental?.doc ?? parseMarkdown(ctx.get(schemaCtx), processor, source, structuredClone(tree));
+			const positions = new Map(rawTree.children.map((node) => [`${node.position?.start.offset}:${node.position?.end.offset}`, node]));
 			for (const [index, node] of tree.children.entries()) {
 				let start = node.position?.start.offset;
 				const end = node.position?.end.offset;
@@ -46516,9 +47187,9 @@ var Preservation = class Preservation {
 				const text = source.slice(start, sourceEnd);
 				const own = this.baseline.childCount === tree.children.length;
 				const parsed = own ? this.baseline.type.create(null, [this.baseline.child(index)]) : parse(text);
-				const blockText = parsed.childCount === 1 ? blockForm(ctx, parsed.firstChild) : form(write(ctx, parsed));
+				const blockText = previous?.forms.get(parsed.firstChild) ?? (parsed.childCount === 1 ? blockForm(ctx, parsed.firstChild) : form(write(ctx, parsed)));
 				if (own) this.forms.set(this.baseline.child(index), blockText);
-				const ast = positionalNode(rawTree, node);
+				const ast = positions.get(`${node.position?.start.offset}:${node.position?.end.offset}`) ?? node;
 				if (parsed.childCount === 1 && parsed.firstChild.type.name === "literal_markdown") literalForms.set(ast, blockText);
 				this.blocks.push({
 					start,
@@ -46555,6 +47226,66 @@ var Preservation = class Preservation {
 			throw new PreservationError("Cannot read Markdown for preservation", { cause });
 		}
 	}
+	readEditedSource(source) {
+		if (this.source.startsWith("") || source.startsWith("") || /[\[\]<>%]/.test(this.source) || /[\[\]<>%]/.test(source) || this.blocks.length !== this.baseline.childCount || this.blocks.some((_, index) => !["paragraph", "heading"].includes(this.baseline.child(index).type.name))) return;
+		let prefix = 0, suffix = 0;
+		while (prefix < source.length && prefix < this.source.length && source[prefix] === this.source[prefix]) prefix++;
+		while (suffix < source.length - prefix && suffix < this.source.length - prefix && source[source.length - suffix - 1] === this.source[this.source.length - suffix - 1]) suffix++;
+		const first = Math.max(0, this.blocks.findIndex((block) => block.end >= prefix) - 1);
+		let last = this.blocks.findIndex((block) => block.start > this.source.length - suffix);
+		if (last < 0) last = this.blocks.length - 1;
+		else last = Math.min(this.blocks.length - 1, last + 1);
+		if (!this.blocks[first] || !this.blocks[last]) return;
+		const start = this.blocks[first].start;
+		const end = this.blocks[last].end;
+		const delta = source.length - this.source.length;
+		const nextEnd = end + delta;
+		if (nextEnd < start || prefix < start || this.source.length - suffix > end) return;
+		const part = new Preservation(this.ctx, source.slice(start, nextEnd));
+		if (part.blocks.length !== part.baseline.childCount || part.blocks.some((_, index) => !["paragraph", "heading"].includes(part.baseline.child(index).type.name))) return;
+		const lines = [0];
+		for (const match of source.matchAll(/\r\n|\r|\n/g)) lines.push(match.index + match[0].length);
+		const point = (offset) => {
+			let low = 0, high = lines.length;
+			while (low + 1 < high) {
+				const middle = low + high >> 1;
+				if (lines[middle] <= offset) low = middle;
+				else high = middle;
+			}
+			return {
+				offset,
+				line: low + 1,
+				column: offset - lines[low] + 1
+			};
+		};
+		const shifted = (node, amount) => {
+			const visit = (value) => {
+				if (Array.isArray(value)) return value.map(visit);
+				if (!value || typeof value !== "object") return value;
+				if ("offset" in value && typeof value.offset === "number") return point(value.offset + amount);
+				return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, visit(child)]));
+			};
+			return visit(node);
+		};
+		const splice = (old, fresh) => ({
+			type: "root",
+			children: [
+				...old.children.slice(0, first),
+				...fresh.children.map((node) => shifted(node, start)),
+				...old.children.slice(last + 1).map((node) => shifted(node, delta))
+			]
+		});
+		const children = [];
+		this.baseline.forEach((node, _offset, index) => {
+			if (index === first) part.baseline.forEach((child) => children.push(child));
+			if (index < first || index > last) children.push(node);
+		});
+		return {
+			raw: splice(this.rawTree, part.rawTree),
+			tree: splice(this.sourceTree, part.sourceTree),
+			doc: this.baseline.copy(Fragment.fromArray(children))
+		};
+	}
 	retainBlock(block, after, canonical, joined = [], reorder) {
 		const offset = this.source.startsWith("") ? 1 : 0;
 		const start = block.ast.position?.start.offset;
@@ -46594,6 +47325,9 @@ var Preservation = class Preservation {
 		const indent = source.slice(source.lastIndexOf("\n", part.from - 1) + 1, part.from);
 		return (/^[ \t]*$/.test(indent) ? indent : "") + part.text;
 	}
+	retainLifted(positions, index, after) {
+		return liftedSource(this.around(positions, index).map((block) => block.ast), after, this.source.slice(this.source.startsWith("") ? 1 : 0));
+	}
 	localEdits(doc) {
 		if (this.baseline.childCount !== this.blocks.length || doc.childCount !== this.blocks.length || !doc.sameMarkup(this.baseline)) return void 0;
 		let output = "", previous = 0;
@@ -46688,7 +47422,7 @@ var Preservation = class Preservation {
 	static plainInline(node) {
 		let plain = true;
 		node.descendants((child) => {
-			if (child.isInline && !child.isText && child.type.name !== "hardbreak") plain = false;
+			if (child.isInline && !child.isText && !["hardbreak", "footnote_reference"].includes(child.type.name)) plain = false;
 			return plain;
 		});
 		return plain;
@@ -46972,6 +47706,12 @@ var Preservation = class Preservation {
 		const block = position == null ? void 0 : this.blocks[position];
 		if (index === 0) return position === 0 && block ? this.source.slice(0, block.start) : this.source.startsWith("") ? "" : "";
 		const previous = positions[index - 1];
+		if (previous === this.blocks.length - 1 && position == null) {
+			const ending = this.source.slice(this.blocks[previous].end);
+			const lines = ending.replace(/\r\n?/g, "\n");
+			if (/\n[ \t]*\n/.test(lines)) return ending + (lines.endsWith("\n") ? "" : this.lineEnding);
+			return ending + this.lineEnding.repeat(lines.endsWith("\n") ? 1 : 2);
+		}
 		return previous != null && position === previous + 1 && block ? this.source.slice(this.blocks[previous].end, block.start) : this.lineEnding.repeat(2);
 	}
 	build(doc, positions, current, carried, from, to, canonical, tree) {
@@ -47008,7 +47748,7 @@ var Preservation = class Preservation {
 			const kind = block && block.form === text && !carried.within.has(index) ? position == null ? "moved" : "unchanged" : block && tree && position != null ? "edited" : "canonical";
 			kept.push(kind);
 			const node = tree ? positionalNode(tree.raw, transformed(index)) : void 0;
-			pieces.push(kind === "unchanged" || kind === "moved" ? this.source.slice(block.start, block.end) : kind === "edited" ? this.retainingForms(block, doc.child(index), () => this.retainBlock(block, node, canonical, this.around(positions, index).filter((other) => !paired.has(other) && other.ast.type === block.ast.type).flatMap((other) => other.ast.children ?? []), carried.children ? this.carriedChildren(doc.child(index), position) : void 0)) : (node && this.retainPart(positions, index, node, canonical, taken)) ?? restoreCodeEndings(this.ctx, doc.type.create(null, [doc.child(index)]), withEnding(text, this.lineEnding)));
+			pieces.push(kind === "unchanged" || kind === "moved" ? this.source.slice(block.start, block.end) : kind === "edited" ? this.retainingForms(block, doc.child(index), () => this.retainBlock(block, node, canonical, this.around(positions, index).filter((other) => !paired.has(other) && other.ast.type === block.ast.type).flatMap((other) => other.ast.children ?? []), carried.children ? this.carriedChildren(doc.child(index), position) : void 0)) : (node && (this.retainPart(positions, index, node, canonical, taken) ?? this.retainLifted(positions, index, node))) ?? restoreCodeEndings(this.ctx, doc.type.create(null, [doc.child(index)]), withEnding(text, this.lineEnding)));
 		}
 		return {
 			gaps,
@@ -47544,23 +48284,6 @@ function completedAngle(tr, chars, from, to) {
 		form: "angle"
 	})).removeStoredMark(tr.doc.type.schema.marks.link);
 }
-function closeAngleEnds(tr, transactions) {
-	const steps = transactions.flatMap((transaction) => transaction.steps.map((step, index) => ({
-		doc: transaction.docs[index],
-		map: step.getMap()
-	})));
-	steps.forEach(({ doc, map }, index) => {
-		const remaining = new Mapping(steps.slice(index + 1).map(({ map }) => map));
-		map.forEach((from, to, start, end) => {
-			if (from !== to || start === end) return;
-			const at = doc.resolve(from);
-			const before = at.nodeBefore?.marks.find((mark) => mark.attrs.form === "angle");
-			const after = at.nodeAfter?.marks.find((mark) => mark.attrs.form === "angle");
-			if (before && after && before.eq(after)) return;
-			for (const mark of [before, after]) if (mark) tr.removeMark(remaining.map(start, 1), remaining.map(end, -1), mark);
-		});
-	});
-}
 function codeAngles(tr, edited) {
 	const spans = [];
 	for (const block of edited) tr.doc.nodesBetween(block.pos, block.pos + block.block.nodeSize, (node, pos) => {
@@ -47769,10 +48492,7 @@ var autolinkLiterals = $prose((ctx) => new Plugin({
 		if (!transactions.some((tr) => tr.docChanged)) return null;
 		const base = newState.tr;
 		const written = transactions.every(isWrittenEdit);
-		if (written) {
-			closeAngleEnds(base, transactions);
-			codeAngles(base, editedBlocks(oldState.doc, base.doc));
-		}
+		if (written) codeAngles(base, editedBlocks(oldState.doc, base.doc));
 		let edited = editedBlocks(oldState.doc, base.doc);
 		if (written && edited.length === 1) {
 			const { pos, block, from, to } = edited[0];
@@ -48024,81 +48744,6 @@ function normalizeTableColumnAlignment(element) {
 	return normalizeTableAlignment(header ?? element);
 }
 //#endregion
-//#region src/parser.ts
-/**
-* Milkdown's parser state, except that it throws where Milkdown would drop content. Milkdown
-* catches the failure to build a node (`createNodeInParserFail`), logs it and carries on without
-* the node and everything inside it, so the document it returns can silently lack part of its
-* source.
-*/
-var CheckedParserState = class extends ParserState {
-	constructor(schema) {
-		super(schema);
-		const closeNode = this.closeNode;
-		const addNode = this.addNode;
-		const unbuildable = (type, attrs, content) => {
-			try {
-				return !type.createAndFill(attrs, content);
-			} catch {
-				return true;
-			}
-		};
-		this.closeNode = () => {
-			const element = this.top();
-			if (!element || this.size() < 2 || unbuildable(element.type, element.attrs, element.content)) throw new Error(`Cannot build ${element?.type.name ?? "a node"}`);
-			return closeNode();
-		};
-		this.addNode = (type, attrs, content) => {
-			if (!this.top() || unbuildable(type, attrs, content)) throw new Error(`Cannot build ${type.name}`);
-			return addNode(type, attrs, content);
-		};
-	}
-};
-/** The document, or undefined when Milkdown cannot build all of it. */
-function build(schema, tree) {
-	try {
-		return new CheckedParserState(schema).next(tree).toDoc();
-	} catch {
-		return;
-	}
-}
-/**
-* Parses Markdown as Milkdown does, but never returns a document that lacks part of its source.
-* A top-level block that cannot be built is kept as its literal source, as unsupported syntax is,
-* so the rest of the document stays editable; when that is not enough, it throws `preservation`.
-*/
-function parseMarkdown(schema, remark, markdown) {
-	const tree = remark.runSync(remark.parse(markdown), markdown);
-	const doc = build(schema, tree);
-	if (doc) return doc;
-	const source = markdown.replace(/^\uFEFF/, "");
-	tree.children = tree.children.map((node) => {
-		if (build(schema, {
-			type: "root",
-			children: [node]
-		})) return node;
-		const start = node.position?.start.offset;
-		const end = node.position?.end.offset;
-		if (start == null || end == null) return node;
-		const value = source.slice(start, end);
-		return {
-			type: "inkkitLiteral",
-			value,
-			comments: literalCommentSpans(value),
-			position: node.position
-		};
-	});
-	const kept = build(schema, tree);
-	if (kept) return kept;
-	throw new InkKitError("preservation", "The Markdown cannot be shown without losing part of it");
-}
-/** Replaces Milkdown's parser with `parseMarkdown`, for every caller of `parserCtx`. */
-var checkedParser = (ctx) => async () => {
-	await ctx.wait(ParserReady);
-	const schema = ctx.get(schemaCtx);
-	ctx.set(parserCtx, (markdown) => parseMarkdown(schema, ctx.get(remarkCtx), markdown));
-};
-//#endregion
 //#region src/callouts.ts
 var kinds = /* @__PURE__ */ new Set([
 	"NOTE",
@@ -48141,7 +48786,8 @@ function remarkCallouts() {
 		const visit = (node) => {
 			if (node.type === "blockquote") {
 				const start = node.position?.start.offset, end = node.position?.end.offset;
-				const raw = start == null || end == null ? "" : source.slice(start, end);
+				const gutter = start == null ? "" : gutterAt(source, start);
+				const raw = start == null || end == null ? "" : source.slice(start, end).replace(/(\r?\n)([^\r\n]*)/g, (line, eol, text) => gutter && text.startsWith(gutter) ? eol + text.slice(gutter.length) : line);
 				const header = /^>[ \t]*([\s\S]*?)(?:\r?\n|$)/.exec(raw)?.[1] ?? "";
 				if (header.startsWith("[!")) {
 					const match = /^(\[!([A-Za-z]+)\])([+-]?)(?:[ \t]+([^\r\n]*))?$/.exec(header);
@@ -48313,7 +48959,7 @@ var calloutView = $prose((ctx) => new Plugin({
 		const render = () => {
 			title.textContent = node.attrs.title || String(node.attrs.kind).toLowerCase().replace(/^./, (letter) => letter.toUpperCase());
 			dom.setAttribute("data-inkkit-folded", String(folded));
-			view.dom.dispatchEvent(new Event("inkkit-media-policy"));
+			view.dom.dispatchEvent(new Event(mediaPolicyEvent));
 			button.hidden = !node.attrs.fold;
 			button.setAttribute("aria-expanded", String(!folded));
 			button.setAttribute("aria-label", `${folded ? editorLabels(ctx).expandCallout : editorLabels(ctx).collapseCallout} ${title.textContent}`);
@@ -50080,12 +50726,50 @@ function writesBare(node, index, ancestors) {
 	return side(-1) && side(1);
 }
 var bareLinks = /* @__PURE__ */ new WeakSet();
+function linkFormatting(node) {
+	const plain = node.type === "link" && !formOf(node) || node.type === "linkReference" && node.referenceType === "full";
+	const [inner] = plain ? node.children : [];
+	return plain && node.children.length === 1 && inner && wrappers.has(inner.type) ? inner : void 0;
+}
+function shareFormatting(children) {
+	const same = (left, right) => {
+		const { children: _left, position: _a, ...leftRest } = left;
+		const { children: _right, position: _b, ...rightRest } = right;
+		return JSON.stringify(leftRest) === JSON.stringify(rightRest);
+	};
+	for (let index = 0; index < children.length; index++) {
+		const child = children[index];
+		const formatting = linkFormatting(child);
+		if (!formatting) continue;
+		const link = {
+			...child,
+			children: formatting.children
+		};
+		const previous = children[index - 1];
+		const next = children[index + 1];
+		const before = previous && same(previous, formatting);
+		const after = next && same(next, formatting);
+		if (!before && !after) continue;
+		const merged = {
+			...formatting,
+			children: [
+				...before ? previous.children : [],
+				link,
+				...after ? next.children : []
+			]
+		};
+		const from = before ? index - 1 : index;
+		children.splice(from, 1 + Number(before) + Number(after), merged);
+		index = from - 1;
+	}
+}
 var root = (node, parent, state, info) => {
 	bareLinks = /* @__PURE__ */ new WeakSet();
 	const empty = (child) => child.type === "text" && child.value === "" || wrappers.has(child.type) && "children" in child && child.children.every(empty);
 	const visit = (current, ancestors) => {
 		if (current.children.some((child) => empty(child))) current.children = current.children.filter((child) => !empty(child));
 		const children = current.children;
+		shareFormatting(children);
 		children.forEach((child, index) => {
 			if (child.type === "link" && formOf(child)) {
 				const outside = formattedOutside(child);
@@ -50306,6 +50990,16 @@ var breaksWithoutMarks = $prose((ctx) => new Plugin({
 	}
 }));
 var remarkLinkFormsPlugin = $remark("inkkitLinkForms", () => remarkLinkForms);
+var remarkFileSourcesPlugin = $remark("inkkitFileSources", () => remarkFileSources);
+var imageWriter = (ctx) => async () => {
+	await ctx.wait(SerializerReady);
+	const schema = ctx.get(schemaCtx);
+	setImageWriter(schema, (node) => {
+		node = node.mark([]);
+		const block = node.isBlock ? node : schema.nodes.paragraph.create(null, node);
+		return ctx.get(serializerCtx)(schema.topNodeType.create(null, block)).replace(/\n+$/, "");
+	});
+};
 var preserveSpacerParagraphs = paragraphSchema.extendSchema((base) => (ctx) => {
 	const schema = base(ctx);
 	return {
@@ -50436,7 +51130,16 @@ var normalizedImages = imageSchema.extendSchema((base) => (ctx) => {
 			...schema.toMarkdown,
 			runner(state, node) {
 				const raw = namedFileMarkdown(node, Boolean(node.attrs.inkkitFileInTable));
-				if (raw == null) return schema.toMarkdown.runner(state, node);
+				if (raw == null) {
+					state.addNode("image", void 0, void 0, {
+						url: node.attrs.src,
+						alt: node.attrs.alt,
+						title: node.attrs.title || null,
+						inkkitFileSource: authoredFileSource(node),
+						inkkitFileInTable: node.attrs.inkkitFileInTable
+					});
+					return;
+				}
 				state.addNode("image", void 0, void 0, {
 					url: node.attrs.src,
 					alt: node.attrs.alt,
@@ -50444,7 +51147,7 @@ var normalizedImages = imageSchema.extendSchema((base) => (ctx) => {
 					inkkitFileRaw: raw,
 					inkkitFileTarget: node.attrs.inkkitFileTarget,
 					inkkitFileFragment: node.attrs.inkkitFileFragment,
-					inkkitFileWidth: fileReference(node).width ?? null,
+					inkkitFileWidth: fileFields(node).width ?? null,
 					inkkitFileInTable: node.attrs.inkkitFileInTable
 				});
 			}
@@ -50557,6 +51260,7 @@ function createDialect(images, wikiLinks = false, files = false) {
 		remarkCodeFences,
 		remarkReferencesPlugin,
 		remarkLinkFormsPlugin,
+		remarkFileSourcesPlugin,
 		remarkCalloutsPlugin,
 		remarkCommentsPlugin,
 		wikiLinks || files ? linkedSyntax(wikiLinks, files) : [],
@@ -50576,6 +51280,7 @@ function createDialect(images, wikiLinks = false, files = false) {
 			wikiLinkComposition,
 			wikiLinkInputRule
 		] : [],
+		wikiLinks || files ? referenceTableContext : [],
 		callouts,
 		comments,
 		hiddenCommentEditing,
@@ -50603,7 +51308,8 @@ function createDialect(images, wikiLinks = false, files = false) {
 		remarkDialectPlugin,
 		tables,
 		literalBlock,
-		checkedParser
+		checkedParser,
+		imageWriter
 	].flat();
 }
 createDialect(false);
@@ -51106,8 +51812,7 @@ function modeSelectionMap(ctx, source, doc) {
 			if (at >= 0) append(value, Array.from({ length: value.length + 1 }, (_, index) => start + bom + at + index));
 		}
 	};
-	const processor = ctx.get(remarkCtx);
-	processor.runSync(processor.parse(source), { value: source }).children.forEach((node) => visit(node));
+	Preservation.read(ctx, source).sourceTree.children.forEach((node) => visit(node));
 	let cursor = 0;
 	doc.descendants((node, position) => {
 		if ([
@@ -51315,7 +52020,7 @@ var ImageView = class {
 	view;
 	getPos;
 	adapter;
-	runtime;
+	host;
 	canMutate;
 	dom;
 	/** The card or picture, which a standalone image's block row holds. */
@@ -51327,22 +52032,31 @@ var ImageView = class {
 	stopResize;
 	resolution;
 	previewFailed = false;
-	constructor(node, view, getPos, adapter, runtime, canMutate = () => true) {
+	suspended = false;
+	/** Present when the host sets `files`, which then shows every image. */
+	runtime;
+	constructor(node, view, getPos, adapter, host, files, cache, canMutate = () => true) {
 		this.node = node;
 		this.view = view;
 		this.getPos = getPos;
 		this.adapter = adapter;
-		this.runtime = runtime;
+		this.host = host;
 		this.canMutate = canMutate;
+		const runtime = files && host && {
+			...host,
+			adapter: files
+		};
+		this.runtime = runtime;
 		this.element = document.createElement("span");
 		this.element.className = "inkkit-image";
+		this.element.addEventListener("contextmenu", this.contextMenu);
 		if (node.isBlock) {
 			this.dom = document.createElement("div");
 			this.dom.className = "inkkit-image-block";
 			this.dom.append(this.element);
 		} else this.dom = this.element;
 		this.view.dom.addEventListener("inkkit-cancel-resize", this.cancelResize);
-		this.view.dom.addEventListener("inkkit-media-policy", this.mediaPolicy);
+		this.view.dom.addEventListener(mediaPolicyEvent, this.mediaPolicy);
 		if (runtime) {
 			this.resolution = new FileResolution({
 				...runtime,
@@ -51350,7 +52064,7 @@ var ImageView = class {
 			}, () => {
 				this.previewFailed = false;
 				this.render();
-			});
+			}, cache);
 			this.resolution.update(this.reference());
 		}
 		this.render();
@@ -51379,15 +52093,37 @@ var ImageView = class {
 	ignoreMutation() {
 		return true;
 	}
-	mediaPolicy = () => {
+	mediaPolicy = (event) => {
 		if (!this.runtime) return;
+		const refresh = refreshOf(event);
+		if (refresh) {
+			if (!refreshes(refresh, this.reference().target)) return;
+			if (!this.active()) {
+				this.resolution?.invalidate();
+				return;
+			}
+			if (this.previewFailed) this.resolution?.retry();
+			else this.resolution?.refresh();
+			return;
+		}
 		if (!this.active()) {
+			if (this.suspended) return;
+			this.suspended = true;
 			this.stopResize?.();
 			this.stopResize = void 0;
-			this.resolution?.cancel();
-			this.releaseMedia();
-			this.render();
-		} else this.resolution?.update(this.reference());
+			this.resolution?.suspend();
+			if (this.media || this.pdf) this.render();
+		} else {
+			const suspended = this.suspended;
+			this.suspended = false;
+			this.resolution?.update(this.reference());
+			const state = this.resolution?.state;
+			if (suspended && state?.status === "resolved" && [
+				"audio",
+				"video",
+				"pdf"
+			].includes(state.presentation.kind)) this.render();
+		}
 	};
 	cancelResize = () => {
 		if (!this.stopResize) return;
@@ -51408,7 +52144,7 @@ var ImageView = class {
 	}
 	destroy() {
 		this.view.dom.removeEventListener("inkkit-cancel-resize", this.cancelResize);
-		this.view.dom.removeEventListener("inkkit-media-policy", this.mediaPolicy);
+		this.view.dom.removeEventListener(mediaPolicyEvent, this.mediaPolicy);
 		this.stopResize?.();
 		this.stopResize = void 0;
 		this.resolution?.destroy();
@@ -51437,6 +52173,37 @@ var ImageView = class {
 	report(error) {
 		this.runtime?.error?.(coded(error, "file-unavailable"));
 	}
+	/** Hands the request to the host's hook, which replaces the web view's own menu. A file card
+	*  uses `FileAdapter.contextMenu`; any other image selects itself and uses
+	*  `ImageAdapter.contextMenu`. */
+	contextMenu = (event) => {
+		const { host, runtime, adapter } = this;
+		if (!host?.active() || !(runtime ? runtime.adapter.contextMenu : adapter?.contextMenu)) return;
+		const captured = host.capture();
+		if (!captured.isCurrent()) return;
+		event.preventDefault();
+		const point = {
+			clientX: event.clientX,
+			clientY: event.clientY
+		};
+		try {
+			if (runtime) runtime.adapter.contextMenu?.(this.reference(), point, captured.context);
+			else {
+				this.select();
+				adapter?.contextMenu?.(String(this.node.attrs.src ?? ""), point, captured.context);
+			}
+		} catch (error) {
+			if (runtime) this.report(error);
+			else host.error?.(coded(error, "image-unavailable"));
+		}
+	};
+	select() {
+		const pos = this.getPos();
+		if (pos == null || this.view.composing) return;
+		const { state } = this.view;
+		const selection = NodeSelection.create(state.doc, pos);
+		if (!state.selection.eq(selection)) this.view.dispatch(state.tr.setSelection(selection));
+	}
 	card(label, status, retry = false) {
 		const footer = document.createElement("span");
 		footer.className = "inkkit-file-footer";
@@ -51485,20 +52252,6 @@ var ImageView = class {
 		this.image = void 0;
 		if (this.runtime) {
 			this.element.classList.add("inkkit-file");
-			this.element.oncontextmenu = (event) => {
-				if (!this.runtime?.adapter.contextMenu || !this.active()) return;
-				const captured = this.runtime.capture();
-				if (!captured.isCurrent()) return;
-				event.preventDefault();
-				try {
-					this.runtime.adapter.contextMenu(this.reference(), {
-						clientX: event.clientX,
-						clientY: event.clientY
-					}, captured.context);
-				} catch (error) {
-					this.report(error);
-				}
-			};
 			const state = this.resolution.state;
 			const label = state.status === "resolved" ? state.presentation.label || alt || reference.reference : alt || reference.reference;
 			this.element.setAttribute("role", "group");
@@ -51518,6 +52271,14 @@ var ImageView = class {
 				return;
 			}
 			const presentation = state.presentation;
+			if (!this.active() && [
+				"audio",
+				"video",
+				"pdf"
+			].includes(presentation.kind)) {
+				this.card(label);
+				return;
+			}
 			if (presentation.kind === "missing") this.card(label, this.runtime.labels.fileMissing, true);
 			else if (presentation.kind === "error") this.card(label, presentation.message || this.runtime.labels.fileError, true);
 			else if (presentation.kind === "image") {
@@ -51647,8 +52408,9 @@ function openArrow() {
 	icon.append(path);
 	return icon;
 }
-function imageView(adapter, runtime, canMutate = () => true) {
-	const view = (schema) => $view(schema.node, () => (node, view, getPos) => new ImageView(node, view, getPos, adapter, runtime, canMutate));
+function imageView(adapter, host, files, canMutate = () => true) {
+	const cache = new FilePresentationCache();
+	const view = (schema) => $view(schema.node, () => (node, view, getPos) => new ImageView(node, view, getPos, adapter, host, files, cache, canMutate));
 	return [view(imageSchema), view(imageBlockSchema)];
 }
 //#endregion
@@ -51660,26 +52422,29 @@ function wikiLinkView(adapter, runtime) {
 		dom.className = "inkkit-wiki-link";
 		dom.setAttribute("role", "link");
 		dom.tabIndex = 0;
-		const reference = () => ({
-			target: String(current.attrs.target),
-			...current.attrs.fragment ? { fragment: String(current.attrs.fragment) } : {},
-			label: String(current.attrs.label)
-		});
+		const reference = () => wikiReference(current);
 		const report = (error) => runtime.error?.(coded(error, "file-unavailable"));
 		const render = () => {
-			dom.textContent = reference().label;
-			dom.removeAttribute("title");
-			dom.removeAttribute("data-missing");
-			if (!runtime.active()) return;
-			const captured = runtime.capture();
-			try {
-				const result = adapter.resolve?.(reference(), captured.context);
-				if (captured.isCurrent() && result?.missing) {
-					dom.dataset.missing = "true";
-					dom.title = runtime.labels.wikiMissing;
+			const { label } = reference();
+			if (dom.textContent !== label) dom.textContent = label;
+			let missing = false;
+			if (runtime.active()) {
+				const captured = runtime.capture();
+				try {
+					const result = adapter.resolve?.(reference(), captured.context);
+					missing = captured.isCurrent() && Boolean(result?.missing);
+				} catch (error) {
+					report(error);
 				}
-			} catch (error) {
-				report(error);
+			}
+			if (missing) {
+				dom.dataset.missing = "true";
+				dom.title = runtime.labels.wikiMissing;
+				dom.setAttribute("aria-description", runtime.labels.wikiMissing);
+			} else {
+				dom.removeAttribute("data-missing");
+				dom.removeAttribute("title");
+				dom.removeAttribute("aria-description");
 			}
 		};
 		const open = (event) => {
@@ -51698,7 +52463,11 @@ function wikiLinkView(adapter, runtime) {
 		dom.addEventListener("keydown", (event) => {
 			if (event.key === "Enter" || event.key === " ") open(event);
 		});
-		view.dom.addEventListener("inkkit-media-policy", render);
+		const policy = (event) => {
+			const refresh = refreshOf(event);
+			if (!refresh || refreshes(refresh, String(current.attrs.target))) render();
+		};
+		view.dom.addEventListener(mediaPolicyEvent, policy);
 		render();
 		return {
 			dom,
@@ -51713,7 +52482,7 @@ function wikiLinkView(adapter, runtime) {
 			},
 			ignoreMutation: () => true,
 			destroy() {
-				view.dom.removeEventListener("inkkit-media-policy", render);
+				view.dom.removeEventListener(mediaPolicyEvent, policy);
 			}
 		};
 	});
@@ -52784,7 +53553,7 @@ function readableProjection(doc) {
 		}
 		if (name === "image_block") {
 			block(position);
-			append(fileReference(node).label || "Image", position, position + node.nodeSize, "embed");
+			append(fileFields(node).label || "Image", position, position + node.nodeSize, "embed");
 			return false;
 		}
 		if (node.isTextblock) {
@@ -52801,7 +53570,7 @@ function readableProjection(doc) {
 			return false;
 		}
 		if (name === "image" || name === "footnote_reference" || name === "inkkit_wiki_link") {
-			append(name === "image" ? fileReference(node).label || "Image" : name === "inkkit_wiki_link" ? String(node.attrs.label || node.attrs.target || "Link") : `[${node.attrs.label}]`, position, position + node.nodeSize, "embed");
+			append(name === "image" ? fileFields(node).label || "Image" : name === "inkkit_wiki_link" ? String(node.attrs.label || node.attrs.target || "Link") : `[${node.attrs.label}]`, position, position + node.nodeSize, "embed");
 			return false;
 		}
 		return true;
@@ -54053,6 +54822,96 @@ function htmlGrid(schema, html) {
 	};
 }
 //#endregion
+//#region src/image-identity.ts
+var pngSignature = [
+	137,
+	80,
+	78,
+	71,
+	13,
+	10,
+	26,
+	10
+];
+function format(bytes) {
+	if (bytes.length >= 8 && pngSignature.every((value, index) => bytes[index] === value)) return "png";
+	if (bytes.length >= 8 && (bytes[0] === 73 && bytes[1] === 73 && bytes[2] === 42 && bytes[3] === 0 || bytes[0] === 77 && bytes[1] === 77 && bytes[2] === 0 && bytes[3] === 42)) return "tiff";
+}
+/** The pixel size in the header of a PNG or the first image of a TIFF. Nothing is decoded, so a
+*  truncated or unusual file gives `undefined` and is never treated as a match. */
+function size(bytes, kind) {
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	if (kind === "png") {
+		if (bytes.length < 24 || view.getUint32(12) !== 1229472850) return void 0;
+		return {
+			width: view.getUint32(16),
+			height: view.getUint32(20)
+		};
+	}
+	const little = bytes[0] === 73;
+	const directory = view.getUint32(4, little);
+	if (directory + 2 > bytes.length) return void 0;
+	const entries = view.getUint16(directory, little);
+	let width;
+	let height;
+	for (let index = 0; index < entries; index++) {
+		const entry = directory + 2 + index * 12;
+		if (entry + 12 > bytes.length) return void 0;
+		const tag = view.getUint16(entry, little);
+		if (tag !== 256 && tag !== 257) continue;
+		const type = view.getUint16(entry + 2, little);
+		const value = type === 3 ? view.getUint16(entry + 8, little) : type === 4 ? view.getUint32(entry + 8, little) : void 0;
+		if (tag === 256) width = value;
+		else height = value;
+	}
+	return width && height ? {
+		width,
+		height
+	} : void 0;
+}
+function identical(a, b) {
+	if (a.length !== b.length) return false;
+	for (let index = 0; index < a.length; index++) if (a[index] !== b[index]) return false;
+	return true;
+}
+function stem(filename) {
+	const name = (filename ?? "").split(/[\\/]/).pop() ?? "";
+	const dot = name.lastIndexOf(".");
+	return (dot > 0 ? name.slice(0, dot) : name).normalize("NFC").toLowerCase();
+}
+/** Whether two captured images are one picture in two representations. */
+function sameImage(a, b) {
+	if ((a.source ?? "") !== (b.source ?? "")) return false;
+	if (identical(a.bytes, b.bytes)) return true;
+	const kindA = format(a.bytes);
+	const kindB = format(b.bytes);
+	if (!kindA || !kindB || kindA === kindB) return false;
+	const nameA = stem(a.filename);
+	const nameB = stem(b.filename);
+	if (nameA && nameB && nameA !== nameB) return false;
+	const sizeA = size(a.bytes, kindA);
+	const sizeB = size(b.bytes, kindB);
+	return !!sizeA && !!sizeB && sizeA.width === sizeB.width && sizeA.height === sizeB.height;
+}
+/** Keeps one image for each picture in a single paste or drop. A clipboard can hold a picture
+*  more than once, such as a screenshot as PNG and as TIFF, and each copy would be stored and
+*  inserted separately.
+*
+*  Two images are one picture when their bytes are identical, or when one is a PNG and the other a
+*  TIFF with the same pixel size and compatible names (the same name without its extension, or a
+*  name missing). Anything else is a different image, including a copy that was resized, re-encoded
+*  as JPEG or renamed. The first image keeps its place; a PNG replaces a TIFF of the same picture
+*  because every web view can show it. */
+function distinctImages(images) {
+	const kept = [];
+	for (const image of images) {
+		const index = kept.findIndex((other) => sameImage(other, image));
+		if (index < 0) kept.push(image);
+		else if (format(kept[index].bytes) === "tiff" && format(image.bytes) === "png") kept[index] = image;
+	}
+	return kept;
+}
+//#endregion
 //#region src/paste.ts
 var PasteController = class {
 	options;
@@ -54214,12 +55073,12 @@ var PasteController = class {
 		this.active = operation;
 		this.options.onPendingChanged?.();
 		try {
-			const images = [...input.images ?? []];
-			for (const file of files) images.push({
+			const fromFiles = files.length ? distinctImages(await Promise.all(files.map(async (file) => ({
 				bytes: new Uint8Array(await file.arrayBuffer()),
 				mimeType: file.type,
 				filename: file.name
-			});
+			})))) : [];
+			const images = distinctImages([...input.images ?? [], ...fromFiles]);
 			this.assertContext(context, operation);
 			const schema = view.state.schema;
 			let slice;
@@ -54238,8 +55097,7 @@ var PasteController = class {
 				}
 				const anchor = this.anchor(operation);
 				const start = view.state.doc.resolve(anchor.from);
-				const end = view.state.doc.resolve(anchor.to);
-				const marks = view.state.storedMarks ?? (anchor.from === anchor.to ? start.marks() : start.marksAcross(end)) ?? [];
+				const marks = replacementMarks(view.state, anchor.from, anchor.to);
 				const nodes = literalTextNodes(schema, input.text, marks, htmlBreakAt(start));
 				slice = new Slice(Fragment.from(schema.nodes.paragraph.create(null, nodes)), 1, 1);
 			} else if (input.html) {
@@ -54247,7 +55105,7 @@ var PasteController = class {
 				const imported = /* @__PURE__ */ new Map();
 				const elements = [...container.querySelectorAll("img")];
 				const uniqueSources = new Set(elements.map((element) => element.getAttribute("src") ?? ""));
-				const positional = (files.length === 0 || files.length === 1 && uniqueSources.size === 1 ? images : input.images ?? []).filter((image) => !image.source);
+				const positional = (fromFiles.length === 0 || fromFiles.length === 1 && uniqueSources.size === 1 ? images : input.images ?? []).filter((image) => !image.source);
 				let index = 0;
 				for (const element of elements) {
 					const source = element.getAttribute("src") ?? "";
@@ -54744,60 +55602,259 @@ var DocumentSession = class {
 //#region src/selection.ts
 /** The stylesheet paints the selection under this name. */
 var name = "inkkit-selection";
-var ranges = /* @__PURE__ */ new Map();
+var activeClass = "inkkit-selection-active";
 /** The selected text within each block. */
 function covered(state) {
 	const { from, to, empty, visible } = state.selection;
-	if (empty || !visible) return null;
+	if (empty || !visible) return [];
 	const text = [];
-	state.doc.nodesBetween(from, to, (node, pos) => {
+	let index = 0;
+	state.doc.descendants((node, pos) => {
 		if (!node.isTextblock) return true;
 		const start = Math.max(from, pos + 1);
 		const end = Math.min(to, pos + node.nodeSize - 1);
 		if (end > start) text.push({
 			from: start,
-			to: end
+			to: end,
+			start: pos + 1,
+			end: pos + node.nodeSize - 1,
+			index
 		});
+		index++;
 		return false;
 	});
 	return text;
 }
+function blockContents(view) {
+	return Array.from(view.dom.querySelectorAll("p,h1,h2,h3,h4,h5,h6,pre,.inkkit-comment-block")).filter((element) => {
+		const excluded = element.closest(".ProseMirror-widget,[contenteditable=\"false\"]");
+		return !excluded || excluded === view.dom;
+	}).map((element) => element.tagName === "PRE" && !element.classList.contains("inkkit-literal-markdown") ? element.querySelector(":scope > code") ?? element : element);
+}
+function matchesBlock(node, content) {
+	if (!content) return false;
+	switch (node.type.name) {
+		case "paragraph": return content.tagName === "P";
+		case "heading": return content.tagName === `H${node.attrs.level}`;
+		case "code_block": return content.tagName === "CODE" && content.parentElement?.tagName === "PRE";
+		case "literal_markdown": return content.classList.contains("inkkit-literal-markdown");
+		case "comment_block": return content.classList.contains("inkkit-comment-block");
+		default: return false;
+	}
+}
+function blockRange(view, span, content) {
+	const range = view.dom.ownerDocument.createRange();
+	range.selectNodeContents(content);
+	const children = Array.from(content.childNodes);
+	const decoration = (node) => node instanceof Element && (node.classList.contains("ProseMirror-widget") || node.classList.contains("ProseMirror-trailingBreak"));
+	const first = children.find((node) => !decoration(node));
+	const last = [...children].reverse().find((node) => !decoration(node));
+	if (first) range.setStartBefore(first);
+	if (last) range.setEndAfter(last);
+	if (span.from !== span.start) {
+		const start = view.domAtPos(span.from);
+		range.setStart(start.node, start.offset);
+	}
+	if (span.to !== span.end) {
+		const end = view.domAtPos(span.to);
+		range.setEnd(end.node, end.offset);
+	}
+	return range;
+}
+function addBlockRanges(highlight, view, spans, contents) {
+	let first;
+	let last;
+	const flush = () => {
+		if (!first || !last) return;
+		const range = view.dom.ownerDocument.createRange();
+		range.setStart(first.content.firstChild, first.span.from - first.span.start);
+		range.setEnd(last.content.firstChild, last.span.to - last.span.start);
+		highlight.add(range);
+		first = last = void 0;
+	};
+	for (const span of spans) {
+		const content = contents[span.index];
+		if (!(/^(P|H[1-6])$/.test(content.tagName) && content.childNodes.length === 1 && content.firstChild?.nodeType === Node.TEXT_NODE)) {
+			flush();
+			highlight.add(blockRange(view, span, content));
+			continue;
+		}
+		if (last && last.content.nextSibling !== content) flush();
+		first ??= {
+			span,
+			content
+		};
+		last = {
+			span,
+			content
+		};
+	}
+	flush();
+}
+function setSelectionHostActive(view, active) {
+	Painter.of(view.dom.ownerDocument).hostActive(view, active);
+}
 function domRange(view, span) {
 	const start = view.domAtPos(span.from);
 	const end = view.domAtPos(span.to);
-	const range = document.createRange();
+	const range = view.dom.ownerDocument.createRange();
 	range.setStart(start.node, start.offset);
 	range.setEnd(end.node, end.offset);
 	return range;
 }
-function paint(view) {
-	ranges.set(view, (covered(view.state) ?? []).map((span) => domRange(view, span)));
-	refresh();
-}
-function refresh() {
-	if (ranges.size === 0) {
-		CSS.highlights.delete(name);
-		return;
-	}
-	const highlight = new Highlight();
-	for (const selection of ranges.values()) for (const range of selection) highlight.add(range);
-	CSS.highlights.set(name, highlight);
-}
+var rootOf = (view) => view.dom.closest(".inkkit-root");
 var paintable = () => typeof Highlight === "function" && "highlights" in CSS && CSS.supports(`selector(::highlight(${name}))`);
-var selectionPlugin = $prose(() => paintable() ? new Plugin({
-	key: new PluginKey("selection"),
-	props: { attributes: { class: "inkkit-painted-selection" } },
-	view(view) {
-		paint(view);
-		return {
-			update: (view) => paint(view),
-			destroy: () => {
-				ranges.delete(view);
-				refresh();
-			}
+/**
+* Whether the view holds the user's input: its formatted surface, or the source or TXT
+* textarea beside it, has focus, or, in a read-only editor that takes no focus, the
+* document selection is inside it.
+*/
+function focused(view) {
+	const doc = view.dom.ownerDocument;
+	const surface = doc.activeElement;
+	if (surface === view.dom || view.dom.contains(surface) || surface instanceof HTMLTextAreaElement && surface.classList.contains("inkkit-plain") && rootOf(view).contains(surface)) return true;
+	const anchor = doc.getSelection()?.anchorNode;
+	return !view.editable && !!anchor && view.dom.contains(anchor);
+}
+/** Whether the focused element takes typing, so a selection kept elsewhere is still what the host is working on. */
+function takesText(element) {
+	return element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement || element instanceof HTMLSelectElement || element instanceof HTMLElement && element.isContentEditable;
+}
+/**
+* One document has one selection, so the editors on it share one painter and one highlight.
+* The owner is the editor that most recently held the selection. Its selection is painted
+* in the active colour while it has focus in a focused window, and in the inactive colour
+* otherwise, so a host that selects a range from its search field, or blurs the editor,
+* still shows what is selected. Anything that takes the selection elsewhere releases it.
+*/
+var Painter = class Painter {
+	doc;
+	static all = /* @__PURE__ */ new WeakMap();
+	views = /* @__PURE__ */ new Map();
+	win;
+	custom = paintable();
+	owner = null;
+	windowFocused;
+	hostActivation = /* @__PURE__ */ new WeakMap();
+	painted;
+	hostActive(view, active) {
+		if (active === null) this.hostActivation.delete(view);
+		else this.hostActivation.set(view, active);
+		this.sync();
+	}
+	static of(doc) {
+		let painter = Painter.all.get(doc);
+		if (!painter) Painter.all.set(doc, painter = new Painter(doc));
+		return painter;
+	}
+	constructor(doc) {
+		this.doc = doc;
+		this.win = doc.defaultView;
+		this.windowFocused = doc.hasFocus();
+	}
+	add(view) {
+		if (!this.views.size) this.listen("add");
+		this.views.set(view, rootOf(view));
+		this.sync();
+	}
+	remove(view) {
+		this.views.get(view)?.classList.remove(activeClass);
+		this.views.delete(view);
+		if (this.owner === view) this.owner = null;
+		this.sync();
+		if (!this.views.size) {
+			this.listen("remove");
+			Painter.all.delete(this.doc);
+		}
+	}
+	/** A transaction gave this view a selection. A focused owner is not taken over by an editor that is not. */
+	take(view) {
+		if (!this.owner || this.owner === view || focused(view) || !focused(this.owner)) this.owner = view;
+		this.sync();
+	}
+	/** The owner's document changed, or its selection moved with it. */
+	changed(view) {
+		if (this.owner === view) this.sync();
+	}
+	onFocusIn = () => {
+		for (const view of this.views.keys()) if (focused(view)) this.owner = view;
+		this.sync();
+	};
+	onFocusOut = () => this.sync();
+	onWindow = (event) => {
+		this.windowFocused = event.type === "focus";
+		this.sync();
+	};
+	onSelectionChange = () => {
+		const owner = this.owner;
+		if (!owner || focused(owner)) return;
+		const selection = this.doc.getSelection();
+		if (!selection?.rangeCount || owner.dom.contains(selection.anchorNode)) return;
+		if (selection.isCollapsed && takesText(this.doc.activeElement)) return;
+		this.owner = null;
+		this.sync();
+	};
+	listen(action) {
+		const method = `${action}EventListener`;
+		this.doc[method]("focusin", this.onFocusIn);
+		this.doc[method]("focusout", this.onFocusOut);
+		this.doc[method]("selectionchange", this.onSelectionChange);
+		this.win[method]("focus", this.onWindow);
+		this.win[method]("blur", this.onWindow);
+	}
+	sync() {
+		for (const [view, root] of this.views) root.classList.toggle(activeClass, (this.hostActivation.get(view) ?? this.windowFocused) && focused(view));
+		if (!this.custom) return;
+		const { owner } = this;
+		if (owner && this.painted?.owner === owner && this.painted.doc === owner.state.doc && this.painted.selection.eq(owner.state.selection)) return;
+		const spans = owner ? covered(owner.state) : [];
+		if (!owner || !spans.length) {
+			CSS.highlights.delete(name);
+			this.painted = void 0;
+			return;
+		}
+		const highlight = new Highlight();
+		const contents = blockContents(owner);
+		let blocks = 0;
+		let mapped = true;
+		owner.state.doc.descendants((node) => {
+			if (!node.isTextblock) return true;
+			if (!matchesBlock(node, contents[blocks])) mapped = false;
+			blocks++;
+			return false;
+		});
+		if (mapped && contents.length === blocks) addBlockRanges(highlight, owner, spans, contents);
+		else for (const span of spans) highlight.add(domRange(owner, span));
+		CSS.highlights.set(name, highlight);
+		this.painted = {
+			owner,
+			doc: owner.state.doc,
+			selection: owner.state.selection
 		};
 	}
-}) : new Plugin({ key: new PluginKey("selection") }));
+};
+var selectionPlugin = $prose(() => {
+	const key = new PluginKey("selection");
+	return new Plugin({
+		key,
+		state: {
+			init: () => 0,
+			apply: (tr, count) => tr.selectionSet ? count + 1 : count
+		},
+		props: paintable() ? { attributes: { class: "inkkit-painted-selection" } } : {},
+		view(view) {
+			const painter = Painter.of(view.dom.ownerDocument);
+			painter.add(view);
+			return {
+				update(view, previous) {
+					if (key.getState(view.state) !== key.getState(previous)) painter.take(view);
+					else painter.changed(view);
+				},
+				destroy: () => painter.remove(view)
+			};
+		}
+	});
+});
 //#endregion
 //#region node_modules/.pnpm/prosemirror-search@1.1.1/node_modules/prosemirror-search/dist/index.js
 var SearchQuery = class {
@@ -55095,7 +56152,7 @@ var searchKey = new PluginKey("search");
 Returns a plugin that stores a current search query and searched
 range, and highlights matches of the query.
 */
-function search(options = {}) {
+function search$1(options = {}) {
 	return new Plugin({
 		key: searchKey,
 		state: {
@@ -55144,6 +56201,56 @@ function setSearchState(tr, query, range = null) {
 }
 //#endregion
 //#region src/search.ts
+function search() {
+	const original = search$1();
+	return new Plugin({
+		...original.spec,
+		state: {
+			init: original.spec.state.init,
+			apply(tr, current, oldState, state) {
+				if (tr.getMeta(original) || current.range) return original.spec.state.apply.call(this, tr, current, oldState, state);
+				if (!current.query.valid || !tr.docChanged && !tr.selectionSet) return current;
+				let deco = tr.docChanged ? current.deco.map(tr.mapping, tr.doc) : current.deco;
+				let from = tr.doc.content.size, to = 0;
+				if (tr.docChanged) {
+					tr.mapping.maps.forEach((map, index) => map.forEach((_a, _b, start, end) => {
+						const rest = tr.mapping.slice(index + 1);
+						from = Math.min(from, rest.map(start, -1));
+						to = Math.max(to, rest.map(end, 1));
+					}));
+					if (from <= to) {
+						const left = tr.doc.resolve(Math.max(0, from - 1));
+						const right = tr.doc.resolve(Math.min(tr.doc.content.size, to + 1));
+						from = left.depth ? left.before(1) : left.pos;
+						to = right.depth ? right.after(1) : right.pos;
+						deco = deco.remove(deco.find(from, to));
+						const added = [];
+						for (let position = from; position < to;) {
+							const match = current.query.findNext(state, position, to);
+							if (!match) break;
+							added.push(Decoration.inline(match.from, match.to, { class: "ProseMirror-search-match" }));
+							position = Math.max(match.to, position + 1);
+						}
+						deco = deco.add(state.doc, added);
+					}
+				}
+				const previous = {
+					from: tr.mapping.map(oldState.selection.from),
+					to: tr.mapping.map(oldState.selection.to)
+				};
+				for (const [selection, active] of [[previous, false], [state.selection, true]]) {
+					const matches = deco.find(selection.from, selection.to).filter((item) => item.from === selection.from && item.to === selection.to);
+					const replacements = matches.map((item) => Decoration.inline(item.from, item.to, { class: active ? "ProseMirror-active-search-match" : "ProseMirror-search-match" }));
+					deco = deco.remove(matches).add(state.doc, replacements);
+				}
+				return {
+					...current,
+					deco
+				};
+			}
+		}
+	});
+}
 function escapedPattern(text) {
 	return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -55227,8 +56334,8 @@ function findFormatted(view, text) {
 	return found;
 }
 function replacementSlice(state, from, to, value) {
-	const start = state.doc.resolve(from), end = state.doc.resolve(to);
-	const marks = start.marksAcross(end) ?? start.marks();
+	const start = state.doc.resolve(from);
+	const marks = replacementMarks(state, from, to);
 	const nodes = [];
 	if (start.parent.type.spec.code) {
 		if (value) nodes.push(state.schema.text(value, marks));
@@ -55305,8 +56412,10 @@ function formattedLocations(doc) {
 	return headings;
 }
 function sourceLocations(ctx, source) {
-	const processor = ctx.get(remarkCtx);
-	const tree = processor.runSync(processor.parse(source), { value: source });
+	const cached = sourceOutlines.get(ctx);
+	if (cached?.source === source) return cached.headings;
+	const preservation = Preservation.read(ctx, source);
+	const tree = preservation.sourceTree;
 	const positions = [];
 	const bom = source.startsWith("") ? 1 : 0;
 	const visit = (node) => {
@@ -55317,13 +56426,19 @@ function sourceLocations(ctx, source) {
 		node.children?.forEach(visit);
 	};
 	visit(tree);
-	const parsed = formattedLocations(ctx.get(parserCtx)(source));
+	const parsed = formattedLocations(preservation.baseline);
 	if (positions.length !== parsed.length || positions.some((item, index) => item.level !== parsed[index].node.attrs.level)) throw new InkKitError("preservation", "The current Markdown headings cannot be located safely");
-	return parsed.map((heading, index) => ({
+	const headings = parsed.map((heading, index) => ({
 		...heading,
 		position: positions[index].position
 	}));
+	sourceOutlines.set(ctx, {
+		source,
+		headings
+	});
+	return headings;
 }
+var sourceOutlines = /* @__PURE__ */ new WeakMap();
 function entry(heading, context) {
 	return Object.freeze({
 		id: `heading:${context.key}:${heading.position}`,
@@ -55845,6 +56960,8 @@ var shortcutNames = [
 	"redo",
 	"moveBlockUp",
 	"moveBlockDown",
+	"indent",
+	"outdent",
 	...tableCommands.map(tableShortcut)
 ];
 /** Checks a keymap and drops omitted entries, so a `null` binding keeps its default. */
@@ -55896,6 +57013,7 @@ function editorOptions(value) {
 		"textInput",
 		"labels",
 		"keymap",
+		"linkSchemes",
 		"rendering",
 		"slashMenu"
 	]) ?? {};
@@ -55905,6 +57023,7 @@ function editorOptions(value) {
 	optionalBoolean(options.editable, "options.editable");
 	if (!isOmitted(options.textInput)) textInputPreferences(options.textInput, "options.textInput");
 	if (!isOmitted(options.keymap)) keymapBindings(options.keymap, "options.keymap");
+	const linkSchemes = isOmitted(options.linkSchemes) ? void 0 : extraLinkSchemes(options.linkSchemes, "options.linkSchemes");
 	const rendering = optionalRecord(options.rendering, "options.rendering", ["codeHighlighting", "diagramPreview"]);
 	optionalBoolean(rendering?.codeHighlighting, "options.rendering.codeHighlighting");
 	optionalBoolean(rendering?.diagramPreview, "options.rendering.diagramPreview");
@@ -55912,6 +57031,7 @@ function editorOptions(value) {
 	return {
 		...options,
 		slashMenu: slashMenuOptions(options.slashMenu),
+		linkSchemes,
 		labels: labels && Object.fromEntries(Object.entries(labels).filter(([, label]) => !isOmitted(label)).map(([key, label]) => [key, expectString(label, `options.labels.${key}`)]))
 	};
 }
@@ -56108,6 +57228,18 @@ function blockAt(parent, $from) {
 	return { type: "paragraph" };
 }
 var quotes = /* @__PURE__ */ new Set(["blockquote", "inkkit_callout"]);
+function liftQuote(state, range, target) {
+	const tr = state.tr.lift(range, target);
+	const { depth } = range;
+	const item = range.$from.node(depth - 1);
+	const spacer = item.firstChild;
+	if (item.type.name === "list_item" && range.$from.index(depth - 1) === 1 && spacer?.type.name === "paragraph" && spacer.content.size === 0) {
+		const from = range.$from.start(depth - 1);
+		if (tr.doc.nodeAt(from + spacer.nodeSize)?.type === spacer.type) tr.delete(from, from + spacer.nodeSize);
+	}
+	return tr;
+}
+var undoTypedRule = $prose(() => keymap$3({ Backspace: undoInputRule }));
 var quoteBackspace = $prose(() => keymap$3({ Backspace: (state, dispatch) => {
 	const { $from, empty } = state.selection;
 	if (!empty || $from.parentOffset > 0 || $from.depth < 2) return false;
@@ -56117,7 +57249,7 @@ var quoteBackspace = $prose(() => keymap$3({ Backspace: (state, dispatch) => {
 	const range = $from.blockRange($from, (node) => quotes.has(node.type.name));
 	const target = range && liftTarget(range);
 	if (!range || target == null) return false;
-	dispatch?.(state.tr.lift(range, target).scrollIntoView());
+	dispatch?.(liftQuote(state, range, target).scrollIntoView());
 	return true;
 } }));
 var calloutEnter = $prose(() => keymap$3({ Enter: (state, dispatch) => {
@@ -56159,7 +57291,6 @@ var liftItem = (state, dispatch) => {
 	dispatch(lifted);
 	return true;
 };
-var listItemShiftTab = $prose(() => keymap$3({ "Shift-Tab": liftItem }));
 var rejoinLists = $prose(() => keymap$3({ Backspace: (state, dispatch) => {
 	const { $from, empty } = state.selection;
 	if (!empty || $from.parent.type.name !== "paragraph" || $from.parent.content.size > 0) return false;
@@ -56252,11 +57383,7 @@ var movedListItems = $prose(() => new Plugin({
 		return tr.docChanged ? tr : null;
 	}
 }));
-var controlCharacters = /^[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]+$/;
-var textInputPolicy = $prose(() => new Plugin({
-	key: new PluginKey("inkkitTextInput"),
-	props: { handleTextInput: (view, from, to, text, deflt) => controlCharacters.test(text) || insertTextChunk(view, from, to, text, deflt) }
-}));
+var textInputPolicy = $prose(() => textInputPlugin());
 function outermostListDepth($pos) {
 	for (let depth = 1; depth <= $pos.depth; depth++) if (isList($pos.node(depth))) return depth;
 	return null;
@@ -56381,6 +57508,7 @@ var InkKitEditor = class InkKitEditor {
 	inputPreferences = {};
 	literalKeys = () => false;
 	configuredKeys = {};
+	indentKeys = () => false;
 	readOnlyKeys = () => false;
 	suggestions;
 	suggestionBase;
@@ -56407,7 +57535,7 @@ var InkKitEditor = class InkKitEditor {
 				const anchor = view.state.doc.attrs[sourceAttribute];
 				const from = anchor?.from ?? this.plain.selectionStart;
 				const to = anchor?.to ?? this.plain.selectionEnd;
-				if (!this.plainComposing) this.plain.value = markdown;
+				if (!this.plainComposing) this.setSourceValue(markdown);
 				if (!this.plainComposing) {
 					this.plain.setSelectionRange(Math.min(from, this.plain.value.length), Math.min(to, this.plain.value.length));
 					this.revealLiteralSelection();
@@ -56420,6 +57548,8 @@ var InkKitEditor = class InkKitEditor {
 	}));
 	keys = () => false;
 	events;
+	/** The host's extra link schemes, in lower case. */
+	linkSchemes;
 	/** How many of each state event the host has been sent. */
 	sentEvents = /* @__PURE__ */ new Map();
 	constructor(events, options) {
@@ -56439,6 +57569,7 @@ var InkKitEditor = class InkKitEditor {
 				else send();
 			};
 		} });
+		this.linkSchemes = new Set(options.linkSchemes);
 		this.writable = options.editable ?? true;
 		this.inputPreferences = textInputPreferences(options.textInput ?? {}, "options.textInput");
 	}
@@ -56499,7 +57630,7 @@ var InkKitEditor = class InkKitEditor {
 		};
 	}
 	mediaPolicy() {
-		if (this.editor && this.root) this.editor.ctx.get(editorViewCtx).dom.dispatchEvent(new Event("inkkit-media-policy"));
+		if (this.editor && this.root) this.editor.ctx.get(editorViewCtx).dom.dispatchEvent(new Event(mediaPolicyEvent));
 	}
 	assertAlive() {
 		if (this.destroyed) throw new InkKitError("destroyed", "The editor has been destroyed");
@@ -56653,6 +57784,12 @@ var InkKitEditor = class InkKitEditor {
 		}
 		this.publishCommandState();
 	}
+	/** Supplies native host activation for selection presentation. Null restores browser detection. */
+	setHostActive(active) {
+		this.assertAlive();
+		if (active !== null) expectBoolean(active, "active");
+		setSelectionHostActive(this.editor.ctx.get(editorViewCtx), active);
+	}
 	/** Replaces the input preferences. A field left out takes its default. Throws `composition`
 	*  during text composition. */
 	setTextInputPreferences(preferences) {
@@ -56671,11 +57808,13 @@ var InkKitEditor = class InkKitEditor {
 	}
 	applyInputPolicy() {
 		const view = this.editor.ctx.get(editorViewCtx);
-		const attributes = typeof view.props.attributes === "function" ? view.props.attributes(view.state) : view.props.attributes;
+		const inputAttributes = { ...typeof view.props.attributes === "function" ? view.props.attributes(view.state) : view.props.attributes };
+		delete inputAttributes["aria-readonly"];
+		if (!this.writable) inputAttributes["aria-readonly"] = "true";
 		view.setProps({
 			editable: () => this.writable && !this.literalSurface,
 			attributes: {
-				...attributes,
+				...inputAttributes,
 				role: "textbox",
 				"aria-multiline": "true",
 				"aria-label": this.options.labels?.formattedEditor ?? defaultLabels.formattedEditor
@@ -56750,6 +57889,7 @@ var InkKitEditor = class InkKitEditor {
 				replace: mutable,
 				replaceSource: mutable,
 				insertImages: formatted && this.canInsertImages,
+				appendImages: formatted && this.canInsertImages,
 				insertPaths: mutable,
 				insertFootnote: formatted,
 				editReferenceDefinition: formatted && referenceDefinitions(state.doc).size > 0,
@@ -56839,7 +57979,7 @@ var InkKitEditor = class InkKitEditor {
 			if (provenance) {
 				preservation = this.sourcePreservations.get(provenance);
 				if (!preservation) {
-					preservation = new Preservation(this.editor.ctx, provenance.text);
+					preservation = Preservation.read(this.editor.ctx, provenance.text);
 					this.sourcePreservations.set(provenance, preservation);
 				}
 			}
@@ -56881,7 +58021,7 @@ var InkKitEditor = class InkKitEditor {
 		this.plainSearch = "";
 		this.literalMatch = void 0;
 		if (mode === "source") {
-			this.plain.value = text;
+			this.setSourceValue(text);
 			this.plain.setSelectionRange(Math.min(anchor, head), Math.max(anchor, head), anchor > head ? "backward" : "forward");
 		} else view.dispatch(view.state.tr.setSelection(TextSelection.between(view.state.doc.resolve(Math.min(anchor, view.state.doc.content.size)), view.state.doc.resolve(Math.min(head, view.state.doc.content.size)))).setMeta("addToHistory", false));
 		const suppressed = this.reportingSuppressed;
@@ -56966,10 +58106,27 @@ var InkKitEditor = class InkKitEditor {
 		if (this.typedSteps.length > sourceStepLimit) this.typedSteps.shift();
 	}
 	showTypedSource(text, from, to) {
-		this.plain.value = text;
+		this.setSourceValue(text);
 		this.plain.setSelectionRange(Math.min(from, this.plain.value.length), Math.min(to, this.plain.value.length));
 		this.revealLiteralSelection();
 	}
+	setSourceValue(text) {
+		const plain = this.plain;
+		if (text.length < 65536 || !plain.isConnected || this.plainComposing) {
+			plain.value = text;
+			return;
+		}
+		const focused = plain.ownerDocument.activeElement === plain;
+		const { selectionStart, selectionEnd, selectionDirection, scrollTop, scrollLeft } = plain;
+		const marker = plain.ownerDocument.createComment("source");
+		plain.replaceWith(marker);
+		plain.value = text;
+		marker.replaceWith(plain);
+		plain.setSelectionRange(selectionStart, selectionEnd, selectionDirection);
+		if (focused) plain.focus({ preventScroll: true });
+		plain.scrollTop = scrollTop;
+		plain.scrollLeft = scrollLeft;
+	}
 	/**
 	* Undoes or redoes typed source that the formatted document has not taken
 	* in, on the text alone. Returns whether there was a step to take.
@@ -57041,7 +58198,7 @@ var InkKitEditor = class InkKitEditor {
 		try {
 			if (this.formatType === "txt") parsed = view.state.schema.topNodeType.create(null, view.state.schema.nodes.paragraph.create(null, text ? view.state.schema.text(text) : void 0));
 			else {
-				const preservation = new Preservation(this.editor.ctx, text);
+				const preservation = Preservation.read(this.editor.ctx, text);
 				this.sourcePreservations.set(provenance, preservation);
 				parsed = preservation.baseline;
 			}
@@ -57205,11 +58362,11 @@ var InkKitEditor = class InkKitEditor {
 		const valid = content.firstChild?.isInline ? Fragment.from(schema.nodes.paragraph.create(null, content)) : content;
 		let markdown;
 		try {
-			markdown = selectedSource ? selectedSource.markdown : all ? snapshot.text : completeDiagrams.size ? new Preservation(this.editor.ctx, snapshot.text).serialize(doc.type.create(null, selectionContent(doc, valid))) : selectionMarkdown(this.editor.ctx, doc, valid);
+			markdown = selectedSource ? selectedSource.markdown : all ? snapshot.text : completeDiagrams.size ? Preservation.read(this.editor.ctx, snapshot.text).serialize(doc.type.create(null, selectionContent(doc, valid))) : selectionMarkdown(this.editor.ctx, doc, valid);
 		} catch (error) {
 			throw coded(error, "preservation");
 		}
-		const result = await this.exportContent(captured, (signal) => portableClipboard(all || selectedDoc ? content : selectionContent(doc, content), schema, markdown, this.options.images, this.context(), completeDiagrams, this.options.files, signal));
+		const result = await this.exportContent(captured, (signal) => portableClipboard(all || selectedDoc ? content : selectionContent(doc, content), schema, markdown, this.options.images, this.context(), completeDiagrams, this.options.files, signal, this.linkSchemes));
 		const metadata = referenceMetadata(this.editor.ctx, selectedDoc ?? doc, content);
 		if (metadata != null) result.html = withReferenceMetadata(result.html, metadata);
 		this.assertCaptured(captured);
@@ -57260,7 +58417,8 @@ var InkKitEditor = class InkKitEditor {
 			if (view.state.selection.$from.parent.type.spec.code && !inHiddenComment) view.dispatch(view.state.tr.insertText(text.replace(/\r\n?/g, "\n")).scrollIntoView());
 			else {
 				const { schema } = view.state;
-				const marks = view.state.storedMarks ?? (view.state.selection.empty ? view.state.selection.$from.marks() : view.state.selection.$from.marksAcross(view.state.selection.$to)) ?? [];
+				const { from, to } = view.state.selection;
+				const marks = replacementMarks(view.state, from, to);
 				const isHTML = !inHiddenComment && htmlBreakAt(view.state.selection.$from);
 				const lines = text.replace(/\r\n?/g, "\n").split("\n");
 				const children = literalTextNodes(schema, text, marks, isHTML);
@@ -57336,6 +58494,10 @@ var InkKitEditor = class InkKitEditor {
 			return this.keys(view, event);
 		} }
 	}));
+	indentPlugin = new Plugin({
+		key: new PluginKey("listIndent"),
+		props: { handleKeyDown: (view, event) => this.indentKeys(view, event) }
+	});
 	copySourceSelection(event) {
 		event.preventDefault();
 		event.stopPropagation();
@@ -57361,7 +58523,7 @@ var InkKitEditor = class InkKitEditor {
 				}
 			}).catch((error) => this.report(error));
 			else {
-				const output = clipboardContent(parsed.content, parsed.type.schema);
+				const output = clipboardContent(parsed.content, parsed.type.schema, this.linkSchemes);
 				if (!event.clipboardData) return;
 				this.rememberCopy(output, selected.markdown, parsed.content, selected.markdown !== selected.shareable, true);
 				event.clipboardData.setData("text/plain", output.text);
@@ -57427,6 +58589,7 @@ var InkKitEditor = class InkKitEditor {
 			ctx.set(rootCtx, root);
 			ctx.set(authoredSourcesCtx.key, (doc, positions) => instance.authoredSources(doc, positions));
 			ctx.set(smartPunctuationCtx.key, () => instance.inputPreferences.smartPunctuation === true);
+			ctx.set(linkSchemesCtx.key, instance.linkSchemes);
 			ctx.update(labelsCtx.key, () => ({
 				...defaultLabels,
 				...options.labels
@@ -57441,9 +58604,16 @@ var InkKitEditor = class InkKitEditor {
 			}), false));
 			ctx.set(defaultValueCtx, "");
 			ctx.set(remarkStringifyOptionsCtx, stringifyOptions);
+			ctx.update(editorStateOptionsCtx, (override) => (options) => {
+				const next = override(options);
+				return {
+					...next,
+					plugins: [...next.plugins ?? [], instance.indentPlugin]
+				};
+			});
 			ctx.update(listItemKeymap.key, (keys) => ({
 				...keys,
-				SinkListItem: { shortcuts: "Tab" },
+				SinkListItem: { shortcuts: [] },
 				LiftListItem: { shortcuts: [] }
 			}));
 			const unbind = (keymap, keep = []) => ctx.update(keymap.key, (keys) => {
@@ -57507,7 +58677,7 @@ var InkKitEditor = class InkKitEditor {
 					return true;
 				}
 			}));
-		}).use(labelsCtx).use(instance.pasteController.plugin).use(visibleClipboard).use($prose(() => instance.suggestions.plugin())).use(instance.keymapPlugin).use(createDialect(Boolean(options.images || options.files), Boolean(options.wikiLinks), Boolean(options.files))).use(codeControlCtx).use(codeControlsPlugin(() => instance.viewport().rect)).use(tablePlugins).use(tableBlock).use(instance.changePlugin).use(instance.historyInputPlugin).use(history).use(clipboard).use(cursor).use(taskListPlugin).use(quoteBackspace).use(calloutEnter).use(literalEnter).use(literalReread).use(listItemBackspace).use(listItemShiftTab).use(nestedItemEnter).use(rejoinLists).use(movedListItems).use(textInputPolicy).use(events.copy ? codeCopyPlugin((text) => events.copy?.(text)) : []).use(placeholderPlugin).use(options.rendering?.codeHighlighting === false ? [] : (await import("./highlight-D6evOlOs.js")).highlightPlugin).use(options.rendering?.diagramPreview === false || !diagramsAvailable() ? [] : mermaidPreview((error) => instance.report(error))).use(selectionPlugin).use($prose(() => search())).use(instance.policyPlugin).use(options.wikiLinks ? wikiLinkView(options.wikiLinks, {
+		}).use(labelsCtx).use(linkSchemesCtx).use(instance.pasteController.plugin).use(visibleClipboard).use($prose(() => instance.suggestions.plugin())).use(instance.keymapPlugin).use(createDialect(Boolean(options.images || options.files), Boolean(options.wikiLinks), Boolean(options.files))).use(codeControlCtx).use(codeControlsPlugin(() => instance.viewport().rect)).use(tablePlugins).use(tableBlock).use(instance.changePlugin).use(instance.historyInputPlugin).use(history).use(clipboard).use(cursor).use(taskListPlugin).use(undoTypedRule).use(quoteBackspace).use(calloutEnter).use(literalEnter).use(literalReread).use(listItemBackspace).use(nestedItemEnter).use(rejoinLists).use(movedListItems).use(textInputPolicy).use(events.copy ? codeCopyPlugin((text) => events.copy?.(text)) : []).use(placeholderPlugin).use(options.rendering?.codeHighlighting === false ? [] : (await import("./highlight-LB7Mkd5W.js")).highlightPlugin).use(options.rendering?.diagramPreview === false || !diagramsAvailable() ? [] : mermaidPreview((error) => instance.report(error))).use(selectionPlugin).use($prose(() => search())).use(instance.policyPlugin).use(options.wikiLinks ? wikiLinkView(options.wikiLinks, {
 			capture: () => instance.adapterCapture(),
 			active: () => instance.ready && !instance.destroyed && !instance.literalSurface,
 			labels: {
@@ -57515,8 +58685,7 @@ var InkKitEditor = class InkKitEditor {
 				...options.labels
 			},
 			error: (error) => instance.report(error)
-		}) : []).use(options.images || options.files ? imageView(options.images, options.files ? {
-			adapter: options.files,
+		}) : []).use(options.images || options.files ? imageView(options.images, {
 			capture: () => instance.adapterCapture(),
 			active: () => instance.ready && !instance.destroyed && !instance.literalSurface,
 			labels: {
@@ -57524,7 +58693,7 @@ var InkKitEditor = class InkKitEditor {
 				...options.labels
 			},
 			error: (error) => instance.report(error)
-		} : void 0, () => {
+		}, options.files, () => {
 			try {
 				instance.assertMutation();
 				return true;
@@ -57558,7 +58727,7 @@ var InkKitEditor = class InkKitEditor {
 		instance.plain.addEventListener("input", () => {
 			if (!instance.ready || !instance.literalSurface) return;
 			if (!instance.writable) {
-				instance.plain.value = instance.currentText();
+				instance.setSourceValue(instance.currentText());
 				return;
 			}
 			try {
@@ -57658,7 +58827,7 @@ var InkKitEditor = class InkKitEditor {
 					const content = expanded;
 					const valid = fragment.firstChild?.isInline ? Fragment.from(view.state.schema.nodes.paragraph.create(null, fragment)) : fragment;
 					const markdown = selectionMarkdown(instance.editor.ctx, view.state.doc, valid);
-					const output = clipboardContent(content, view.state.schema);
+					const output = clipboardContent(content, view.state.schema, instance.linkSchemes);
 					const metadata = referenceMetadata(instance.editor.ctx, view.state.doc, valid);
 					if (metadata != null) output.html = withReferenceMetadata(output.html, metadata);
 					instance.rememberCopy(output, markdown, fragment, false, true);
@@ -57709,7 +58878,7 @@ var InkKitEditor = class InkKitEditor {
 		const markdown = input.format === "txt" ? "" : input.text;
 		let preservation;
 		try {
-			preservation = new Preservation(this.editor.ctx, markdown);
+			preservation = Preservation.read(this.editor.ctx, markdown);
 		} catch (error) {
 			throw new InkKitError("preservation", "The document was not loaded because its Markdown could not be shown without losing part of it", { cause: error });
 		}
@@ -57734,7 +58903,7 @@ var InkKitEditor = class InkKitEditor {
 		this.plainSearch = "";
 		this.literalMatch = void 0;
 		this.formatType = input.format;
-		this.plain.value = input.text;
+		this.setSourceValue(input.text);
 		this.plain.setSelectionRange(this.plain.value.length, this.plain.value.length);
 		this.load(markdown, preservation);
 		this.originalSource = input.text;
@@ -58311,10 +59480,23 @@ var InkKitEditor = class InkKitEditor {
 		this.assertReady(expectedGeneration);
 		this.releaseFocus();
 	}
+	/**
+	* Resolves wiki links and file embeds again, all of them or those whose `target` is named, after
+	* something they point to changed. A file keeps its card until the new answer differs. Changes no
+	* document state, so it works in a read-only editor and during composition. Source and TXT modes
+	* draw no references; named file answers are invalidated and resolved when formatted mode returns.
+	*/
+	refreshReferences(targets, expectedGeneration) {
+		this.assertAlive();
+		const names = isOmitted(targets) ? void 0 : new Set(expectArray(targets, "targets").map((target) => expectString(target, "targets entry")));
+		this.assertReady(expectedGeneration);
+		requestRefresh(this.editor.ctx.get(editorViewCtx).dom, { ...names && { targets: names } });
+	}
 	/** Replaces every binding. Keys are in ProseMirror's notation. A key given to two shortcuts goes
 	*  to the later one, in the order history, formatting, block moves, tables, so it lands the same
 	*  way every time. A table binding passes a key it shares with a block move to the move outside
-	*  a table. */
+	*  a table. List indentation keys apply after all of these, and after the table keys the editor
+	*  keeps for itself. */
 	setKeymap(keymap) {
 		this.assertAlive();
 		keymap = keymapBindings(keymap, "keymap");
@@ -58324,6 +59506,8 @@ var InkKitEditor = class InkKitEditor {
 			moveBlockUp: ["Alt-ArrowUp"],
 			moveBlockDown: ["Alt-ArrowDown"],
 			tableExit: ["Mod-Enter", "Enter"],
+			indent: ["Tab"],
+			outdent: ["Shift-Tab"],
 			...keymap
 		};
 		const bindings = {};
@@ -58350,6 +59534,9 @@ var InkKitEditor = class InkKitEditor {
 			if (move === "move" && !this.composing && !this.pasteController.pending) this.forPerson(() => this.moveBlock(direction), false);
 			return true;
 		};
+		const indents = {};
+		const sink = (state, dispatch) => sinkListItem(state.schema.nodes.list_item)(state, dispatch);
+		for (const [name, command] of [["indent", sink], ["outdent", liftItem]]) for (const key of this.configuredKeys[name] ?? []) indents[key] = (state, dispatch, view) => this.ready && this.writable && !this.literalSurface ? command(state, dispatch, view) : false;
 		for (const command of tableCommands) for (const key of this.configuredKeys[tableShortcut(command)] ?? []) bindings[key] = (state, dispatch, view) => {
 			if (!this.ready || !this.commandState().commands.table[command]) return moves[key]?.(state, dispatch, view) ?? false;
 			return this.forPerson(() => this.table(command), true);
@@ -58358,6 +59545,7 @@ var InkKitEditor = class InkKitEditor {
 			throw new InkKitError("read-only", "The editor is read-only");
 		}])));
 		this.keys = keydownHandler(bindings);
+		this.indentKeys = keydownHandler(indents);
 		this.literalKeys = keydownHandler(historyBindings);
 	}
 	/** Dropped files land as one paragraph per path at the drop point: in place of an empty block, after
@@ -58385,17 +59573,12 @@ var InkKitEditor = class InkKitEditor {
 		this.assertMutation(expectedGeneration);
 		if (!images.length || !this.canInsertImages || this.literalSurface) return false;
 		const view = this.editor.ctx.get(editorViewCtx);
-		const { schema } = view.state;
 		const placement = point ? void 0 : imagePlacement(view.state);
 		if (placement?.kind === "inline") {
 			this.insertInline(images);
 			return true;
 		}
-		const blocks = images.map((image) => schema.nodes.paragraph.create(null, schema.nodes.image.create({
-			src: image.reference,
-			alt: image.alt,
-			title: image.title ?? ""
-		})));
+		const blocks = this.imageBlocks(images);
 		if (point) {
 			this.insertBlocks(blocks, point);
 			return true;
@@ -58411,6 +59594,31 @@ var InkKitEditor = class InkKitEditor {
 		view.dispatch(tr.scrollIntoView());
 		return true;
 	}
+	/** Adds images as the last blocks of the document and leaves everything else as it is: no focus,
+	*  no scrolling, and the selection stays on the text it covered. For a host that attaches images
+	*  to a document the person is not editing at that moment. Returns false when it does nothing. */
+	appendImages(images, expectedGeneration) {
+		this.assertAlive();
+		images = imageInsertions(images);
+		this.assertMutation(expectedGeneration);
+		if (!images.length || !this.canInsertImages || this.literalSurface) return false;
+		const view = this.editor.ctx.get(editorViewCtx);
+		const { doc, tr } = view.state;
+		const blocks = this.imageBlocks(images);
+		if (doc.childCount === 1 && doc.firstChild.type.name === "paragraph" && doc.firstChild.content.size === 0 && this.currentText().trim() === "") tr.replaceWith(0, doc.content.size, blocks);
+		else tr.insert(doc.content.size, blocks);
+		view.dispatch(closeHistory(tr));
+		view.dispatch(closeHistory(view.state.tr).setMeta("addToHistory", false));
+		return true;
+	}
+	imageBlocks(images) {
+		const { schema } = this.editor.ctx.get(editorViewCtx).state;
+		return images.map((image) => schema.nodes.paragraph.create(null, schema.nodes.image.create({
+			src: image.reference,
+			alt: image.alt,
+			title: image.title ?? ""
+		})));
+	}
 	insertInline(images) {
 		const view = this.editor.ctx.get(editorViewCtx);
 		const { state } = view;
@@ -58528,7 +59736,7 @@ var InkKitEditor = class InkKitEditor {
 		if (!range) return;
 		const target = liftTarget(range);
 		if (target == null) return;
-		view.dispatch(view.state.tr.lift(range, target));
+		view.dispatch(liftQuote(view.state, range, target));
 	}
 	/** Changes the selected textblocks' type, keeping everything they hold. */
 	textblockType(type, attr) {
@@ -58613,25 +59821,27 @@ var InkKitEditor = class InkKitEditor {
 			commit(command);
 			return;
 		}
+		const onHostError = (error) => {
+			if (!this.destroyed) this.report(coded(error, "slash-command-failed"));
+		};
+		const insert = (markdown) => {
+			if (this.destroyed) return;
+			if (markdown === void 0) return;
+			if (typeof markdown !== "string") {
+				this.report(invalidArgument("A slash command must return Markdown text"));
+				return;
+			}
+			commit({ markdown });
+		};
+		let result;
 		try {
-			const result = command.action(this.context());
-			const insert = (markdown) => {
-				if (this.destroyed) return;
-				if (markdown === void 0) return;
-				if (typeof markdown !== "string") {
-					this.report(invalidArgument("A slash command must return Markdown text"));
-					return;
-				}
-				commit({ markdown });
-			};
-			if (result instanceof Promise) result.then(insert).catch((error) => {
-				if (this.destroyed) return;
-				this.report(error);
-			});
-			else insert(result);
+			result = command.action(this.context());
 		} catch (error) {
-			this.report(error);
+			onHostError(error);
+			return;
 		}
+		if (result instanceof Promise) result.then(insert, onHostError);
+		else insert(result);
 	}
 	/** Returns whether the document or the marks the next typed text takes changed. */
 	format(command, options, expectedGeneration) {
@@ -58692,12 +59902,13 @@ var InkKitEditor = class InkKitEditor {
 		return !after.doc.eq(before.doc) || !Mark.sameSet(marks(after), marks(before));
 	}
 	/**
-	* Refuses a link destination that is empty, that opens anything but a web, mail or phone address,
-	* or that the Markdown writer cannot save so that it reads back the same.
+	* Refuses a link destination that is empty, that opens anything but a web, mail or phone address
+	* or a scheme the host listed, or that the Markdown writer cannot save so that it reads back the
+	* same.
 	*/
 	checkDestination(destination, name) {
 		if (destination.trim() === "") throw invalidArgument(`${name} must not be empty`);
-		if (!isSafeLinkTarget(destination)) throw invalidArgument(`${name} must be relative, or an http, https, mailto or tel address, with no control characters`);
+		if (!isSafeLinkTarget(destination, this.linkSchemes)) throw invalidArgument(`${name} must be relative, or an address with an allowed scheme (http, https, mailto, tel or one of linkSchemes), with no control characters`);
 		const { schema } = this.editor.ctx.get(editorViewCtx).state;
 		const written = serialize(this.editor.ctx, schema.node("doc", null, [schema.node("paragraph", null, [schema.text("x", [schema.marks.link.create({ href: destination })])])]));
 		let read;
@@ -58719,13 +59930,18 @@ var InkKitEditor = class InkKitEditor {
 		const { selection, storedMarks } = state;
 		const { from, to, empty } = selection;
 		const stored = empty ? type.isInSet(storedMarks ?? []) : void 0;
-		if (stored && !stored.isInSet(selection.$from.marks())) {
+		const beside = empty ? selection.$from.nodeBefore?.marks ?? [] : [];
+		if (stored && !stored.isInSet(selection.$from.marks()) && !stored.isInSet(beside)) {
 			const tr = state.tr.removeStoredMark(type);
 			if (destination !== void 0) tr.addStoredMark(type.create({ href: destination }));
 			view.dispatch(tr);
 			return;
 		}
-		const mark = type.isInSet(empty ? [...selection.$from.marks(), ...state.doc.nodeAt(from)?.marks ?? []] : state.doc.nodeAt(from)?.marks ?? []);
+		const mark = type.isInSet(empty ? [
+			...selection.$from.marks(),
+			...beside,
+			...state.doc.nodeAt(from)?.marks ?? []
+		] : state.doc.nodeAt(from)?.marks ?? []);
 		const extent = mark && markRun(state.doc, mark, from, to);
 		const keepStored = (tr, link) => {
 			if (!storedMarks) return tr;
@@ -58857,6 +60073,7 @@ var InkKitEditor = class InkKitEditor {
 			"pasteAsPlainText",
 			"commandState",
 			"setEditable",
+			"setHostActive",
 			"setTextInputPreferences",
 			"setEditingMode",
 			"replaceSource",
@@ -58872,12 +60089,14 @@ var InkKitEditor = class InkKitEditor {
 			"keyDown",
 			"insertPaths",
 			"insertImages",
+			"appendImages",
 			"insertFootnote",
 			"navigateFootnote",
 			"editReferenceDefinition",
 			"setCommentsVisible",
 			"focus",
 			"blur",
+			"refreshReferences",
 			"setKeymap",
 			"textSnapshot",
 			"selectTextRange",