@aicayzer/inkkit 0.1.5 → 0.1.7

package/dist/chunks/{core-D7n0IhAZ.js → core-DkL-wDqy.js}

@@ -22734,7 +22734,7 @@ var SerializerState = class extends Stack {
 	#closeMark;
 };
 //#endregion
-//#region node_modules/.pnpm/prosemirror-view@1.42.6_patch_hash=a3414754d6cb6cd32517617a4affee5f7895ca0b3b976186951d43106adf18b3/node_modules/prosemirror-view/dist/index.js
+//#region node_modules/.pnpm/prosemirror-view@1.42.6_patch_hash=808819d35255b79fc131ebc4873ab2fbcd47cd8f5bc05cd11e8caab02ecee548/node_modules/prosemirror-view/dist/index.js
 var domIndex = function(node) {
 	for (var index = 0;; index++) {
 		node = node.previousSibling;
@@ -25232,6 +25232,17 @@ editHandlers.keydown = (view, _event) => {
 	view.input.lastKeyCodeTime = Date.now();
 	if (android && chrome && event.keyCode == 13) return;
 	if (event.keyCode != 229) view.domObserver.forceFlush();
+	if (event.keyCode != 229 && ![
+		16,
+		17,
+		18,
+		91,
+		92,
+		93
+	].includes(event.keyCode)) {
+		view.domObserver.flush();
+		view.input.lastFocus = 0;
+	}
 	if (ios && event.keyCode == 13 && !event.ctrlKey && !event.altKey && !event.metaKey) {
 		let now = Date.now();
 		view.input.lastIOSEnter = now;
@@ -28391,8 +28402,8 @@ function editorLabels(ctx) {
 	return ctx.isInjected(labelsCtx.key) ? ctx.get(labelsCtx.key) : defaultLabels;
 }
 //#endregion
-//#region node_modules/.pnpm/dompurify@3.4.16/node_modules/dompurify/dist/purify.es.mjs
-/*! @license DOMPurify 3.4.16 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.4.16/LICENSE */
+//#region node_modules/.pnpm/dompurify@3.4.17/node_modules/dompurify/dist/purify.es.mjs
+/*! @license DOMPurify 3.4.17 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.4.17/LICENSE */
 function _OverloadYield(e, d) {
 	this.v = e, this.k = d;
 }
@@ -28516,9 +28527,12 @@ Array.prototype.indexOf;
 var arrayLastIndexOf = unapply(Array.prototype.lastIndexOf);
 var arrayPop = unapply(Array.prototype.pop);
 var arrayPush = unapply(Array.prototype.push);
-Array.prototype.slice;
+var arraySlice = unapply(Array.prototype.slice);
 var arraySplice = unapply(Array.prototype.splice);
 var arrayIsArray = Array.isArray;
+var setCreate = unconstruct(Set);
+var setAdd = unapply(Set.prototype.add);
+var setHas = unapply(Set.prototype.has);
 var stringToLowerCase = unapply(String.prototype.toLowerCase);
 var stringToString = unapply(String.prototype.toString);
 var stringMatch = unapply(String.prototype.match);
@@ -28663,6 +28677,25 @@ function lookupGetter(object, prop) {
 	}
 	return fallbackValue;
 }
+/**
+* Like lookupGetter, but for accessor properties only, and returns null
+* instead of a null-returning fallback when no getter exists on the chain.
+* Lets a caller fall back to a direct property read in environments that
+* lack the getter, where a fallback returning null would be indistinguishable
+* from a legitimate null value (e.g. namespaceURI of a no-namespace element).
+*
+* @param object - The object (usually a prototype) to start the lookup at.
+* @param prop - The accessor property name.
+* @returns The unapplied getter, or null if none was found.
+*/
+function lookupAccessor(object, prop) {
+	while (object !== null) {
+		const desc = getOwnPropertyDescriptor(object, prop);
+		if (desc) return desc.get ? unapply(desc.get) : null;
+		object = getPrototypeOf(object);
+	}
+	return null;
+}
 function isRegex(value) {
 	try {
 		regExpTest(value, "");
@@ -29347,7 +29380,7 @@ var NODE_TYPE = {
 	documentFragment: 11,
 	notation: 12
 };
-var LITERAL_TEXT_ELEMENT_NAMES = [
+var LITERAL_TEXT_ELEMENTS = freeze(addToSet({}, [
 	"style",
 	"script",
 	"xmp",
@@ -29356,15 +29389,7 @@ var LITERAL_TEXT_ELEMENT_NAMES = [
 	"noframes",
 	"plaintext",
 	"noscript"
-];
-var LITERAL_TEXT_ELEMENTS = freeze(addToSet({}, LITERAL_TEXT_ELEMENT_NAMES));
-var LITERAL_TEXT_CLOSE = function() {
-	const map = {};
-	arrayForEach(LITERAL_TEXT_ELEMENT_NAMES, (name) => {
-		map[name] = seal(new RegExp("</" + name + "(?=[\\t\\n\\f\\r />])", "i"));
-	});
-	return freeze(map);
-}();
+]));
 var getGlobal = function getGlobal() {
 	return typeof window === "undefined" ? null : window;
 };
@@ -29442,7 +29467,7 @@ var _resolveObjectOption = function _resolveObjectOption(cfg, key, makeFallback)
 function createDOMPurify() {
 	let window = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : getGlobal();
 	const DOMPurify = (root) => createDOMPurify(root);
-	DOMPurify.version = "3.4.16";
+	DOMPurify.version = "3.4.17";
 	DOMPurify.removed = [];
 	if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document || !window.Element) {
 		DOMPurify.isSupported = false;
@@ -29474,6 +29499,10 @@ function createDOMPurify() {
 	const _readNodeName = function _readNodeName(node) {
 		return getNodeName ? getNodeName(node) : node.nodeName;
 	};
+	const getNamespaceURI = lookupAccessor(ElementPrototype, "namespaceURI");
+	const _readNamespaceURI = function _readNamespaceURI(element) {
+		return getNamespaceURI ? getNamespaceURI(element) : element.namespaceURI;
+	};
 	if (typeof HTMLTemplateElement === "function") {
 		const template = document.createElement("template");
 		if (template.content && template.content.ownerDocument) document = template.content.ownerDocument;
@@ -29594,6 +29623,7 @@ function createDOMPurify() {
 	const SANITIZE_NAMED_PROPS_PREFIX = "user-content-";
 	let KEEP_CONTENT = true;
 	let IN_PLACE = false;
+	let IN_PLACE_VISITED = null;
 	let USE_PROFILES = {};
 	let FORBID_CONTENTS = null;
 	const DEFAULT_FORBID_CONTENTS = addToSet({}, [
@@ -29867,18 +29897,23 @@ function createDOMPurify() {
 	*  return. Return true otherwise.
 	*/
 	const _checkValidNamespace = function _checkValidNamespace(element) {
-		let parent = getParentNode(element);
-		if (!parent || !parent.tagName) parent = {
-			namespaceURI: NAMESPACE,
-			tagName: "template"
-		};
-		const tagName = stringToLowerCase(element.tagName);
-		const parentTagName = stringToLowerCase(parent.tagName);
-		if (!ALLOWED_NAMESPACES[element.namespaceURI]) return false;
-		if (element.namespaceURI === SVG_NAMESPACE) return _checkSvgNamespace(tagName, parent, parentTagName);
-		if (element.namespaceURI === MATHML_NAMESPACE) return _checkMathMlNamespace(tagName, parent, parentTagName);
-		if (element.namespaceURI === HTML_NAMESPACE) return _checkHtmlNamespace(tagName, parent, parentTagName);
-		if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && ALLOWED_NAMESPACES[element.namespaceURI]) return true;
+		const elementNamespace = _readNamespaceURI(element);
+		const tagName = stringToLowerCase(_readNodeName(element));
+		const parentNode = getParentNode(element);
+		let parent;
+		let parentTagName;
+		if (parentNode && _readNodeType(parentNode) === NODE_TYPE.element) {
+			parent = { namespaceURI: _readNamespaceURI(parentNode) };
+			parentTagName = stringToLowerCase(_readNodeName(parentNode));
+		} else {
+			parent = { namespaceURI: NAMESPACE };
+			parentTagName = "template";
+		}
+		if (!ALLOWED_NAMESPACES[elementNamespace]) return false;
+		if (elementNamespace === SVG_NAMESPACE) return _checkSvgNamespace(tagName, parent, parentTagName);
+		if (elementNamespace === MATHML_NAMESPACE) return _checkMathMlNamespace(tagName, parent, parentTagName);
+		if (elementNamespace === HTML_NAMESPACE) return _checkHtmlNamespace(tagName, parent, parentTagName);
+		if (PARSER_MEDIA_TYPE === "application/xhtml+xml" && ALLOWED_NAMESPACES[elementNamespace]) return true;
 		return false;
 	};
 	/**
@@ -29922,36 +29957,21 @@ function createDOMPurify() {
 		}
 	};
 	/**
-	* _neutralizeRoot
-	*
-	* Fail-closed teardown of an in-place root after the sanitize walk aborts
-	* (campaign-3 F2). An internal throw mid-walk — e.g. a page-registered
-	* custom element's reaction detaches a node so `_forceRemove`'s deliberate
-	* parentless guard throws, or any other re-entrant engine mutation — would
-	* otherwise leave the caller's *live* tree half-sanitized, with everything
-	* after the abort point still carrying its handlers. There is no safe way
-	* to resume the walk (the tree mutated under us), so we strip the root bare:
-	* remove every child and every attribute, then let the caller's catch see
-	* the original error. Clobber-safe (cached `remove`/`childNodes`/`attributes`
-	* getters; the root was already clobber-pre-flighted at the IN_PLACE entry).
+	* Fail-closed teardown of an in-place root: strip every disallowed attribute
+	* in the subtree first, so nothing armed is left behind, then remove all
+	* children and the root's own attributes.
 	*
 	* @param root the in-place root to empty
 	*/
 	const _neutralizeRoot = function _neutralizeRoot(root) {
 		_neutralizeSubtree(root);
 		const childNodes = getChildNodes(root);
-		if (childNodes) {
-			const snapshot = [];
-			arrayForEach(childNodes, (child) => {
-				arrayPush(snapshot, child);
-			});
-			arrayForEach(snapshot, (child) => {
-				try {
-					remove(child);
-				} catch (_) {}
-			});
-		}
-		const attributes = getAttributes(root);
+		if (childNodes) arrayForEach(arraySlice(childNodes), (child) => {
+			try {
+				remove(child);
+			} catch (_) {}
+		});
+		const attributes = _readNodeType(root) === NODE_TYPE.element ? getAttributes(root) : null;
 		if (attributes) for (let i = attributes.length - 1; i >= 0; --i) {
 			const attribute = attributes[i];
 			const name = attribute && attribute.name;
@@ -29959,18 +29979,9 @@ function createDOMPurify() {
 		}
 	};
 	/**
-	* _removeAttribute
-	*
-	* Name-based getAttributeNode()/removeAttribute() ASCII-lowercase their
-	* lookup key for HTML elements in an HTML document, so they silently miss an
-	* attribute whose stored qualified name still contains uppercase ASCII
-	* letters. That happens when the node came from a case-preserving source
-	* (an XML/XHTML document imported via importNode(), or createAttributeNS()),
-	* where e.g. `ONERROR` survives the walk: the policy check lowercases to
-	* `onerror` and rejects it, but `removeAttribute('ONERROR')` looks up
-	* `onerror` and finds nothing. Remove the exact Attr node instead, which is
-	* case- and namespace-exact, and fall back to name-based removal only when
-	* the caller could not supply the node.
+	* Removes an attribute, preferably as its exact Attr node: name-based
+	* removal lowercases the name in HTML documents and misses case-preserved
+	* names, e.g. from imported XHTML.
 	*
 	* @param name an Attribute name
 	* @param element a DOM node
@@ -30004,12 +30015,8 @@ function createDOMPurify() {
 		}
 	};
 	/**
-	* _stripDisallowedAttributes
-	*
-	* Removes every attribute the active configuration does not allow from a
-	* single element, using the same allowlist as the main attribute pass (so
-	* `on*` handlers go, but no `/^on/` blocklist is introduced). Used only to
-	* neutralise nodes that are being discarded from an in-place tree.
+	* Removes every attribute the configuration does not allow. Used to
+	* neutralize nodes discarded from an in-place tree.
 	*
 	* @param element the element to strip
 	*/
@@ -30024,77 +30031,158 @@ function createDOMPurify() {
 		}
 	};
 	/**
-	* _neutralizeSubtree
+	* Iterative depth-first walk, so deep trees cannot overflow the call stack,
+	* reading through the cached getters, so clobbering cannot hide children.
+	* When `visit` returns false, the node's children are skipped. With
+	* `intoShadow`, open shadow roots are walked after their host's children.
 	*
-	* Completes the audit-5 F1 fix across every removal path. The KEEP_CONTENT
-	* move-hoist neutralises only disallowed-tag removals; clobber, mXSS-canary,
-	* namespace, comment, processing-instruction and KEEP_CONTENT:false removals
-	* all drop their subtree wholesale via `_forceRemove`. On the IN_PLACE path
-	* those dropped nodes are detached from the caller's LIVE tree but a
-	* handler-bearing original among them (an `<img onerror>`/`<video>` that was
-	* loading) keeps its queued resource event, which fires in page scope after
-	* sanitize returns. This walks a removed subtree and strips every attribute
-	* the active configuration does not allow — so `on*` handlers are cancelled
-	* through the SAME allowlist that governs kept nodes, not a separate `/^on/`
-	* blocklist. Run synchronously before sanitize returns, i.e. before any
-	* queued event can fire. Hook-free by design: these nodes leave the output,
-	* so firing attribute hooks for them would be surprising. Clobber-safe reads;
-	* a doomed clobbered node may shadow `removeAttribute` (its own attributes are
-	* irrelevant — it is discarded — while its non-clobbered descendants, e.g.
-	* the `<img>`, are reached and scrubbed).
-	*
-	* @param root the root of a removed subtree to neutralise
+	* @param root where to start
+	* @param visit called for every node
+	* @param intoShadow whether to enter open shadow roots
 	*/
-	const _neutralizeSubtree = function _neutralizeSubtree(root) {
+	const _walkTree = function _walkTree(root, visit) {
+		let intoShadow = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
 		const stack = [root];
 		while (stack.length > 0) {
 			const node = stack.pop();
-			if (_readNodeType(node) === NODE_TYPE.element) _stripDisallowedAttributes(node);
+			if (visit(node) === false) continue;
+			if (intoShadow && _readNodeType(node) === NODE_TYPE.element) {
+				const shadowRoot = getShadowRoot(node);
+				if (_isDocumentFragment(shadowRoot)) stack.push(shadowRoot);
+			}
 			const childNodes = getChildNodes(node);
 			if (childNodes) for (let i = childNodes.length - 1; i >= 0; --i) stack.push(childNodes[i]);
 		}
 	};
 	/**
-	* _neutralizePatchLinkage
+	* Strips disallowed attributes from every element of a discarded subtree,
+	* so a handler that is already queued (a loading image) cannot fire.
 	*
-	* IN_PLACE entry pre-pass (declarative-partial-updates / streaming
-	* hardening, https://github.com/WICG/declarative-partial-updates).
+	* @param root the root of a removed subtree
+	*/
+	const _neutralizeSubtree = function _neutralizeSubtree(root) {
+		_walkTree(root, (node) => {
+			if (_readNodeType(node) === NODE_TYPE.element) _stripDisallowedAttributes(node);
+		});
+	};
+	/**
+	* All nodes under `root`, root first, including open shadow roots. Template
+	* content is not entered, it is inert.
 	*
-	* The main walk strips patch linkage (`for`/`patchsrc`) and removes range
-	* markers (PIs / markup comments) node-by-node, in document order, AS it
-	* reaches each node. On a live in-place root that leaves a window: from the
-	* moment the root is connected until the walk arrives at a given node, that
-	* node's linkage is live. A patch applied on connection/stream can fire as
-	* a microtask during the walk and inject or teleport an unsanitized DOM
-	* range into a region the iterator has already passed and will not revisit,
-	* so the post-return "tree is sanitized" contract is violated. Sweep the
-	* whole tree once up front and sever every linkage before the walk begins,
-	* closing that window.
+	* @param root the in-place root
+	* @return the nodes
+	*/
+	const _collectLiveNodes = function _collectLiveNodes(root) {
+		const nodes = [];
+		_walkTree(root, (node) => {
+			nodes.push(node);
+		}, true);
+		return nodes;
+	};
+	/**
+	* Strips disallowed attributes from every element that was under the
+	* in-place root when the call started and no longer is, whatever removed
+	* or moved it.
 	*
-	* This CANNOT undo a patch that already fired before sanitize ran — that is
-	* the irreducible "do not IN_PLACE a live-connected attacker tree" caveat —
-	* but it closes everything from sanitize-start onward. Gated on SAFE_FOR_XML
-	* to group with the rest of the declarative-partial-updates handling and
-	* stay overridable, consistent with the codebase.
+	* @param root the in-place root
+	* @param before the root's nodes, collected before the walk
+	*/
+	const _neutralizeEscapedElements = function _neutralizeEscapedElements(root, before) {
+		const reachable = setCreate();
+		arrayForEach(_collectLiveNodes(root), (node) => {
+			if (_readNodeType(node) === NODE_TYPE.element) setAdd(reachable, node);
+		});
+		arrayForEach(before, (node) => {
+			if (_readNodeType(node) === NODE_TYPE.element && !setHas(reachable, node)) _stripDisallowedAttributes(node);
+		});
+	};
+	/**
+	* Neutralizes everything that left the in-place tree during the call: what
+	* DOMPurify removed, and what hooks or custom elements removed or moved out.
 	*
-	* Clobber-safe traversal (cached childNodes getter); per-node try/catch so a
-	* clobbered root cannot defeat the sweep of its non-clobbered descendants.
+	* @param root the in-place root
+	* @param before the root's nodes, collected before the walk
+	* @return true if the root itself was removed
+	*/
+	const _neutralizeDiscarded = function _neutralizeDiscarded(root, before) {
+		let rootRemoved = false;
+		arrayForEach(DOMPurify.removed, (entry) => {
+			if (entry.element) {
+				rootRemoved = rootRemoved || entry.element === root;
+				_neutralizeSubtree(entry.element);
+			}
+		});
+		_neutralizeEscapedElements(root, before);
+		return rootRemoved;
+	};
+	const MAX_UNVISITED_ROUNDS = 8;
+	/**
+	* The walk only moves forward, so a node moved to a position it already
+	* passed is never visited. Give every original node that is still in the
+	* tree but unvisited the normal treatment, hooks included. Nodes created
+	* during the call are left alone. Fails closed if the tree keeps changing.
+	*
+	* @param root the in-place root
+	* @param before the root's nodes, collected before the walk
+	*/
+	const _sanitizeUnvisitedNodes = function _sanitizeUnvisitedNodes(root, before) {
+		const visited = IN_PLACE_VISITED;
+		let original = null;
+		const getOriginal = () => {
+			if (!original) {
+				original = setCreate();
+				arrayForEach(before, (beforeNode) => {
+					setAdd(original, beforeNode);
+				});
+			}
+			return original;
+		};
+		for (let round = 0;; round++) {
+			const live = _collectLiveNodes(root);
+			const containers = [root];
+			let pending = false;
+			arrayForEach(live, (node) => {
+				if (_readNodeType(node) === NODE_TYPE.documentFragment) arrayPush(containers, node);
+				else if (!pending && !setHas(visited, node)) pending = setHas(getOriginal(), node);
+			});
+			if (!pending) return;
+			if (round >= MAX_UNVISITED_ROUNDS) throw typeErrorCreate("the tree kept changing during in-place sanitization; refusing to return it");
+			arrayForEach(containers, (container, index) => {
+				_sanitizeUnvisitedIn(container, index > 0, root, getOriginal());
+			});
+		}
+	};
+	/**
+	* One _sanitizeUnvisitedNodes pass over the root or an open shadow root.
 	*
-	* NOTE (pending real-Chrome confirmation, see test/declarative-patch-probe
-	* .html Q1): this mirrors the existing policy of keeping `for` on
-	* <label>/<output>. If the shipping feature can drive a patch through a
-	* surviving `for`-on-label/output + `id` pair, this pre-pass and the
-	* attribute check at _isBasicCustomElement's caller must additionally drop
-	* that pair on the IN_PLACE path. Left as-is until the taxonomy is verified.
+	* @param container the root or an open shadow root
+	* @param inShadow whether container is a shadow root
+	* @param root the in-place root
+	* @param original the root's nodes collected before the walk, as a set
+	*/
+	const _sanitizeUnvisitedIn = function _sanitizeUnvisitedIn(container, inShadow, root, original) {
+		const iterator = _createNodeIterator(container);
+		let node;
+		while (node = iterator.nextNode()) {
+			if (!setHas(original, node) || setHas(IN_PLACE_VISITED, node)) continue;
+			if (inShadow) _executeHooks(hooks.uponSanitizeShadowNode, node, null);
+			_sanitizeElements(node, root);
+			_sanitizeAttributes(node, root);
+			if (_isDocumentFragment(node.content)) _sanitizeShadowDOM2(node.content);
+		}
+	};
+	/**
+	* Records that _sanitizeElements processed `node`. No-op outside IN_PLACE.
 	*
-	* @param root the in-place root to sweep
+	* @param node the node being processed
 	*/
+	const _markVisited = function _markVisited(node) {
+		if (IN_PLACE_VISITED) setAdd(IN_PLACE_VISITED, node);
+	};
 	/**
-	* Central policy for declarative-partial-updates patch-linkage attributes,
-	* shared by the _neutralizePatchLinkage pre-pass and _isValidAttribute so
-	* the two sites cannot drift: `patchsrc` always links, `for` links
-	* everywhere except on <label>/<output>, and the whole policy is gated on
-	* SAFE_FOR_XML (see the rationale block in _isValidAttribute).
+	* Patch-linkage attributes (declarative partial updates): `patchsrc`
+	* always, `for` everywhere except on <label> and <output>. Gated on
+	* SAFE_FOR_XML. Shared by the IN_PLACE pre-pass and _isValidAttribute.
 	*
 	* @param lcName the transformCaseFunc'd attribute name
 	* @param lcTag the transformCaseFunc'd tag name of the carrying element
@@ -30105,17 +30193,26 @@ function createDOMPurify() {
 		if (lcName === "patchsrc") return true;
 		return lcName === "for" && lcTag !== "label" && lcTag !== "output";
 	};
+	/**
+	* IN_PLACE pre-pass: sever all patch linkage before the walk, so no patch
+	* can fire mid-walk into a part of the tree the walker already passed.
+	* Removes range markers (processing instructions, comments with markup)
+	* and strips linkage attributes. It cannot undo a patch that already fired.
+	*
+	* TODO: if the shipped feature can patch through `for` on <label>/<output>,
+	* drop that pair here too (see test/declarative-patch-probe.html).
+	*
+	* @param root the in-place root to sweep
+	*/
 	const _neutralizePatchLinkage = function _neutralizePatchLinkage(root) {
 		if (!SAFE_FOR_XML) return;
-		const stack = [root];
-		while (stack.length > 0) {
-			const node = stack.pop();
+		_walkTree(root, (node) => {
 			const nodeType = _readNodeType(node);
 			if (nodeType === NODE_TYPE.processingInstruction || nodeType === NODE_TYPE.comment && regExpTest(COMMENT_MARKUP_PROBE, node.data)) {
 				try {
 					remove(node);
 				} catch (_) {}
-				continue;
+				return false;
 			}
 			if (nodeType === NODE_TYPE.element) {
 				const element = node;
@@ -30125,9 +30222,8 @@ function createDOMPurify() {
 					if (element.hasAttribute && element.hasAttribute("for") && _isPatchLinkageAttribute("for", lcTag)) element.removeAttribute("for");
 				} catch (_) {}
 			}
-			const childNodes = getChildNodes(node);
-			if (childNodes) for (let i = childNodes.length - 1; i >= 0; --i) stack.push(childNodes[i]);
-		}
+			return true;
+		});
 	};
 	/**
 	* _initDocument
@@ -30204,6 +30300,27 @@ function createDOMPurify() {
 	*/
 	const _scrubTemplateExpressions2 = function _scrubTemplateExpressions(node) {
 		var _node$querySelectorAl;
+		_scrubOwnCharacterData(node);
+		const templates = (_node$querySelectorAl = node.querySelectorAll) === null || _node$querySelectorAl === void 0 ? void 0 : _node$querySelectorAl.call(node, "template");
+		if (templates) arrayForEach(templates, (tmpl) => {
+			if (_isDocumentFragment(tmpl.content)) _scrubTemplateExpressions2(tmpl.content);
+		});
+	};
+	/**
+	* _scrubOwnCharacterData
+	*
+	* Non-recursive core of _scrubTemplateExpressions: normalize `node` and
+	* strip template expressions from its own character data only. Does not
+	* enter <template>.content or attached shadow roots (NodeIterator never
+	* does). Used by _sanitizeShadowDOM, where every nested template content
+	* and shadow root is already walked - and therefore scrubbed - by its own
+	* recursive _sanitizeShadowDOM call; recursing here as well would rescrub
+	* each nested fragment once per ancestor, which is quadratic in nesting
+	* depth.
+	*
+	* @param node The root whose own character data should be scrubbed.
+	*/
+	const _scrubOwnCharacterData = function _scrubOwnCharacterData(node) {
 		node.normalize();
 		const doc = getOwnerDocument ? getOwnerDocument(node) : node.ownerDocument;
 		const walker = createNodeIterator.call(doc || node, node, NodeFilter.SHOW_TEXT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_CDATA_SECTION | NodeFilter.SHOW_PROCESSING_INSTRUCTION, null);
@@ -30212,10 +30329,6 @@ function createDOMPurify() {
 			currentNode.data = _stripTemplateExpressions(currentNode.data);
 			currentNode = walker.nextNode();
 		}
-		const templates = (_node$querySelectorAl = node.querySelectorAll) === null || _node$querySelectorAl === void 0 ? void 0 : _node$querySelectorAl.call(node, "template");
-		if (templates) arrayForEach(templates, (tmpl) => {
-			if (_isDocumentFragment(tmpl.content)) _scrubTemplateExpressions2(tmpl.content);
-		});
 	};
 	/**
 	* _isClobbered
@@ -30291,7 +30404,7 @@ function createDOMPurify() {
 	*/
 	const _isUnsafeNode = function _isUnsafeNode(currentNode, tagName) {
 		if (SAFE_FOR_XML && currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(ELEMENT_MARKUP_PROBE, currentNode.textContent) && regExpTest(ELEMENT_MARKUP_PROBE, currentNode.innerHTML)) return true;
-		if (SAFE_FOR_XML && currentNode.namespaceURI === HTML_NAMESPACE && LITERAL_TEXT_ELEMENTS[tagName] && (_isNode(currentNode.firstElementChild) || typeof currentNode.textContent === "string" && regExpTest(LITERAL_TEXT_CLOSE[tagName], currentNode.textContent))) return true;
+		if (SAFE_FOR_XML && LITERAL_TEXT_ELEMENTS[tagName] && _readNodeType(currentNode) === NODE_TYPE.element && _readNamespaceURI(currentNode) === HTML_NAMESPACE && (_isNode(currentNode.firstElementChild) || typeof currentNode.textContent === "string" && regExpTest(ELEMENT_MARKUP_PROBE, currentNode.textContent))) return true;
 		if (currentNode.nodeType === NODE_TYPE.processingInstruction) return true;
 		if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(COMMENT_MARKUP_PROBE, currentNode.data)) return true;
 		return false;
@@ -30335,7 +30448,7 @@ function createDOMPurify() {
 	*/
 	const _sanitizeDisallowedNode = function _sanitizeDisallowedNode(currentNode, tagName, root) {
 		if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName) && _matchesNameCheck(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) return false;
-		if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
+		if (KEEP_CONTENT && !FORBID_CONTENTS[tagName] && !FORBID_CONTENTS[stringToLowerCase(tagName)]) {
 			const parentNode = getParentNode(currentNode);
 			const childNodes = getChildNodes(currentNode);
 			if (childNodes && parentNode) {
@@ -30368,35 +30481,13 @@ function createDOMPurify() {
 		return set === defaultSet || set === setConfigSet ? clone(set) : set;
 	};
 	/**
-	* Shared guard for a node that a hook has detached from the walk tree,
-	* used after each element-hook site in _sanitizeElements. Detaching is a
-	* long-standing user pattern (issue #469; draw.io-style foreignObject
-	* filtering). Per the cached, unclobberable parentNode getter the node is
-	* genuinely out of the tree, so it can reach neither the serialized
-	* output nor an IN_PLACE live tree; treat it as removed and stop
-	* processing it. Without this guard, the unsafe-node / namespace checks
-	* would call _forceRemove on a parentless node and hit the REPORT-3
-	* fail-closed throw — which exists for nodes DOMPurify wants gone but
-	* *cannot* detach (clobbered / parentless roots), the opposite of a node
-	* that is already safely gone. The walk root is exempt: a detached
-	* IN_PLACE root is legitimate input and must still be fully sanitized,
-	* and a kill-decision on it must keep hitting the REPORT-3 throw.
-	*
-	* Nodes detached by hooks stay the hook's responsibility for placement:
-	* they are not recorded in DOMPurify.removed, so the post-walk IN_PLACE
-	* pass (which iterates DOMPurify.removed) does not reach them. But a
-	* hook-detached subtree can still hold a queued resource-event handler -
-	* e.g. an <img onload> that began loading when the caller built the live
-	* tree - which fires in page scope after sanitize returns even though the
-	* handler never reached the returned tree. That is the audit-5 F1 hazard,
-	* and the documented node.remove() hook pattern walks straight into it.
-	* So on the IN_PLACE path we neutralize the detached subtree inline,
-	* stripping its non-allow-listed attributes before returning, exactly as
-	* the post-walk pass does for _forceRemove'd subtrees.
+	* A hook may have detached the node it was called for. If so, treat it as
+	* removed and stop processing it; the walk root is exempt. On the IN_PLACE
+	* path the detached subtree is neutralized right away.
 	*
 	* @param currentNode the node a hook may have detached
 	* @param root the current walk root
-	* @return true if the node is detached and now handled, false otherwise
+	* @return true if the node was detached
 	*/
 	const _handleHookDetachedNode = function _handleHookDetachedNode(currentNode, root) {
 		if (currentNode === root || getParentNode(currentNode) !== null) return false;
@@ -30413,6 +30504,7 @@ function createDOMPurify() {
 	* @return true if node was killed, false if left alive
 	*/
 	const _sanitizeElements = function _sanitizeElements(currentNode, root) {
+		_markVisited(currentNode);
 		_executeHooks(hooks.beforeSanitizeElements, currentNode, null);
 		if (_handleHookDetachedNode(currentNode, root)) return true;
 		if (_isClobbered(currentNode)) {
@@ -30556,6 +30648,22 @@ function createDOMPurify() {
 		}
 	};
 	/**
+	* _isUnsafeAttributeValue
+	*
+	* Value-based attribute checks that the attribute walk applies before any
+	* hook can force-keep an attribute, shared with the public
+	* isValidAttribute() so that it never approves a value sanitize() would
+	* strip.
+	*
+	* @param name the attribute name as found on the node (case preserved)
+	* @param value the attribute value
+	* @returns true if the attribute must be removed because of its value
+	*/
+	const _isUnsafeAttributeValue = function _isUnsafeAttributeValue(name, value) {
+		if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|script|title|xmp|textarea|noscript|iframe|noembed|noframes)/i, value)) return true;
+		return stringToLowerCase(name) === "attributename" && stringMatch(value, "href") !== null;
+	};
+	/**
 	* _sanitizeAttributes
 	*
 	* @protect attributes
@@ -30599,11 +30707,7 @@ function createDOMPurify() {
 				value = SANITIZE_NAMED_PROPS_PREFIX + value;
 				recreatedNamedProp = true;
 			}
-			if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|script|title|xmp|textarea|noscript|iframe|noembed|noframes)/i, value)) {
-				_removeAttribute(name, currentNode, attr);
-				continue;
-			}
-			if (lcName === "attributename" && stringMatch(value, "href")) {
+			if (_isUnsafeAttributeValue(name, value)) {
 				_removeAttribute(name, currentNode, attr);
 				continue;
 			}
@@ -30651,24 +30755,13 @@ function createDOMPurify() {
 				}
 			}
 		}
+		if (SAFE_FOR_TEMPLATES) _scrubOwnCharacterData(fragment);
 		_executeHooks(hooks.afterSanitizeShadowDOM, fragment, null);
 	};
 	/**
-	* _sanitizeAttachedShadowRoots
-	*
-	* Walks `root` and feeds every attached shadow root we encounter into
-	* the existing _sanitizeShadowDOM pipeline. The default node iterator
-	* does not descend into shadow trees, so nodes inside an attached
-	* shadow root would otherwise be skipped entirely.
-	*
-	* Two real input paths put attached shadow roots in front of us:
-	*   1. IN_PLACE on a DOM node that already has shadow roots attached.
-	*   2. DOM-node input where importNode(dirty, true) deep-clones the
-	*      shadow root because it was created with `clonable: true`.
-	*
-	* This pass runs once, up front, so the main iteration loop (and the
-	* existing _sanitizeShadowDOM template-content recursion) stay
-	* untouched — string-input paths are not affected.
+	* Sanitizes every attached shadow root under `root`, since the node
+	* iterator does not enter shadow trees. Needed for IN_PLACE input and for
+	* DOM input whose clonable shadow roots were copied by importNode().
 	*
 	* @param root the subtree root to walk for attached shadow roots
 	*/
@@ -30733,6 +30826,8 @@ function createDOMPurify() {
 		if (hooks.uponSanitizeAttribute.length > 0) ALLOWED_ATTR = clone(ALLOWED_ATTR);
 		DOMPurify.removed = [];
 		const inPlace = IN_PLACE && typeof dirty !== "string" && _isNode(dirty);
+		let inPlaceNodes = [];
+		const outerVisited = IN_PLACE_VISITED;
 		if (inPlace) {
 			_neutralizePatchLinkage(dirty);
 			const nn = _readNodeName(dirty);
@@ -30747,12 +30842,8 @@ function createDOMPurify() {
 				_neutralizeRoot(dirty);
 				throw typeErrorCreate("root node is clobbered and cannot be sanitized in-place");
 			}
-			try {
-				_sanitizeAttachedShadowRoots(dirty);
-			} catch (error) {
-				_neutralizeRoot(dirty);
-				throw error;
-			}
+			inPlaceNodes = _collectLiveNodes(dirty);
+			IN_PLACE_VISITED = setCreate();
 		} else if (_isNode(dirty)) {
 			body = _initDocument("<!---->");
 			importedNode = body.ownerDocument.importNode(dirty, true);
@@ -30768,30 +30859,25 @@ function createDOMPurify() {
 		if (body && FORCE_BODY) _forceRemove(body.firstChild);
 		const walkRoot = inPlace ? dirty : body;
 		try {
+			if (inPlace) _sanitizeAttachedShadowRoots(dirty);
 			const nodeIterator = _createNodeIterator(walkRoot);
 			while (currentNode = nodeIterator.nextNode()) {
 				_sanitizeElements(currentNode, walkRoot);
 				_sanitizeAttributes(currentNode, walkRoot);
 				if (_isDocumentFragment(currentNode.content)) _sanitizeShadowDOM2(currentNode.content);
 			}
+			if (inPlace) _sanitizeUnvisitedNodes(dirty, inPlaceNodes);
 		} catch (error) {
 			if (inPlace) {
 				_neutralizeRoot(dirty);
-				arrayForEach(DOMPurify.removed, (entry) => {
-					if (entry.element) _neutralizeSubtree(entry.element);
-				});
+				_neutralizeDiscarded(dirty, inPlaceNodes);
 			}
 			throw error;
+		} finally {
+			IN_PLACE_VISITED = outerVisited;
 		}
 		if (inPlace) {
-			let rootWasRemoved = false;
-			arrayForEach(DOMPurify.removed, (entry) => {
-				if (entry.element) {
-					if (entry.element === dirty) rootWasRemoved = true;
-					_neutralizeSubtree(entry.element);
-				}
-			});
-			if (rootWasRemoved) throw typeErrorCreate("a node selected for removal could not be safely returned; refusing to sanitize in place");
+			if (_neutralizeDiscarded(dirty, inPlaceNodes)) throw typeErrorCreate("a node selected for removal could not be safely returned; refusing to sanitize in place");
 			if (SAFE_FOR_TEMPLATES) _scrubTemplateExpressions2(dirty);
 			return dirty;
 		}
@@ -30828,6 +30914,7 @@ function createDOMPurify() {
 		if (!CONFIG) _parseConfig({});
 		const lcTag = transformCaseFunc(tag);
 		const lcName = transformCaseFunc(attr);
+		if (typeof value === "string" && (_isUnsafeAttributeValue(attr, value) || !ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(SELF_CLOSING_TAG, value))) return false;
 		return _isValidAttribute(lcTag, lcName, value);
 	};
 	DOMPurify.addHook = function(entryPoint, hookFunction) {
@@ -31167,6 +31254,18 @@ function mermaidPreview(onError) {
 	}));
 }
 //#endregion
+//#region src/literal-text.ts
+/** Literal lines stay in their textblock, including headings and table cells. */
+function literalTextNodes(schema, text, marks, isHTML) {
+	const nodes = [];
+	const lines = text.replace(/\r\n?/g, "\n").split("\n");
+	lines.forEach((line, index) => {
+		if (index) nodes.push(schema.nodes.hardbreak.create({ isHTML }, null, index === lines.length - 1 && line === "" ? [] : marks));
+		if (line) nodes.push(schema.text(line, marks));
+	});
+	return nodes;
+}
+//#endregion
 //#region node_modules/.pnpm/rope-sequence@1.3.4/node_modules/rope-sequence/dist/index.js
 var GOOD_LEAF_SIZE = 200;
 var RopeSequence = function RopeSequence() {};
@@ -31621,6 +31720,13 @@ A command function that redoes the last undone change, if any.
 */
 var redo = buildCommand(true, true);
 /**
+The amount of redoable events available in a given editor state.
+*/
+function redoDepth(state) {
+	let hist = historyKey.getState(state);
+	return hist ? hist.undone.eventCount : 0;
+}
+/**
 Returns true if the given transaction was generated by the history
 plugin.
 */
@@ -44042,7 +44148,7 @@ function nodeText(node, missingImages, fileDescriptions) {
 	}
 	return clipboardText(node.content, missingImages, fileDescriptions);
 }
-function clipboardContent(content, schema) {
+function clipboardDOM(content, schema) {
 	content = shareableFragment(content);
 	const container = document.createElement("div");
 	const serializer = DOMSerializer.fromSchema(schema);
@@ -44072,14 +44178,30 @@ function clipboardContent(content, schema) {
 		label.textContent = `[${definition.getAttribute("data-inkkit-label")}] `;
 		definition.prepend(label);
 	}
+	return container;
+}
+function clipboardContent(content, schema) {
 	return {
 		text: clipboardText(content),
-		html: container.innerHTML
+		html: clipboardDOM(content, schema).innerHTML
 	};
 }
-var visibleClipboard = $prose(() => new Plugin({
+function clipboardSerializer(schema) {
+	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);
+		return output;
+	};
+	return safe;
+}
+var visibleClipboard = $prose((ctx) => new Plugin({
 	key: new PluginKey("visibleClipboard"),
-	props: { clipboardTextSerializer: (slice) => clipboardText(slice.content) }
+	props: {
+		clipboardSerializer: clipboardSerializer(ctx.get(schemaCtx)),
+		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) {
@@ -45023,13 +45145,16 @@ function lineBreakHTML(value) {
 		"<br/>"
 	].includes(value.trim());
 }
-function restoreInlineBreaks(node) {
-	if (node.type === "paragraph" && node.children.length > 1 || node.type === "heading" || node.type === "tableCell") node.children = node.children.map((child) => child.type === "html" && lineBreakHTML(child.value) ? {
-		type: "break",
-		data: { inkkitHTMLBreak: true },
-		position: child.position
-	} : child);
-	if ("children" in node) node.children.forEach(restoreInlineBreaks);
+function restoreInlineBreaks(node, inline = false) {
+	const restore = node.type === "paragraph" && node.children.length > 1 || node.type === "heading" || node.type === "tableCell" || inline;
+	if ("children" in node) {
+		node.children = node.children.map((child) => restore && child.type === "html" && lineBreakHTML(child.value) ? {
+			type: "break",
+			data: { inkkitHTMLBreak: true },
+			position: child.position
+		} : child);
+		node.children.forEach((child) => restoreInlineBreaks(child, restore));
+	}
 }
 function containsUnsupported(node, images, inline = false) {
 	if (!inline && node.type === "html" && lineBreakHTML(node.value)) return false;
@@ -45934,6 +46059,12 @@ function retainSource(before, after, source, canonical, lineEnding, inTable = fa
 		}, source, canonical, lineEnding, inTable);
 		const first = before.children[0];
 		if (spacer(first)) return retained;
+		const gap = source.slice(first.position.end.offset, before.children[1].position.start.offset);
+		if (!/\r?\n[ \t]*\r?\n/.test(gap)) {
+			const from = first.position.start.offset - start;
+			const to = before.children[1].position.start.offset - start;
+			return retained.startsWith(source.slice(start, start + to)) ? retained.slice(0, from) + retained.slice(to) : retained;
+		}
 		const from = first.position.start.offset - start;
 		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;
@@ -50114,7 +50245,23 @@ function padShortRows(node) {
 	if ("children" in node) node.children.forEach(padShortRows);
 }
 var remarkDialectPlugin = $remark("remarkDialect", () => remarkDialect);
-var commonmarkWithLiteralReferences = commonmark.filter((plugin) => !remarkInlineLinkPlugin.includes(plugin) && plugin !== hardbreakClearMarkPlugin && !hardbreakKeymap.some((part) => part === plugin) && plugin !== syncHeadingIdPlugin && plugin !== createCodeBlockInputRule);
+var preservingSoftBreaks = $remark("preservingSoftBreaks", () => () => (tree) => {
+	const walk = (parent) => {
+		parent.children = parent.children.flatMap((child) => {
+			if ("children" in child) walk(child);
+			if (child.type !== "text" || !/[\r\n]/.test(child.value)) return [child];
+			return child.value.split(/(\r?\n|\r)/).flatMap((value) => !value ? [] : /^(?:\r?\n|\r)$/.test(value) ? [{
+				type: "break",
+				data: { isInline: true }
+			}] : [{
+				type: "text",
+				value
+			}]);
+		});
+	};
+	walk(tree);
+});
+var commonmarkWithLiteralReferences = commonmark.filter((plugin) => !remarkInlineLinkPlugin.includes(plugin) && !remarkLineBreak.includes(plugin) && plugin !== hardbreakClearMarkPlugin && !hardbreakKeymap.some((part) => part === plugin) && plugin !== syncHeadingIdPlugin && plugin !== createCodeBlockInputRule);
 var breaksWithoutMarks = $prose((ctx) => new Plugin({
 	key: new PluginKey("inkkitBreaksWithoutMarks"),
 	appendTransaction(transactions, oldState, newState) {
@@ -50124,9 +50271,24 @@ var breaksWithoutMarks = $prose((ctx) => new Plugin({
 		const end = oldState.doc.content.findDiffEnd(newState.doc.content).b;
 		const type = hardbreakSchema.type(ctx);
 		const tr = newState.tr;
+		newState.doc.nodesBetween(start, Math.max(start, end), (node, pos) => {
+			if (!node.isTextblock || !node.firstChild) return;
+			let count = 0;
+			for (let index = 0; index < node.childCount; index++) {
+				const child = node.child(index);
+				if (child.type !== type || !child.attrs.isInline || child.attrs.isHTML) break;
+				let previous = pos + 1 + count;
+				for (let transaction = transactions.length - 1; transaction >= 0; transaction--) previous = transactions[transaction].mapping.invert().map(previous, 1);
+				const before = oldState.doc.nodeAt(previous);
+				if (before?.type !== type || !before.attrs.isInline || before.attrs.isHTML || oldState.doc.resolve(previous).parentOffset === 0) break;
+				count += child.nodeSize;
+			}
+			if (count) tr.delete(tr.mapping.map(pos + 1), tr.mapping.map(pos + 1 + count));
+			return false;
+		});
 		newState.doc.nodesBetween(start, Math.max(start, end), (node, pos) => {
 			if (node.type !== type) return;
-			for (const mark of node.marks) if (mark.type.spec.code) tr.removeMark(pos, pos + 1, mark.type);
+			for (const mark of node.marks) if (mark.type.spec.code) tr.removeMark(tr.mapping.map(pos), tr.mapping.map(pos + 1), mark.type);
 		});
 		return tr.steps.length ? tr : null;
 	}
@@ -50388,6 +50550,7 @@ function createDialect(images, wikiLinks = false, files = false) {
 		wikiLinks || files ? linkedSyntax(wikiLinks, files) : [],
 		createLiteralPreservation(images || files),
 		commonmarkWithLiteralReferences,
+		preservingSoftBreaks,
 		$node("doc", () => ({
 			...docSchema.schema,
 			attrs: {
@@ -51343,7 +51506,8 @@ var ImageView = class {
 				return;
 			}
 			const presentation = state.presentation;
-			if (presentation.kind === "missing" || presentation.kind === "error") this.card(label, presentation.kind === "missing" ? this.runtime.labels.fileMissing : this.runtime.labels.fileError, true);
+			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") {
 				this.renderImage(presentation.url, label, width);
 				this.card(label);
@@ -53987,6 +54151,7 @@ var PasteController = class {
 	async run(input, files = [], target) {
 		if (this.dead) throw new InkKitError("destroyed", "The editor was destroyed.");
 		if (this.pending) throw new InkKitError("operation-pending", "An image paste is still pending.");
+		input = this.options.restoreCopy?.(input) ?? input;
 		const context = { ...this.options.context() };
 		const ctx = this.options.ctx();
 		const view = ctx.get(editorViewCtx);
@@ -54027,8 +54192,12 @@ var PasteController = class {
 					this.dispatch(view, caretAfterInsertion(view.state.tr.insertText(input.text, anchor.from, anchor.to)).scrollIntoView());
 					return;
 				}
-				const paragraphs = input.text.replace(/\r\n?/g, "\n").split("\n").map((line) => schema.nodes.paragraph.create(null, line ? schema.text(line) : void 0));
-				slice = new Slice(Fragment.fromArray(paragraphs), 1, 1);
+				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 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) {
 				const container = visibleContent(ctx, input.html);
 				const imported = /* @__PURE__ */ new Map();
@@ -55019,14 +55188,7 @@ function replacementSlice(state, from, to, value) {
 	const nodes = [];
 	if (start.parent.type.spec.code) {
 		if (value) nodes.push(state.schema.text(value, marks));
-	} else {
-		const isHTML = htmlBreakAt(start);
-		const lines = value.split("\n");
-		lines.forEach((line, index) => {
-			if (index) nodes.push(state.schema.nodes.hardbreak.create({ isHTML }, null, index === lines.length - 1 && line === "" ? [] : marks));
-			if (line) nodes.push(state.schema.text(line, marks));
-		});
-	}
+	} else nodes.push(...literalTextNodes(state.schema, value, marks, htmlBreakAt(start)));
 	return new Slice(Fragment.fromArray(nodes), 0, 0);
 }
 function replaceFormatted(view, search, replacement, preflight, all = false) {
@@ -55853,6 +56015,15 @@ function caretState(state) {
 		quoted: quoted($from, $to)
 	};
 }
+function terminalSelection(doc) {
+	const $end = doc.resolve(doc.content.size);
+	const gap = GapCursor;
+	if (isImageBlock(doc.lastChild) && gap.valid($end)) return new GapCursor($end);
+	const text = Selection.findFrom($end, -1, true);
+	if (text) return text;
+	if (gap.valid($end)) return new GapCursor($end);
+	throw new InkKitError("preservation", "Document has no safe writing position");
+}
 function quoted($from, $to) {
 	return $from.blockRange($to, (node) => node.type.name === "blockquote") != null;
 }
@@ -56065,6 +56236,8 @@ var InkKitEditor = class InkKitEditor {
 	typedSteps = [];
 	undoneSteps = [];
 	formattedUndone = 0;
+	formattedRedoLimit;
+	historyDirection;
 	lastSourceInput = 0;
 	syncingSource = false;
 	mode = "formatted";
@@ -56082,6 +56255,52 @@ var InkKitEditor = class InkKitEditor {
 	auxClickHandler;
 	untrackLinkModifier;
 	footnoteKeyHandler;
+	localCopies = /* @__PURE__ */ new Map();
+	rememberCopy(output, markdown, content, privateSource = false, actualCopy = false) {
+		let comments = privateSource;
+		content.descendants((node) => {
+			const labelled = (label) => typeof label === "string" && literalCommentSpans(label).length > 0;
+			if (isComment(node) || /^(?:reference|footnote)_/.test(node.type.name) && labelled(node.attrs.label) || node.marks.some((mark) => mark.type.name === "link" && (labelled(mark.attrs.label) || commentProvenance(mark.attrs.referenceContent)))) comments = true;
+		});
+		if (!comments) {
+			if (actualCopy) this.localCopies.clear();
+			return output;
+		}
+		const key = JSON.stringify([
+			output.text,
+			output.html,
+			markdown
+		]);
+		const previous = this.localCopies.get(key);
+		if (previous) {
+			output.html = previous.html;
+			if (actualCopy) this.localCopies.clear();
+			this.localCopies.set(key, previous);
+			return output;
+		}
+		const wrapper = document.createElement("div");
+		const token = Array.from(crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16)), (byte) => byte.toString(16).padStart(2, "0")).join("");
+		wrapper.setAttribute("data-inkkit-local-copy", token);
+		wrapper.innerHTML = output.html;
+		output.html = wrapper.outerHTML;
+		if (actualCopy) this.localCopies.clear();
+		this.localCopies.set(key, {
+			text: output.text,
+			html: output.html,
+			markdown
+		});
+		return output;
+	}
+	retainCopy(html) {
+		for (const [key, copy] of this.localCopies) if (copy.html !== html) this.localCopies.delete(key);
+	}
+	restoreCopy(input) {
+		const copy = [...this.localCopies.values()].find((copy) => copy.text === input.text && copy.html === input.html);
+		return copy && input.markdown == null && !input.plainText && copy.text === input.text && copy.html === input.html ? {
+			...input,
+			markdown: copy.markdown
+		} : input;
+	}
 	copyHandler;
 	originalSource = "";
 	reportingSuppressed = false;
@@ -56297,7 +56516,9 @@ var InkKitEditor = class InkKitEditor {
 			revision: this.session.mark(),
 			lastMarkdown: this.lastMarkdown,
 			literalMatch: this.literalMatch,
-			textScope: this.textScope
+			textScope: this.textScope,
+			formattedRedoLimit: this.formattedRedoLimit,
+			formattedUndone: this.formattedUndone
 		};
 	}
 	finish(call, before, failure) {
@@ -56319,6 +56540,8 @@ var InkKitEditor = class InkKitEditor {
 		this.lastMarkdown = before.lastMarkdown;
 		this.literalMatch = before.literalMatch;
 		this.textScope = before.textScope;
+		this.formattedRedoLimit = before.formattedRedoLimit;
+		this.formattedUndone = before.formattedUndone;
 	}
 	/** Reports a refused edit to the facade call that made it, or else to `events.error`. */
 	refuse(error) {
@@ -56459,7 +56682,7 @@ var InkKitEditor = class InkKitEditor {
 			table: this.literalSurface ? void 0 : tableContext(state),
 			commands: {
 				undo: mutable && (!!this.pendingSource || undo(state)),
-				redo: mutable && (this.undoneSteps.length > 0 || !this.pendingSource && redo(state)),
+				redo: mutable && (this.undoneSteps.length > 0 || !this.pendingSource && this.formattedRedoLimit !== 0 && redo(state)),
 				insertText: mutable,
 				paste: mutable,
 				replace: mutable,
@@ -56629,7 +56852,9 @@ var InkKitEditor = class InkKitEditor {
 		this.assertAlive();
 		expectString(text, "text");
 		this.assertMutation(expectedGeneration);
-		return this.applySource(text, true);
+		const changed = this.applySource(text, true);
+		if (changed) this.localCopies.clear();
+		return changed;
 	}
 	applySource(text, isolated, from, to, native = false) {
 		if (!this.writable) throw new InkKitError("read-only", "The editor is read-only");
@@ -56648,6 +56873,7 @@ var InkKitEditor = class InkKitEditor {
 		const previous = this.pendingSource;
 		const continuing = previous && !previous.closed && !closed && now - this.lastSourceInput <= sourceGroupDelay;
 		if (previous && !continuing) this.rememberTypedStep(previous);
+		this.formattedRedoLimit = 0;
 		this.lastSourceInput = now;
 		this.undoneSteps = [];
 		this.formattedUndone = 0;
@@ -56775,7 +57001,7 @@ var InkKitEditor = class InkKitEditor {
 			}
 		}
 		let tr = view.state.tr.replaceWith(0, view.state.doc.content.size, parsed.content).setDocAttribute(sourceAttribute, provenance).setMeta(sourceReplacement, true);
-		tr.setSelection(Selection.atEnd(tr.doc));
+		tr.setSelection(terminalSelection(tr.doc));
 		if (isolated) tr = closeHistory(tr);
 		view.dispatch(tr);
 		if (isolated) view.dispatch(closeHistory(view.state.tr).setMeta("addToHistory", false));
@@ -56786,7 +57012,7 @@ var InkKitEditor = class InkKitEditor {
 		this.assertMutation(expectedGeneration);
 		if (this.literalSurface && this.stepTypedSource("undo")) return true;
 		const view = this.editor.ctx.get(editorViewCtx);
-		const undone = !this.literalSurface && undoSmartPunctuation(view.state, view.dispatch) || undo(view.state, view.dispatch);
+		const undone = !this.literalSurface && undoSmartPunctuation(view.state, view.dispatch) || this.stepFormattedHistory("undo");
 		if (undone) {
 			if (this.literalSurface && this.undoneSteps.length) this.formattedUndone++;
 			else this.undoneSteps = [];
@@ -56799,14 +57025,30 @@ var InkKitEditor = class InkKitEditor {
 		const view = this.editor.ctx.get(editorViewCtx);
 		if (this.literalSurface) {
 			if (this.formattedUndone > 0) {
-				this.formattedUndone--;
-				if (redo(view.state, view.dispatch)) return true;
+				if (this.formattedRedoLimit !== 0 && redo(view.state)) {
+					const redone = this.stepFormattedHistory("redo");
+					if (redone) this.formattedUndone--;
+					return redone;
+				}
 				this.formattedUndone = 0;
 			}
 			if (this.stepTypedSource("redo")) return true;
 			if (this.pendingSource) return false;
 		}
-		return redo(view.state, view.dispatch);
+		return this.stepFormattedHistory("redo");
+	}
+	stepFormattedHistory(direction) {
+		if (direction === "redo" && this.formattedRedoLimit === 0) return false;
+		const view = this.editor.ctx.get(editorViewCtx);
+		const before = view.state;
+		const previous = this.historyDirection;
+		this.historyDirection = direction;
+		try {
+			(direction === "undo" ? undo : redo)(before, view.dispatch);
+			return view.state !== before;
+		} finally {
+			this.historyDirection = previous;
+		}
 	}
 	replaceLiteralSelection(text, isolated = true, retainEndings = false) {
 		const value = this.plain.value;
@@ -56909,6 +57151,7 @@ var InkKitEditor = class InkKitEditor {
 		const metadata = referenceMetadata(this.editor.ctx, selectedDoc ?? doc, content);
 		if (metadata != null) result.html = withReferenceMetadata(result.html, metadata);
 		this.assertCaptured(captured);
+		this.rememberCopy(result, markdown, content, selectedSource != null && selectedSource.markdown !== selectedSource.shareable);
 		return {
 			...version,
 			...result
@@ -56918,7 +57161,7 @@ var InkKitEditor = class InkKitEditor {
 	*  clipboard again while this runs. */
 	async paste(input, expectedGeneration) {
 		this.assertAlive();
-		input = clipboardInput(input);
+		input = this.restoreCopy(clipboardInput(input));
 		this.assertMutation(expectedGeneration);
 		if (this.literalSurface) {
 			this.pasteAsPlainText(this.mode === "source" && this.formatType === "md" ? input.markdown ?? input.text : input.text);
@@ -56951,14 +57194,9 @@ var InkKitEditor = class InkKitEditor {
 			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 children = [];
 				const isHTML = !inHiddenComment && htmlBreakAt(view.state.selection.$from);
 				const lines = text.replace(/\r\n?/g, "\n").split("\n");
-				lines.forEach((line, index) => {
-					const finalBreak = index === lines.length - 1 && line === "";
-					if (index) children.push(schema.nodes.hardbreak.create({ isHTML }, null, finalBreak ? [] : marks));
-					if (line) children.push(schema.text(line, marks));
-				});
+				const children = literalTextNodes(schema, text, marks, isHTML);
 				if (!children.length) {
 					view.dispatch(view.state.tr.deleteSelection());
 					return;
@@ -57001,12 +57239,14 @@ var InkKitEditor = class InkKitEditor {
 	async destroy() {
 		if (this.destroyed) return;
 		this.destroyed = true;
+		this.localCopies.clear();
 		this.ready = false;
 		this.session.close();
 		this.pendingSource = void 0;
 		this.typedSteps = [];
 		this.undoneSteps = [];
 		this.formattedUndone = 0;
+		this.formattedRedoLimit = void 0;
 		this.cancelExports();
 		this.mediaPolicy();
 		this.pasteController.destroy();
@@ -57046,6 +57286,7 @@ var InkKitEditor = class InkKitEditor {
 			if (portable && this.events.clipboard) this.clipboardSnapshot("selection").then(async (content) => {
 				if (cut) refuseUnportableCut(content);
 				await writeClipboard(this.events, content);
+				this.retainCopy(content.html);
 				if (cut) {
 					this.assertCut(captured);
 					this.plain.setSelectionRange(from, to);
@@ -57055,6 +57296,7 @@ var InkKitEditor = class InkKitEditor {
 			else {
 				const output = clipboardContent(parsed.content, parsed.type.schema);
 				if (!event.clipboardData) return;
+				this.rememberCopy(output, selected.markdown, parsed.content, selected.markdown !== selected.shareable, true);
 				event.clipboardData.setData("text/plain", output.text);
 				event.clipboardData.setData("text/html", output.html);
 				if (portable) {
@@ -57079,6 +57321,7 @@ var InkKitEditor = class InkKitEditor {
 		instance.ownsRootClass = !root.classList.contains("inkkit-root");
 		root.classList.add("inkkit-root");
 		instance.pasteController = new PasteController({
+			restoreCopy: (input) => instance.restoreCopy(input),
 			ctx: () => instance.editor.ctx,
 			context: () => instance.context(),
 			adapter: options.images,
@@ -57182,6 +57425,14 @@ var InkKitEditor = class InkKitEditor {
 							return;
 						}
 					}
+					if (instance.formattedRedoLimit !== void 0) {
+						const depth = redoDepth(next);
+						if (depth === 0) instance.formattedRedoLimit = void 0;
+						else if (next !== this.state) {
+							if (instance.historyDirection === "undo") instance.formattedRedoLimit = Math.min(depth, instance.formattedRedoLimit + 1);
+							else if (instance.historyDirection === "redo") instance.formattedRedoLimit = Math.max(0, instance.formattedRedoLimit - 1);
+						}
+					}
 					this.updateState(next);
 				},
 				handleScrollToSelection: () => {
@@ -57189,7 +57440,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-BIasnL-b.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(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-TSUdUlMi.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: {
@@ -57269,6 +57520,7 @@ var InkKitEditor = class InkKitEditor {
 			event.preventDefault();
 			instance.paste({
 				text: event.clipboardData.getData("text/plain"),
+				html: event.clipboardData.getData("text/html"),
 				markdown: event.clipboardData.getData("text/markdown") || void 0
 			}).catch((error) => instance.report(error));
 		});
@@ -57338,11 +57590,13 @@ var InkKitEditor = class InkKitEditor {
 					instance.snapshot();
 					const content = expanded;
 					const valid = fragment.firstChild?.isInline ? Fragment.from(view.state.schema.nodes.paragraph.create(null, fragment)) : fragment;
-					selectionMarkdown(instance.editor.ctx, view.state.doc, valid);
+					const markdown = selectionMarkdown(instance.editor.ctx, view.state.doc, valid);
 					const output = clipboardContent(content, view.state.schema);
-					event.clipboardData.setData("text/plain", output.text);
 					const metadata = referenceMetadata(instance.editor.ctx, view.state.doc, valid);
-					event.clipboardData.setData("text/html", metadata != null ? withReferenceMetadata(output.html, metadata) : output.html);
+					if (metadata != null) output.html = withReferenceMetadata(output.html, metadata);
+					instance.rememberCopy(output, markdown, fragment, false, true);
+					event.clipboardData.setData("text/plain", output.text);
+					event.clipboardData.setData("text/html", output.html);
 					if (event.type === "cut" && instance.writable) view.dispatch(view.state.tr.deleteSelection().scrollIntoView());
 				} catch (error) {
 					instance.report(error);
@@ -57358,6 +57612,7 @@ var InkKitEditor = class InkKitEditor {
 				instance.clipboardSnapshot("selection").then(async (content) => {
 					if (cut) refuseUnportableCut(content);
 					await writeClipboard(events, content);
+					instance.retainCopy(content.html);
 					if (cut) {
 						instance.assertCut(captured);
 						view.dispatch(view.state.tr.deleteRange(from, to).scrollIntoView());
@@ -57405,6 +57660,7 @@ var InkKitEditor = class InkKitEditor {
 		this.typedSteps = [];
 		this.undoneSteps = [];
 		this.formattedUndone = 0;
+		this.formattedRedoLimit = void 0;
 		this.mode = "formatted";
 		this.plainComposing = false;
 		this.beforePlainInput = void 0;
@@ -57784,6 +58040,7 @@ var InkKitEditor = class InkKitEditor {
 		}])[0]);
 	}
 	load(markdown, preservation) {
+		this.localCopies.clear();
 		this.originalSource = markdown;
 		const { ctx } = this.editor;
 		const view = ctx.get(editorViewCtx);
@@ -57800,9 +58057,7 @@ var InkKitEditor = class InkKitEditor {
 		this.preservation = preservation;
 		this.carried = void 0;
 		this.lastMarkdown = markdown;
-		const { doc } = view.state;
-		const $end = doc.resolve(doc.content.size);
-		const end = isImageBlock(doc.lastChild) ? new GapCursor($end) : Selection.findFrom($end, -1, true) ?? Selection.atEnd(doc);
+		const end = terminalSelection(view.state.doc);
 		view.dispatch(setSearchState(view.state.tr.setSelection(end), new SearchQuery({ search: "" })));
 	}
 	/** Selects the next match and returns whether there was one. */