@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/view/viewdesc.js

@@ -0,0 +1,1205 @@
+import { DOMSerializer } from "../model/to_dom.js";
+import { Fragment } from "../model/fragment.js";
+import { Mark } from "../model/mark.js";
+import { TextSelection } from "../state/selection.js";
+import { chrome, gecko, ios, safari } from "./browser.js";
+import { domIndex, isElt, isEquivalentPosition } from "./dom.js";
+import * as Arr from "effect/Array";
+import * as Order from "effect/Order";
+// src/view/viewdesc.ts
+/**
+* View descriptions, node views and mark views.
+*
+* @since 0.1.0
+*/
+const textOf = (node) => node.text;
+const NOT_DIRTY = 0;
+const CHILD_DIRTY = 1;
+const CONTENT_DIRTY = 2;
+const NODE_DIRTY = 3;
+/** @internal */
+var ViewDesc = class {
+	constructor(parent, children, dom, contentDOM) {
+		this.parent = parent;
+		this.children = children;
+		this.dom = dom;
+		this.contentDOM = contentDOM;
+		this.dirty = NOT_DIRTY;
+		dom.pmViewDesc = this;
+	}
+	matchesWidget(_widget) {
+		return false;
+	}
+	matchesMark(_mark) {
+		return false;
+	}
+	matchesNode(_node, _outerDeco, _innerDeco) {
+		return false;
+	}
+	matchesHack(_nodeName) {
+		return false;
+	}
+	parseRule(_addedNodes) {
+		return null;
+	}
+	stopEvent(_event) {
+		return false;
+	}
+	get size() {
+		let size = 0;
+		for (let i = 0; i < this.children.length; i++) size += this.children[i].size;
+		return size;
+	}
+	get border() {
+		return 0;
+	}
+	destroy() {
+		this.parent = void 0;
+		if (this.dom.pmViewDesc == this) this.dom.pmViewDesc = void 0;
+		for (let i = 0; i < this.children.length; i++) this.children[i].destroy();
+	}
+	posBeforeChild(child) {
+		for (let i = 0, pos = this.posAtStart;; i++) {
+			const cur = this.children[i];
+			if (cur == child) return pos;
+			pos += cur.size;
+		}
+	}
+	get posBefore() {
+		return this.parent.posBeforeChild(this);
+	}
+	get posAtStart() {
+		return this.parent ? this.parent.posBeforeChild(this) + this.border : 0;
+	}
+	get posAfter() {
+		return this.posBefore + this.size;
+	}
+	get posAtEnd() {
+		return this.posAtStart + this.size - 2 * this.border;
+	}
+	localPosFromDOM(dom, offset, bias) {
+		if (this.contentDOM && this.contentDOM.contains(dom.nodeType == 1 ? dom : dom.parentNode)) {
+			if (bias < 0) {
+				let domBefore, desc;
+				if (dom == this.contentDOM) domBefore = dom.childNodes[offset - 1];
+				else {
+					while (dom.parentNode != this.contentDOM) dom = dom.parentNode;
+					domBefore = dom.previousSibling;
+				}
+				while (domBefore && !((desc = domBefore.pmViewDesc) && desc.parent == this)) domBefore = domBefore.previousSibling;
+				return domBefore ? this.posBeforeChild(desc) + desc.size : this.posAtStart;
+			} else {
+				let domAfter, desc;
+				if (dom == this.contentDOM) domAfter = dom.childNodes[offset];
+				else {
+					while (dom.parentNode != this.contentDOM) dom = dom.parentNode;
+					domAfter = dom.nextSibling;
+				}
+				while (domAfter && !((desc = domAfter.pmViewDesc) && desc.parent == this)) domAfter = domAfter.nextSibling;
+				return domAfter ? this.posBeforeChild(desc) : this.posAtEnd;
+			}
+		}
+		let atEnd;
+		if (dom == this.dom && this.contentDOM) atEnd = offset > domIndex(this.contentDOM);
+		else if (this.contentDOM && this.contentDOM != this.dom && this.dom.contains(this.contentDOM)) {
+			const rel = dom.compareDocumentPosition(this.contentDOM);
+			if (rel & 16) atEnd = offset > Array.from(dom.childNodes).findIndex((n) => n.contains(this.contentDOM));
+			else atEnd = !(rel & 4);
+		} else if (this.dom.firstChild) {
+			if (offset == 0) for (let search = dom;; search = search.parentNode) {
+				if (search == this.dom) {
+					atEnd = false;
+					break;
+				}
+				if (search.previousSibling) break;
+			}
+			if (atEnd == null && offset == dom.childNodes.length) for (let search = dom;; search = search.parentNode) {
+				if (search == this.dom) {
+					atEnd = true;
+					break;
+				}
+				if (search.nextSibling) break;
+			}
+		}
+		return (atEnd == null ? bias > 0 : atEnd) ? this.posAtEnd : this.posAtStart;
+	}
+	nearestDesc(dom, onlyNodes = false) {
+		for (let first = true, cur = dom; cur; cur = cur.parentNode) {
+			const desc = this.getDesc(cur);
+			let nodeDOM;
+			if (desc && (!onlyNodes || desc.node)) {
+				if (first && (nodeDOM = desc.nodeDOM) && !(nodeDOM.nodeType == 1 ? nodeDOM.contains(dom.nodeType == 1 ? dom : dom.parentNode) : nodeDOM == dom)) first = false;
+				else return desc;
+			}
+		}
+	}
+	getDesc(dom) {
+		const desc = dom.pmViewDesc;
+		for (let cur = desc; cur; cur = cur.parent) if (cur == this) return desc;
+	}
+	posFromDOM(dom, offset, bias) {
+		for (let scan = dom; scan; scan = scan.parentNode) {
+			const desc = this.getDesc(scan);
+			if (desc) return desc.localPosFromDOM(dom, offset, bias);
+		}
+		return -1;
+	}
+	descAt(pos) {
+		for (let i = 0, offset = 0; i < this.children.length; i++) {
+			let child = this.children[i];
+			const end = offset + child.size;
+			if (offset == pos && end != offset) {
+				while (!child.border && child.children.length) for (let i = 0; i < child.children.length; i++) {
+					const inner = child.children[i];
+					if (inner.size) {
+						child = inner;
+						break;
+					}
+				}
+				return child;
+			}
+			if (pos < end) return child.descAt(pos - offset - child.border);
+			offset = end;
+		}
+	}
+	domFromPos(pos, side) {
+		if (!this.contentDOM) return {
+			node: this.dom,
+			offset: 0,
+			atom: pos + 1
+		};
+		let i = 0, offset = 0;
+		for (let curPos = 0; i < this.children.length; i++) {
+			const child = this.children[i], end = curPos + child.size;
+			if (end > pos) {
+				offset = pos - curPos;
+				break;
+			}
+			curPos = end;
+		}
+		if (offset) return this.children[i].domFromPos(offset - this.children[i].border, side);
+		while (i > 0 && skippableBefore(this.children, i)) i--;
+		if (side <= 0) {
+			let prev, enter = true;
+			for (;; i--, enter = false) {
+				prev = i ? this.children[i - 1] : null;
+				if (!prev || prev.dom.parentNode == this.contentDOM) break;
+			}
+			if (prev && side && enter && !prev.border && !prev.domAtom) return prev.domFromPos(prev.size, side);
+			return {
+				node: this.contentDOM,
+				offset: prev ? domIndex(prev.dom) + 1 : 0
+			};
+		} else {
+			let next, enter = true;
+			for (;; i++, enter = false) {
+				next = i < this.children.length ? this.children[i] : null;
+				if (!next || next.dom.parentNode == this.contentDOM) break;
+			}
+			if (next && enter && !next.border && !next.domAtom) return next.domFromPos(0, side);
+			return {
+				node: this.contentDOM,
+				offset: next ? domIndex(next.dom) : this.contentDOM.childNodes.length
+			};
+		}
+	}
+	parseRange(from, to, base = 0) {
+		if (Arr.isReadonlyArrayEmpty(this.children)) return {
+			node: this.contentDOM,
+			from,
+			to,
+			fromOffset: 0,
+			toOffset: this.contentDOM.childNodes.length
+		};
+		let fromOffset = -1, toOffset = -1;
+		for (let offset = base, i = 0;; i++) {
+			const child = this.children[i], end = offset + child.size;
+			if (fromOffset == -1 && from <= end) {
+				const childBase = offset + child.border;
+				if (from >= childBase && to <= end - child.border && child.node && child.contentDOM && this.contentDOM.contains(child.contentDOM)) return child.parseRange(from, to, childBase);
+				from = offset;
+				for (let j = i; j > 0; j--) {
+					const prev = this.children[j - 1];
+					if (prev.size && prev.dom.parentNode == this.contentDOM && !prev.emptyChildAt(1)) {
+						fromOffset = domIndex(prev.dom) + 1;
+						break;
+					}
+					from -= prev.size;
+				}
+				if (fromOffset == -1) fromOffset = 0;
+			}
+			if (fromOffset > -1 && (end > to || i == this.children.length - 1)) {
+				to = end;
+				for (let j = i + 1; j < this.children.length; j++) {
+					const next = this.children[j];
+					if (next.size && next.dom.parentNode == this.contentDOM && !next.emptyChildAt(-1)) {
+						toOffset = domIndex(next.dom);
+						break;
+					}
+					to += next.size;
+				}
+				if (toOffset == -1) toOffset = this.contentDOM.childNodes.length;
+				break;
+			}
+			offset = end;
+		}
+		return {
+			node: this.contentDOM,
+			from,
+			to,
+			fromOffset,
+			toOffset
+		};
+	}
+	emptyChildAt(side) {
+		if (this.border || !this.contentDOM || !this.children.length) return false;
+		const child = this.children[side < 0 ? 0 : this.children.length - 1];
+		return child.size == 0 || child.emptyChildAt(side);
+	}
+	domAfterPos(pos) {
+		const { node, offset } = this.domFromPos(pos, 0);
+		if (node.nodeType != 1 || offset == node.childNodes.length) throw new RangeError("No node after pos " + pos);
+		return node.childNodes[offset];
+	}
+	setSelection(anchor, head, view, force = false) {
+		const from = Math.min(anchor, head), to = Math.max(anchor, head);
+		for (let i = 0, offset = 0; i < this.children.length; i++) {
+			const child = this.children[i], end = offset + child.size;
+			if (from > offset && to < end) return child.setSelection(anchor - offset - child.border, head - offset - child.border, view, force);
+			offset = end;
+		}
+		let anchorDOM = this.domFromPos(anchor, anchor ? -1 : 1);
+		let headDOM = head == anchor ? anchorDOM : this.domFromPos(head, head ? -1 : 1);
+		const domSel = view.root.getSelection();
+		const selRange = view.domSelectionRange();
+		let brKludge = false;
+		if ((gecko || safari) && anchor == head) {
+			const { node, offset } = anchorDOM;
+			if (node.nodeType == 3) {
+				brKludge = !!(offset && node.nodeValue[offset - 1] == "\n");
+				if (brKludge && offset == node.nodeValue.length) for (let scan = node, after; scan; scan = scan.parentNode) {
+					if (after = scan.nextSibling) {
+						if (after.nodeName == "BR") anchorDOM = headDOM = {
+							node: after.parentNode,
+							offset: domIndex(after) + 1
+						};
+						break;
+					}
+					const desc = scan.pmViewDesc;
+					if (desc && desc.node && desc.node.isBlock) break;
+				}
+			} else {
+				const prev = node.childNodes[offset - 1];
+				brKludge = !!prev && (prev.nodeName == "BR" || prev.contentEditable == "false");
+			}
+		}
+		if (gecko && selRange.focusNode && selRange.focusNode != headDOM.node && selRange.focusNode.nodeType == 1) {
+			const after = selRange.focusNode.childNodes[selRange.focusOffset];
+			if (after && after.contentEditable == "false") force = true;
+		}
+		if (!(force || brKludge && safari) && isEquivalentPosition(anchorDOM.node, anchorDOM.offset, selRange.anchorNode, selRange.anchorOffset) && isEquivalentPosition(headDOM.node, headDOM.offset, selRange.focusNode, selRange.focusOffset)) return;
+		let domSelExtended = false;
+		if ((domSel.extend || anchor == head) && !(brKludge && gecko)) {
+			domSel.collapse(anchorDOM.node, anchorDOM.offset);
+			try {
+				if (anchor != head) domSel.extend(headDOM.node, headDOM.offset);
+				domSelExtended = true;
+			} catch {}
+		}
+		if (!domSelExtended) {
+			if (anchor > head) {
+				const tmp = anchorDOM;
+				anchorDOM = headDOM;
+				headDOM = tmp;
+			}
+			const range = document.createRange();
+			range.setEnd(headDOM.node, headDOM.offset);
+			range.setStart(anchorDOM.node, anchorDOM.offset);
+			domSel.removeAllRanges();
+			domSel.addRange(range);
+		}
+	}
+	ignoreMutation(mutation) {
+		return !this.contentDOM && mutation.type != "selection";
+	}
+	get contentLost() {
+		return !!this.contentDOM && this.contentDOM != this.dom && !this.dom.contains(this.contentDOM);
+	}
+	markDirty(from, to) {
+		for (let offset = 0, i = 0; i < this.children.length; i++) {
+			const child = this.children[i], end = offset + child.size;
+			if (offset == end ? from <= end && to >= offset : from < end && to > offset) {
+				const startInside = offset + child.border, endInside = end - child.border;
+				if (from >= startInside && to <= endInside) {
+					this.dirty = from == offset || to == end ? CONTENT_DIRTY : CHILD_DIRTY;
+					if (from == startInside && to == endInside && (child.contentLost || child.dom.parentNode != this.contentDOM)) child.dirty = NODE_DIRTY;
+					else child.markDirty(from - startInside, to - startInside);
+					return;
+				} else child.dirty = child.dom == child.contentDOM && child.dom.parentNode == this.contentDOM && !child.children.length ? CONTENT_DIRTY : NODE_DIRTY;
+			}
+			offset = end;
+		}
+		this.dirty = CONTENT_DIRTY;
+	}
+	markParentsDirty() {
+		let level = 1;
+		for (let node = this.parent; node; node = node.parent, level++) {
+			const dirty = level == 1 ? CONTENT_DIRTY : CHILD_DIRTY;
+			if (node.dirty < dirty) node.dirty = dirty;
+		}
+	}
+	get domAtom() {
+		return false;
+	}
+	get ignoreForCoords() {
+		return false;
+	}
+	get ignoreForSelection() {
+		return false;
+	}
+	isText(_text) {
+		return false;
+	}
+};
+var WidgetViewDesc = class extends ViewDesc {
+	constructor(parent, widget, view, pos) {
+		const cell = { desc: void 0 };
+		let dom = widget.type.toDOM;
+		if (typeof dom == "function") dom = dom(view, () => {
+			const desc = cell.desc;
+			if (!desc) return pos;
+			if (desc.parent) return desc.parent.posBeforeChild(desc);
+		});
+		if (!widget.type.spec.raw) {
+			const elt = isElt(dom) ? dom : document.createElement("span");
+			if (elt != dom) {
+				elt.appendChild(dom);
+				dom = elt;
+			}
+			if (!elt.hasAttribute("contenteditable")) elt.contentEditable = "false";
+			elt.classList.add("ProseMirror-widget");
+		}
+		super(parent, [], dom, null);
+		this.widget = widget;
+		cell.desc = this;
+	}
+	matchesWidget(widget) {
+		return this.dirty == NOT_DIRTY && widget.type.eq(this.widget.type);
+	}
+	parseRule() {
+		return { ignore: true };
+	}
+	stopEvent(event) {
+		const stop = this.widget.spec.stopEvent;
+		return stop ? stop(event) : false;
+	}
+	ignoreMutation(mutation) {
+		return mutation.type != "selection" || this.widget.spec.ignoreSelection;
+	}
+	destroy() {
+		this.widget.type.destroy(this.dom);
+		super.destroy();
+	}
+	get domAtom() {
+		return true;
+	}
+	get ignoreForSelection() {
+		return !!this.widget.type.spec.relaxedSide;
+	}
+	get side() {
+		return this.widget.type.side;
+	}
+};
+/** @internal */
+var CompositionViewDesc = class extends ViewDesc {
+	constructor(parent, dom, textDOM, text) {
+		super(parent, [], dom, null);
+		this.textDOM = textDOM;
+		this.text = text;
+	}
+	get size() {
+		return this.text.length;
+	}
+	localPosFromDOM(dom, offset) {
+		if (dom != this.textDOM) return this.posAtStart + (offset ? this.size : 0);
+		return this.posAtStart + offset;
+	}
+	domFromPos(pos) {
+		return {
+			node: this.textDOM,
+			offset: pos
+		};
+	}
+	ignoreMutation(mut) {
+		return mut.type === "characterData" && mut.target.nodeValue == mut.oldValue;
+	}
+};
+var MarkViewDesc = class MarkViewDesc extends ViewDesc {
+	constructor(parent, mark, dom, contentDOM, spec) {
+		super(parent, [], dom, contentDOM);
+		this.mark = mark;
+		this.spec = spec;
+	}
+	static create(parent, mark, inline, view) {
+		const custom = view.nodeViews[mark.type.name];
+		let spec = custom && custom(mark, view, inline);
+		if (!spec || !spec.dom) spec = DOMSerializer.renderSpecUnsafe(document, mark.type.spec.toDOM(mark, inline), null, mark.attrs);
+		return new MarkViewDesc(parent, mark, spec.dom, spec.contentDOM || spec.dom, spec);
+	}
+	parseRule() {
+		if (this.dirty & NODE_DIRTY || this.mark.type.spec.reparseInView) return null;
+		return {
+			mark: this.mark.type.name,
+			attrs: this.mark.attrs,
+			contentElement: this.contentDOM
+		};
+	}
+	matchesMark(mark) {
+		return this.dirty != NODE_DIRTY && this.mark.eq(mark);
+	}
+	markDirty(from, to) {
+		super.markDirty(from, to);
+		if (this.dirty != NOT_DIRTY) {
+			let parent = this.parent;
+			while (!parent.node) parent = parent.parent;
+			if (parent.dirty < this.dirty) parent.dirty = this.dirty;
+			this.dirty = NOT_DIRTY;
+		}
+	}
+	slice(from, to, view) {
+		const copy = MarkViewDesc.create(this.parent, this.mark, true, view);
+		let nodes = this.children;
+		const size = this.size;
+		if (to < size) nodes = replaceNodes(nodes, to, size, view);
+		if (from > 0) nodes = replaceNodes(nodes, 0, from, view);
+		for (let i = 0; i < nodes.length; i++) nodes[i].parent = copy;
+		copy.children = nodes;
+		return copy;
+	}
+	ignoreMutation(mutation) {
+		return this.spec.ignoreMutation ? this.spec.ignoreMutation(mutation) : super.ignoreMutation(mutation);
+	}
+	destroy() {
+		if (this.spec.destroy) this.spec.destroy();
+		super.destroy();
+	}
+};
+/** @internal */
+var NodeViewDesc = class NodeViewDesc extends ViewDesc {
+	constructor(parent, node, outerDeco, innerDeco, dom, contentDOM, nodeDOM, _view, _pos) {
+		super(parent, [], dom, contentDOM);
+		this.node = node;
+		this.outerDeco = outerDeco;
+		this.innerDeco = innerDeco;
+		this.nodeDOM = nodeDOM;
+	}
+	static create(parent, node, outerDeco, innerDeco, view, pos) {
+		const custom = view.nodeViews[node.type.name];
+		let descObj;
+		const spec = custom && custom(node, view, () => {
+			if (!descObj) return pos;
+			if (descObj.parent) return descObj.parent.posBeforeChild(descObj);
+		}, outerDeco, innerDeco);
+		let dom = spec && spec.dom, contentDOM = spec && spec.contentDOM;
+		if (node.isText) {
+			if (!dom) dom = document.createTextNode(textOf(node));
+			else if (dom.nodeType != 3) throw new RangeError("Text must be rendered as a DOM text node");
+		} else if (!dom) {
+			const spec = DOMSerializer.renderSpecUnsafe(document, node.type.spec.toDOM(node), null, node.attrs);
+			({dom, contentDOM} = spec);
+		}
+		if (!contentDOM && !node.isText && dom.nodeName != "BR") {
+			if (!dom.hasAttribute("contenteditable")) dom.contentEditable = "false";
+			if (node.type.spec.draggable) dom.draggable = true;
+		}
+		const nodeDOM = dom;
+		dom = applyOuterDeco(dom, outerDeco, node);
+		if (spec) return descObj = new CustomNodeViewDesc(parent, node, outerDeco, innerDeco, dom, contentDOM || null, nodeDOM, spec, view, pos + 1);
+		else if (node.isText) return new TextViewDesc(parent, node, outerDeco, innerDeco, dom, nodeDOM, view);
+		else return new NodeViewDesc(parent, node, outerDeco, innerDeco, dom, contentDOM || null, nodeDOM, view, pos + 1);
+	}
+	parseRule(addedNodes) {
+		if (this.node.type.spec.reparseInView) return null;
+		const rule = {
+			node: this.node.type.name,
+			attrs: this.node.attrs
+		};
+		if (this.node.type.whitespace == "pre") rule.preserveWhitespace = "full";
+		if (!this.contentDOM) rule.getContent = () => this.node.content;
+		else if (!this.contentLost) rule.contentElement = this.contentDOM;
+		else {
+			for (let i = this.children.length - 1; i >= 0; i--) {
+				const child = this.children[i];
+				if (this.dom.contains(child.dom.parentNode)) {
+					rule.contentElement = child.dom.parentNode;
+					break;
+				}
+			}
+			if (!rule.contentElement) {
+				const found = addedNodes?.find((n) => isElt(n) && (!n.parentNode || addedNodes.indexOf(n.parentNode) < 0) && this.dom.contains(n));
+				if (found) rule.contentElement = found;
+				else rule.getContent = () => Fragment.empty;
+			}
+		}
+		return rule;
+	}
+	matchesNode(node, outerDeco, innerDeco) {
+		return this.dirty == NOT_DIRTY && node.eq(this.node) && sameOuterDeco(outerDeco, this.outerDeco) && innerDeco.eq(this.innerDeco);
+	}
+	get size() {
+		return this.node.nodeSize;
+	}
+	get border() {
+		return this.node.isLeaf ? 0 : 1;
+	}
+	updateChildren(view, pos) {
+		const inline = this.node.inlineContent;
+		let off = pos;
+		const composition = view.composing ? this.localCompositionInfo(view, pos) : null;
+		const localComposition = composition && composition.pos > -1 ? composition : null;
+		const compositionInChild = composition && composition.pos < 0;
+		const updater = new ViewTreeUpdater(this, localComposition && localComposition.node, view);
+		const addBuffers = this.node.inlineContent;
+		let atBufferPos = addBuffers && this.node.isBlock;
+		iterDeco(this.node, this.innerDeco, (widget, i, insideNode) => {
+			if (widget.spec.marks) updater.syncToMarks(widget.spec.marks, inline, view, i);
+			else if (widget.type.side >= 0 && !insideNode) updater.syncToMarks(i == this.node.childCount ? Mark.none : this.node.content.content[i].marks, inline, view, i);
+			updater.placeWidget(widget, view, off);
+		}, (child, outerDeco, innerDeco, i) => {
+			updater.syncToMarks(child.marks, inline, view, i);
+			if (atBufferPos && child.isAtom && !child.isText) updater.addHackNode("IMG", updater.top);
+			let compIndex;
+			if (updater.findNodeMatch(child, outerDeco, innerDeco, i)) {} else if (compositionInChild && view.state.selection.from > off && view.state.selection.to < off + child.nodeSize && (compIndex = updater.findIndexWithChild(composition.node)) > -1 && updater.updateNodeAt(child, outerDeco, innerDeco, compIndex, view)) {} else if (updater.updateNextNode(child, outerDeco, innerDeco, view, i, off)) {} else updater.addNode(child, outerDeco, innerDeco, view, off);
+			off += child.nodeSize;
+			if (addBuffers) atBufferPos = child.isAtom && !child.isText;
+		});
+		updater.syncToMarks([], inline, view, 0);
+		if (this.node.isTextblock) updater.addTextblockHacks();
+		updater.destroyRest();
+		if (updater.changed || this.dirty == CONTENT_DIRTY) {
+			if (localComposition) this.protectLocalComposition(view, localComposition);
+			renderDescs(this.contentDOM, this.children, view);
+			if (ios) iosHacks(this.dom);
+		}
+	}
+	localCompositionInfo(view, pos) {
+		const { from, to } = view.state.selection;
+		if (!(view.state.selection instanceof TextSelection) || from < pos || to > pos + this.node.content.size) return null;
+		const textNode = view.input.compositionNode;
+		if (!textNode || !this.dom.contains(textNode.parentNode)) return null;
+		if (this.node.inlineContent) {
+			const text = textNode.nodeValue;
+			const textPos = findTextInFragment(this.node.content, text, from - pos, to - pos);
+			return textPos < 0 ? null : {
+				node: textNode,
+				pos: textPos,
+				text
+			};
+		} else return {
+			node: textNode,
+			pos: -1,
+			text: ""
+		};
+	}
+	protectLocalComposition(view, { node, pos, text }) {
+		if (this.getDesc(node)) return;
+		let topNode = node;
+		for (;; topNode = topNode.parentNode) {
+			if (topNode.parentNode == this.contentDOM) break;
+			while (topNode.previousSibling) topNode.parentNode.removeChild(topNode.previousSibling);
+			while (topNode.nextSibling) topNode.parentNode.removeChild(topNode.nextSibling);
+			if (topNode.pmViewDesc) topNode.pmViewDesc = void 0;
+		}
+		const desc = new CompositionViewDesc(this, topNode, node, text);
+		view.input.compositionNodes.push(desc);
+		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;
+		this.updateInner(node, outerDeco, innerDeco, view);
+		return true;
+	}
+	updateInner(node, outerDeco, innerDeco, view) {
+		this.updateOuterDeco(outerDeco);
+		this.node = node;
+		this.innerDeco = innerDeco;
+		if (this.contentDOM) this.updateChildren(view, this.posAtStart);
+		this.dirty = NOT_DIRTY;
+	}
+	updateOuterDeco(outerDeco) {
+		if (sameOuterDeco(outerDeco, this.outerDeco)) return;
+		const needsWrap = this.nodeDOM.nodeType != 1;
+		const oldDOM = this.dom;
+		this.dom = patchOuterDeco(this.dom, this.nodeDOM, computeOuterDeco(this.outerDeco, this.node, needsWrap), computeOuterDeco(outerDeco, this.node, needsWrap));
+		if (this.dom != oldDOM) {
+			oldDOM.pmViewDesc = void 0;
+			this.dom.pmViewDesc = this;
+		}
+		this.outerDeco = outerDeco;
+	}
+	selectNode() {
+		if (this.nodeDOM.nodeType == 1) {
+			this.nodeDOM.classList.add("ProseMirror-selectednode");
+			if (this.contentDOM || !this.node.type.spec.draggable) this.nodeDOM.draggable = true;
+		}
+	}
+	deselectNode() {
+		if (this.nodeDOM.nodeType == 1) {
+			this.nodeDOM.classList.remove("ProseMirror-selectednode");
+			if (this.contentDOM || !this.node.type.spec.draggable) this.nodeDOM.removeAttribute("draggable");
+		}
+	}
+	get domAtom() {
+		return this.node.isAtom;
+	}
+};
+/**
+* Create a view desc for the top-level document node, to be exported
+* and used by the view class.
+*
+* @internal
+*/
+function docViewDesc(doc, outerDeco, innerDeco, dom, view) {
+	applyOuterDeco(dom, outerDeco, doc);
+	const docView = new NodeViewDesc(void 0, doc, outerDeco, innerDeco, dom, dom, dom, view, 0);
+	if (docView.contentDOM) docView.updateChildren(view, 0);
+	return docView;
+}
+var TextViewDesc = class TextViewDesc extends NodeViewDesc {
+	constructor(parent, node, outerDeco, innerDeco, dom, nodeDOM, view) {
+		super(parent, node, outerDeco, innerDeco, dom, null, nodeDOM, view, 0);
+	}
+	parseRule() {
+		let skip = this.nodeDOM.parentNode;
+		while (skip && skip != this.dom && !skip.pmIsDeco) skip = skip.parentNode;
+		return { skip: skip || true };
+	}
+	update(node, outerDeco, _innerDeco, view) {
+		if (this.dirty == NODE_DIRTY || this.dirty != NOT_DIRTY && !this.inParent() || !node.sameMarkup(this.node)) return false;
+		this.updateOuterDeco(outerDeco);
+		if ((this.dirty != NOT_DIRTY || textOf(node) != textOf(this.node)) && textOf(node) != this.nodeDOM.nodeValue) {
+			this.nodeDOM.nodeValue = textOf(node);
+			if (view.trackWrites == this.nodeDOM) view.trackWrites = null;
+		}
+		this.node = node;
+		this.dirty = NOT_DIRTY;
+		return true;
+	}
+	inParent() {
+		const parentDOM = this.parent.contentDOM;
+		for (let n = this.nodeDOM; n; n = n.parentNode) if (n == parentDOM) return true;
+		return false;
+	}
+	domFromPos(pos) {
+		return {
+			node: this.nodeDOM,
+			offset: pos
+		};
+	}
+	localPosFromDOM(dom, offset, bias) {
+		if (dom == this.nodeDOM) return this.posAtStart + Math.min(offset, textOf(this.node).length);
+		return super.localPosFromDOM(dom, offset, bias);
+	}
+	ignoreMutation(mutation) {
+		return mutation.type != "characterData" && mutation.type != "selection";
+	}
+	slice(from, to, view) {
+		const node = this.node.cut(from, to), dom = document.createTextNode(textOf(node));
+		return new TextViewDesc(this.parent, node, this.outerDeco, this.innerDeco, dom, dom, view);
+	}
+	markDirty(from, to) {
+		super.markDirty(from, to);
+		if (this.dom != this.nodeDOM && (from == 0 || to == this.nodeDOM.nodeValue.length)) this.dirty = NODE_DIRTY;
+	}
+	get domAtom() {
+		return false;
+	}
+	isText(text) {
+		return textOf(this.node) == text;
+	}
+};
+var BufferHackViewDesc = class extends ViewDesc {
+	parseRule() {
+		return { ignore: true };
+	}
+	matchesHack(nodeName) {
+		return this.dirty == NOT_DIRTY && this.dom.nodeName == nodeName;
+	}
+	get domAtom() {
+		return true;
+	}
+	get ignoreForCoords() {
+		return this.dom.nodeName == "IMG";
+	}
+};
+function skippableBefore(children, index) {
+	const desc = children[index - 1];
+	if (!desc || desc.size) return false;
+	return desc instanceof BufferHackViewDesc || desc instanceof WidgetViewDesc && desc.side >= 0;
+}
+var CustomNodeViewDesc = class extends NodeViewDesc {
+	constructor(parent, node, outerDeco, innerDeco, dom, contentDOM, nodeDOM, spec, view, pos) {
+		super(parent, node, outerDeco, innerDeco, dom, contentDOM, nodeDOM, view, pos);
+		this.spec = spec;
+	}
+	update(node, outerDeco, innerDeco, view) {
+		if (this.dirty == NODE_DIRTY) return false;
+		if (this.spec.update && (this.node.type == node.type || this.spec.multiType)) {
+			const result = this.spec.update(node, outerDeco, innerDeco);
+			if (result) this.updateInner(node, outerDeco, innerDeco, view);
+			return result;
+		} else if (!this.contentDOM && !node.isLeaf) return false;
+		else return super.update(node, outerDeco, innerDeco, view);
+	}
+	selectNode() {
+		if (this.spec.selectNode) this.spec.selectNode();
+		else super.selectNode();
+	}
+	deselectNode() {
+		if (this.spec.deselectNode) this.spec.deselectNode();
+		else super.deselectNode();
+	}
+	setSelection(anchor, head, view, force) {
+		if (this.spec.setSelection) this.spec.setSelection(anchor, head, view.root);
+		else super.setSelection(anchor, head, view, force);
+	}
+	destroy() {
+		if (this.spec.destroy) this.spec.destroy();
+		super.destroy();
+	}
+	stopEvent(event) {
+		return this.spec.stopEvent ? this.spec.stopEvent(event) : false;
+	}
+	ignoreMutation(mutation) {
+		return this.spec.ignoreMutation ? this.spec.ignoreMutation(mutation) : super.ignoreMutation(mutation);
+	}
+};
+function renderDescs(parentDOM, descs, view) {
+	let dom = parentDOM.firstChild, written = false;
+	for (let i = 0; i < descs.length; i++) {
+		const desc = descs[i], childDOM = desc.dom;
+		if (childDOM.parentNode == parentDOM) {
+			while (childDOM != dom) {
+				dom = rm(dom);
+				written = true;
+			}
+			dom = dom.nextSibling;
+		} else {
+			written = true;
+			parentDOM.insertBefore(childDOM, dom);
+		}
+		if (desc instanceof MarkViewDesc) {
+			const pos = dom ? dom.previousSibling : parentDOM.lastChild;
+			renderDescs(desc.contentDOM, desc.children, view);
+			dom = pos ? pos.nextSibling : parentDOM.firstChild;
+		}
+	}
+	while (dom) {
+		dom = rm(dom);
+		written = true;
+	}
+	if (written && view.trackWrites == parentDOM) view.trackWrites = null;
+}
+const OuterDecoLevel = function(nodeName) {
+	if (nodeName) this.nodeName = nodeName;
+};
+OuterDecoLevel.prototype = Object.create(null);
+const noDeco = [new OuterDecoLevel()];
+function computeOuterDeco(outerDeco, node, needsWrap) {
+	if (Arr.isReadonlyArrayEmpty(outerDeco)) return noDeco;
+	let top = needsWrap ? noDeco[0] : new OuterDecoLevel();
+	const result = [top];
+	for (let i = 0; i < outerDeco.length; i++) {
+		const attrs = outerDeco[i].type.attrs;
+		if (!attrs) continue;
+		if (attrs.nodeName) result.push(top = new OuterDecoLevel(attrs.nodeName));
+		for (const name in attrs) {
+			const val = attrs[name];
+			if (val == null) continue;
+			if (needsWrap && result.length == 1) result.push(top = new OuterDecoLevel(node.isInline ? "span" : "div"));
+			if (name == "class") top.class = (top.class ? top.class + " " : "") + val;
+			else if (name == "style") top.style = (top.style ? top.style + ";" : "") + val;
+			else if (name != "nodeName") top[name] = val;
+		}
+	}
+	return result;
+}
+function patchOuterDeco(outerDOM, nodeDOM, prevComputed, curComputed) {
+	if (prevComputed == noDeco && curComputed == noDeco) return nodeDOM;
+	let curDOM = nodeDOM;
+	for (let i = 0; i < curComputed.length; i++) {
+		const deco = curComputed[i];
+		let prev = prevComputed[i];
+		if (i) {
+			let parent;
+			if (prev && prev.nodeName == deco.nodeName && curDOM != outerDOM && (parent = curDOM.parentNode) && parent.nodeName.toLowerCase() == deco.nodeName) curDOM = parent;
+			else {
+				parent = document.createElement(deco.nodeName);
+				parent.pmIsDeco = true;
+				parent.appendChild(curDOM);
+				prev = noDeco[0];
+				curDOM = parent;
+			}
+		}
+		patchAttributes(curDOM, prev || noDeco[0], deco);
+	}
+	return curDOM;
+}
+function patchAttributes(dom, prev, cur) {
+	for (const name in prev) if (name != "class" && name != "style" && name != "nodeName" && !(name in cur)) dom.removeAttribute(name);
+	for (const name in cur) if (name != "class" && name != "style" && name != "nodeName" && cur[name] != prev[name]) dom.setAttribute(name, cur[name]);
+	if (prev.class != cur.class) {
+		const prevList = prev.class ? prev.class.split(" ").filter(Boolean) : [];
+		const curList = cur.class ? cur.class.split(" ").filter(Boolean) : [];
+		for (let i = 0; i < prevList.length; i++) if (curList.indexOf(prevList[i]) == -1) dom.classList.remove(prevList[i]);
+		for (let i = 0; i < curList.length; i++) if (prevList.indexOf(curList[i]) == -1) dom.classList.add(curList[i]);
+		if (dom.classList.item(0) === null) dom.removeAttribute("class");
+	}
+	if (prev.style != cur.style) {
+		if (prev.style) {
+			const prop = /\s*([\w\-\xa1-￿]+)\s*:(?:"(?:\\.|[^"])*"|'(?:\\.|[^'])*'|\(.*?\)|[^;])*/g;
+			let m;
+			while (m = prop.exec(prev.style)) dom.style.removeProperty(m[1]);
+		}
+		if (cur.style) dom.style.cssText += cur.style;
+	}
+}
+function applyOuterDeco(dom, deco, node) {
+	return patchOuterDeco(dom, dom, noDeco, computeOuterDeco(deco, node, dom.nodeType != 1));
+}
+function sameOuterDeco(a, b) {
+	if (a.length != b.length) return false;
+	for (let i = 0; i < a.length; i++) if (!a[i].type.eq(b[i].type)) return false;
+	return true;
+}
+function rm(dom) {
+	const next = dom.nextSibling;
+	dom.parentNode.removeChild(dom);
+	return next;
+}
+var ViewTreeUpdater = class {
+	constructor(top, lock, view) {
+		this.lock = lock;
+		this.view = view;
+		this.index = 0;
+		this.stack = [];
+		this.changed = false;
+		this.top = top;
+		this.preMatch = preMatch(top.node.content, top);
+	}
+	destroyBetween(start, end) {
+		if (start == end) return;
+		for (let i = start; i < end; i++) this.top.children[i].destroy();
+		this.top.children.splice(start, end - start);
+		this.changed = true;
+	}
+	destroyRest() {
+		this.destroyBetween(this.index, this.top.children.length);
+	}
+	syncToMarks(marks, inline, view, parentIndex) {
+		let keep = 0, depth = this.stack.length >> 1;
+		const maxKeep = Math.min(depth, marks.length);
+		while (keep < maxKeep && (keep == depth - 1 ? this.top : this.stack[keep + 1 << 1]).matchesMark(marks[keep]) && marks[keep].type.spec.spanning !== false) keep++;
+		while (keep < depth) {
+			this.destroyRest();
+			this.top.dirty = NOT_DIRTY;
+			this.index = this.stack.pop();
+			this.top = this.stack.pop();
+			depth--;
+		}
+		while (depth < marks.length) {
+			this.stack.push(this.top, this.index + 1);
+			let found = -1, scanTo = this.top.children.length;
+			if (parentIndex < this.preMatch.index) scanTo = Math.min(this.index + 3, scanTo);
+			for (let i = this.index; i < scanTo; i++) {
+				const next = this.top.children[i];
+				if (next.matchesMark(marks[depth]) && !this.isLocked(next.dom)) {
+					found = i;
+					break;
+				}
+			}
+			const cur = this.top.children.at(this.index), want = marks.at(depth);
+			if (found < 0 && want) {
+				if (cur instanceof MarkViewDesc && cur.dirty != NODE_DIRTY && cur.mark.type == want.type && cur.spec.update && !this.isLocked(cur.dom) && cur.spec.update(want)) {
+					cur.mark = want;
+					found = this.index;
+					this.changed = true;
+				}
+			}
+			if (found > -1) {
+				if (found > this.index) {
+					this.changed = true;
+					this.destroyBetween(this.index, found);
+				}
+				this.top = this.top.children[this.index];
+			} else {
+				const markDesc = MarkViewDesc.create(this.top, marks[depth], inline, view);
+				this.top.children.splice(this.index, 0, markDesc);
+				this.top = markDesc;
+				this.changed = true;
+			}
+			this.index = 0;
+			depth++;
+		}
+	}
+	findNodeMatch(node, outerDeco, innerDeco, index) {
+		let found = -1, targetDesc;
+		if (index >= this.preMatch.index && (targetDesc = this.preMatch.matches[index - this.preMatch.index]).parent == this.top && targetDesc.matchesNode(node, outerDeco, innerDeco)) found = this.top.children.indexOf(targetDesc, this.index);
+		else for (let i = this.index, e = Math.min(this.top.children.length, i + 5); i < e; i++) {
+			const child = this.top.children[i];
+			if (child.matchesNode(node, outerDeco, innerDeco) && !this.preMatch.matched.has(child)) {
+				found = i;
+				break;
+			}
+		}
+		if (found < 0) return false;
+		this.destroyBetween(this.index, found);
+		this.index++;
+		return true;
+	}
+	updateNodeAt(node, outerDeco, innerDeco, index, view) {
+		const child = this.top.children[index];
+		if (child.dirty == NODE_DIRTY && child.dom == child.contentDOM) child.dirty = CONTENT_DIRTY;
+		if (!child.update(node, outerDeco, innerDeco, view)) return false;
+		this.destroyBetween(this.index, index);
+		this.index++;
+		return true;
+	}
+	findIndexWithChild(domNode) {
+		for (;;) {
+			const parent = domNode.parentNode;
+			if (!parent) return -1;
+			if (parent == this.top.contentDOM) {
+				const desc = domNode.pmViewDesc;
+				if (desc) {
+					for (let i = this.index; i < this.top.children.length; i++) if (this.top.children[i] == desc) return i;
+				}
+				return -1;
+			}
+			domNode = parent;
+		}
+	}
+	updateNextNode(node, outerDeco, innerDeco, view, index, pos) {
+		for (let i = this.index; i < this.top.children.length; i++) {
+			const next = this.top.children[i];
+			if (next instanceof NodeViewDesc) {
+				const preMatch = this.preMatch.matched.get(next);
+				if (preMatch != null && preMatch != index) return false;
+				const nextDOM = next.dom;
+				let updated;
+				const locked = this.isLocked(nextDOM) && !(node.isText && next.node && next.node.isText && next.nodeDOM.nodeValue == textOf(node) && next.dirty != NODE_DIRTY && sameOuterDeco(outerDeco, next.outerDeco));
+				if (!locked && next.update(node, outerDeco, innerDeco, view)) {
+					this.destroyBetween(this.index, i);
+					if (next.dom != nextDOM) this.changed = true;
+					this.index++;
+					return true;
+				} else if (!locked && (updated = this.recreateWrapper(next, node, outerDeco, innerDeco, view, pos))) {
+					this.destroyBetween(this.index, i);
+					this.top.children[this.index] = updated;
+					if (updated.contentDOM) {
+						updated.dirty = CONTENT_DIRTY;
+						updated.updateChildren(view, pos + 1);
+						updated.dirty = NOT_DIRTY;
+					}
+					this.changed = true;
+					this.index++;
+					return true;
+				}
+				break;
+			}
+		}
+		return false;
+	}
+	recreateWrapper(next, node, outerDeco, innerDeco, view, pos) {
+		if (next.dirty || node.isAtom || !next.children.length || !next.node.content.eq(node.content) || !sameOuterDeco(outerDeco, next.outerDeco) || !innerDeco.eq(next.innerDeco)) return null;
+		const wrapper = NodeViewDesc.create(this.top, node, outerDeco, innerDeco, view, pos);
+		if (wrapper.contentDOM) {
+			wrapper.children = next.children;
+			next.children = [];
+			for (const ch of wrapper.children) ch.parent = wrapper;
+		}
+		next.destroy();
+		return wrapper;
+	}
+	addNode(node, outerDeco, innerDeco, view, pos) {
+		const desc = NodeViewDesc.create(this.top, node, outerDeco, innerDeco, view, pos);
+		if (desc.contentDOM) desc.updateChildren(view, pos + 1);
+		this.top.children.splice(this.index++, 0, desc);
+		this.changed = true;
+	}
+	placeWidget(widget, view, pos) {
+		const next = this.index < this.top.children.length ? this.top.children[this.index] : null;
+		if (next && next.matchesWidget(widget) && (widget == next.widget || !next.widget.type.toDOM.parentNode)) this.index++;
+		else {
+			const desc = new WidgetViewDesc(this.top, widget, view, pos);
+			this.top.children.splice(this.index++, 0, desc);
+			this.changed = true;
+		}
+	}
+	addTextblockHacks() {
+		let lastChild = this.top.children[this.index - 1], parent = this.top;
+		while (lastChild instanceof MarkViewDesc) {
+			parent = lastChild;
+			lastChild = parent.children[parent.children.length - 1];
+		}
+		if (!lastChild || !(lastChild instanceof TextViewDesc) || textOf(lastChild.node).endsWith("\n") || this.view.requiresGeckoHackNode && /\s$/.test(textOf(lastChild.node))) {
+			if ((safari || chrome) && lastChild && lastChild.dom.contentEditable == "false") this.addHackNode("IMG", parent);
+			this.addHackNode("BR", this.top);
+		}
+	}
+	addHackNode(nodeName, parent) {
+		if (parent == this.top && this.index < parent.children.length && parent.children[this.index].matchesHack(nodeName)) this.index++;
+		else {
+			const dom = document.createElement(nodeName);
+			if (nodeName == "IMG") {
+				dom.className = "ProseMirror-separator";
+				dom.alt = "";
+			}
+			if (nodeName == "BR") dom.className = "ProseMirror-trailingBreak";
+			const hack = new BufferHackViewDesc(this.top, [], dom, null);
+			if (parent != this.top) parent.children.push(hack);
+			else parent.children.splice(this.index++, 0, hack);
+			this.changed = true;
+		}
+	}
+	isLocked(node) {
+		return this.lock && (node == this.lock || node.nodeType == 1 && node.contains(this.lock.parentNode));
+	}
+};
+function preMatch(frag, parentDesc) {
+	let curDesc = parentDesc, descI = curDesc.children.length;
+	let fI = frag.childCount;
+	const matched = /* @__PURE__ */ new WeakMap(), matches = [];
+	outer: while (fI > 0) {
+		let desc;
+		for (;;) if (descI) {
+			const next = curDesc.children[descI - 1];
+			if (next instanceof MarkViewDesc) {
+				curDesc = next;
+				descI = next.children.length;
+			} else {
+				desc = next;
+				descI--;
+				break;
+			}
+		} else if (curDesc == parentDesc) break outer;
+		else {
+			descI = curDesc.parent.children.indexOf(curDesc);
+			curDesc = curDesc.parent;
+		}
+		const node = desc.node;
+		if (!node) continue;
+		if (node != frag.content[fI - 1]) break;
+		--fI;
+		matched.set(desc, fI);
+		matches.push(desc);
+	}
+	return {
+		index: fI,
+		matched,
+		matches: matches.reverse()
+	};
+}
+const bySide = (a, b) => Order.Number(a.type.side, b.type.side);
+function iterDeco(parent, deco, onWidget, onNode) {
+	const locals = deco.locals(parent);
+	let offset = 0;
+	if (Arr.isReadonlyArrayEmpty(locals)) {
+		for (let i = 0; i < parent.childCount; i++) {
+			const child = parent.content.content[i];
+			onNode(child, locals, deco.forChild(offset, child), i);
+			offset += child.nodeSize;
+		}
+		return;
+	}
+	let decoIndex = 0, restNode = null;
+	const active = [];
+	for (let parentIndex = 0;;) {
+		let widget, widgets;
+		while (decoIndex < locals.length && locals[decoIndex].to == offset) {
+			const next = locals[decoIndex++];
+			if (next.widget) {
+				if (!widget) widget = next;
+				else (widgets || (widgets = [widget])).push(next);
+			}
+		}
+		if (widget) {
+			if (widgets) {
+				const sorted = Arr.sort(widgets, bySide);
+				for (let i = 0; i < sorted.length; i++) onWidget(sorted[i], parentIndex, !!restNode);
+			} else onWidget(widget, parentIndex, !!restNode);
+		}
+		let child, index;
+		if (restNode) {
+			index = -1;
+			child = restNode;
+			restNode = null;
+		} else if (parentIndex < parent.childCount) {
+			index = parentIndex;
+			child = parent.content.content[parentIndex++];
+		} else break;
+		for (let i = 0; i < active.length; i++) if (active[i].to <= offset) active.splice(i--, 1);
+		while (decoIndex < locals.length && locals[decoIndex].from <= offset && locals[decoIndex].to > offset) active.push(locals[decoIndex++]);
+		let end = offset + child.nodeSize;
+		if (child.isText) {
+			let cutAt = end;
+			if (decoIndex < locals.length && locals[decoIndex].from < cutAt) cutAt = locals[decoIndex].from;
+			for (let i = 0; i < active.length; i++) if (active[i].to < cutAt) cutAt = active[i].to;
+			if (cutAt < end) {
+				restNode = child.cut(cutAt - offset);
+				child = child.cut(0, cutAt - offset);
+				end = cutAt;
+				index = -1;
+			}
+		} else while (decoIndex < locals.length && locals[decoIndex].to < end) decoIndex++;
+		const outerDeco = child.isInline && !child.isLeaf ? active.filter((d) => !d.inline) : active.slice();
+		onNode(child, outerDeco, deco.forChild(offset, child), index);
+		offset = end;
+	}
+}
+function iosHacks(dom) {
+	if (dom.nodeName == "UL" || dom.nodeName == "OL") {
+		const oldCSS = dom.style.cssText;
+		dom.style.cssText = oldCSS + "; list-style: square !important";
+		window.getComputedStyle(dom).listStyle;
+		dom.style.cssText = oldCSS;
+	}
+}
+function findTextInFragment(frag, text, from, to) {
+	for (let i = 0, pos = 0; i < frag.childCount && pos <= to;) {
+		const child = frag.content[i++], childStart = pos;
+		pos += child.nodeSize;
+		if (!child.isText) continue;
+		let str = textOf(child);
+		while (i < frag.childCount) {
+			const next = frag.content[i++];
+			pos += next.nodeSize;
+			if (!next.isText) break;
+			str += textOf(next);
+		}
+		if (pos >= from) {
+			if (pos >= to && str.slice(to - text.length - childStart, to - childStart) == text) return to - text.length;
+			const found = childStart < to ? str.lastIndexOf(text, to - childStart - 1) : -1;
+			if (found >= 0 && found + text.length + childStart >= from) return childStart + found;
+			if (from == to && str.length >= to + text.length - childStart && str.slice(to - childStart, to - childStart + text.length) == text) return to;
+		}
+	}
+	return -1;
+}
+function replaceNodes(nodes, from, to, view, replacement) {
+	const result = [];
+	for (let i = 0, off = 0; i < nodes.length; i++) {
+		const child = nodes[i], start = off, end = off += child.size;
+		if (start >= to || end <= from) result.push(child);
+		else {
+			if (start < from) result.push(child.slice(0, from - start, view));
+			if (replacement) {
+				result.push(replacement);
+				replacement = void 0;
+			}
+			if (end > to) result.push(child.slice(to - start, child.size, view));
+		}
+	}
+	return result;
+}
+export { CompositionViewDesc, NodeViewDesc, ViewDesc, docViewDesc };