@stesura/react-prosemirror 3.2.11-stesura.1

package/dist/esm/viewdesc.js

@@ -0,0 +1,844 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */ /* eslint-disable @typescript-eslint/no-non-null-assertion */ import { Fragment } from "prosemirror-model";
+import { browser } from "./browser.js";
+import { domIndex, isEquivalentPosition } from "./dom.js";
+// View descriptions are data structures that describe the DOM that is
+// used to represent the editor's content. They are used for:
+//
+// - Incremental redrawing when the document changes
+//
+// - Figuring out what part of the document a given DOM position
+//   corresponds to
+//
+// - Wiring in custom implementations of the editing interface for a
+//   given node
+//
+// They form a doubly-linked mutable tree, starting at `view.docView`.
+export function sortViewDescs(a, b) {
+    if (a instanceof TrailingHackViewDesc) return 1;
+    if (b instanceof TrailingHackViewDesc) return -1;
+    const posDiff = a.getPos() - b.getPos();
+    if (posDiff !== 0) return posDiff;
+    // When two descs share the same PM position (e.g. a zero-width widget
+    // and a text node that starts at the same position), fall back to DOM
+    // order so that the viewdesc children match the actual DOM layout.
+    // Without this, position computations like `posBeforeChild` can return
+    // the wrong PM position for the widget's container.
+    const cmp = a.dom.compareDocumentPosition(b.dom);
+    if (cmp & 4 /* DOCUMENT_POSITION_FOLLOWING */ ) return -1;
+    if (cmp & 2 /* DOCUMENT_POSITION_PRECEDING */ ) return 1;
+    return 0;
+}
+// Adds `desc` to `siblings` if missing and moves it into sorted order.
+// Every child used to sort the whole sibling list from its own layout
+// effect, which made mounting n siblings O(n²). Only `desc` can be out of
+// place here; the parent's own `children.sort` remains the full pass for
+// siblings that move without re-rendering (reorderSiblings).
+export const placeViewDesc = (siblings, desc)=>{
+    let index = siblings.lastIndexOf(desc);
+    if (index === -1) index = siblings.push(desc) - 1;
+    const prev = siblings[index - 1];
+    const next = siblings[index + 1];
+    if ((!prev || sortViewDescs(prev, desc) <= 0) && (!next || sortViewDescs(desc, next) <= 0)) {
+        return;
+    }
+    siblings.splice(index, 1);
+    let low = 0;
+    let high = siblings.length;
+    while(low < high){
+        const mid = low + high >> 1;
+        const sibling = siblings[mid];
+        if (sibling && sortViewDescs(sibling, desc) <= 0) low = mid + 1;
+        else high = mid;
+    }
+    siblings.splice(low, 0, desc);
+};
+const NOT_DIRTY = 0, CHILD_DIRTY = 1, CONTENT_DIRTY = 2, NODE_DIRTY = 3;
+// Superclass for the various kinds of descriptions. Defines their
+// basic structure and shared methods.
+export class ViewDesc {
+    parent;
+    children;
+    getPos;
+    dom;
+    contentDOM;
+    dirty;
+    node;
+    constructor(parent, children, getPos, dom, // This is the node that holds the child views. It may be null for
+    // descs that don't have children.
+    contentDOM){
+        this.parent = parent;
+        this.children = children;
+        this.getPos = getPos;
+        this.dom = dom;
+        this.contentDOM = contentDOM;
+        this.dirty = NOT_DIRTY;
+        // An expando property on the DOM node provides a link back to its
+        // description.
+        dom.pmViewDesc = this;
+    }
+    // Used to check whether a given description corresponds to a
+    // widget/mark/node.
+    matchesWidget(_widget) {
+        return false;
+    }
+    matchesMark(_mark) {
+        return false;
+    }
+    matchesNode(_node, _outerDeco, _innerDeco) {
+        return false;
+    }
+    // @ts-expect-error ...
+    matchesHack(nodeName) {
+        return false;
+    }
+    // When parsing in-editor content (in domchange.js), we allow
+    // descriptions to determine the parse rules that should be used to
+    // parse them.
+    parseRule() {
+        return null;
+    }
+    // Used by the editor's event handler to ignore events that come
+    // from certain descs.
+    // @ts-expect-error ...
+    stopEvent(event) {
+        return false;
+    }
+    // The size of the content represented by this desc.
+    get size() {
+        let size = 0;
+        for(let i = 0; i < this.children.length; i++)// @ts-expect-error ...
+        size += this.children[i].size;
+        return size;
+    }
+    // For block nodes, this represents the space taken up by their
+    // start/end tokens.
+    get border() {
+        return 0;
+    }
+    destroy() {
+        this.parent = undefined;
+        if (this.dom.pmViewDesc == this) this.dom.pmViewDesc = undefined;
+        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;
+            // @ts-expect-error ...
+            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 the DOM position is in the content, use the child desc after
+        // it to figure out a position.
+        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;
+            }
+        }
+        // Otherwise, use various heuristics, falling back on the bias
+        // parameter, to determine whether to return the position at the
+        // start or at the end of this view desc.
+        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)) {
+            atEnd = dom.compareDocumentPosition(this.contentDOM) & 2;
+        } 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) {
+        let onlyNodes = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+        for(let first = true, cur = dom; cur; cur = cur.parentNode){
+            const desc = this.getDesc(cur);
+            let nodeDOM;
+            if (desc && (!onlyNodes || desc.node)) {
+                // If dom is outside of this desc's nodeDOM, don't count it.
+                if (first && (nodeDOM = desc.nodeDOM) && !(nodeDOM.nodeType == 1 ? nodeDOM.contains(dom.nodeType == 1 ? dom : dom.parentNode) : nodeDOM == dom)) first = false;
+                else return desc;
+            }
+        }
+        return;
+    }
+    getDesc(dom) {
+        const desc = dom.pmViewDesc;
+        for(let cur = desc; cur; cur = cur.parent)if (cur == this) return desc;
+        return;
+    }
+    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;
+    }
+    // Find the desc for the node after the given pos, if any. (When a
+    // parent node overrode rendering, there might not be one.)
+    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;
+        }
+        return;
+    }
+    domFromPos(pos, side) {
+        if (!this.contentDOM) return {
+            node: this.dom,
+            offset: 0,
+            atom: pos + 1
+        };
+        // First find the position in the child array
+        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 || child instanceof TrailingHackViewDesc) {
+                offset = pos - curPos;
+                break;
+            }
+            curPos = end;
+        }
+        // If this points into the middle of a child, call through
+        if (offset) return this.children[i].domFromPos(offset - this.children[i].border, side);
+        // Go back if there were any zero-length widgets with side >= 0 before this point
+        for(let prev; i && !(prev = this.children[i - 1]).size && prev instanceof WidgetViewDesc && prev.side >= 0; i--){
+        // ...
+        }
+        // Scan towards the first useable node
+        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
+            };
+        }
+    }
+    // Used to find a DOM range in a single parent for a given changed
+    // range.
+    parseRange(from, to) {
+        let base = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0;
+        if (this.children.length == 0) 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;
+                // FIXME maybe descend mark views to parse a narrower range?
+                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];
+        // @ts-expect-error ...
+        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);
+        // @ts-expect-error ...
+        return node.childNodes[offset];
+    }
+    // View descs are responsible for setting any selection that falls
+    // entirely inside of them, so that custom implementations can do
+    // custom things with the selection. Note that this falls apart when
+    // a selection starts in such a node and ends in another, in which
+    // case we just use whatever domFromPos produces as a best effort.
+    setSelection(anchor, head, view) {
+        let force = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
+        if (view.composing) return;
+        // If the selection falls entirely in a child, give it to that child
+        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;
+        // On Firefox, using Selection.collapse to put the cursor after a
+        // BR node for some reason doesn't always work (#1073). On Safari,
+        // the cursor sometimes inexplicable visually lags behind its
+        // reported position in such situations (#1092).
+        if ((browser.gecko || browser.safari) && anchor == head) {
+            const { node, offset } = anchorDOM;
+            if (node.nodeType == 3) {
+                brKludge = !!(offset && node.nodeValue?.[offset - 1] == "\n");
+                // Issue #1128
+                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];
+                // @ts-expect-error ...
+                brKludge = prev && (prev.nodeName == "BR" || prev.contentEditable == "false");
+            }
+        }
+        // Firefox can act strangely when the selection is in front of an
+        // uneditable node. See #1163 and https://bugzilla.mozilla.org/show_bug.cgi?id=1709536
+        if (browser.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 (view.cursorWrapped || !(force || brKludge && browser.safari) && isEquivalentPosition(anchorDOM.node, anchorDOM.offset, selRange.anchorNode, selRange.anchorOffset) && isEquivalentPosition(headDOM.node, headDOM.offset, selRange.focusNode, selRange.focusOffset)) {
+            return;
+        }
+        // Selection.extend can be used to create an 'inverted' selection
+        // (one where the focus is before the anchor), but not all
+        // browsers support it yet.
+        let domSelExtended = false;
+        if ((domSel.extend || anchor == head) && !brKludge) {
+            domSel.collapse(anchorDOM.node, anchorDOM.offset);
+            try {
+                if (anchor != head) domSel.extend(headDOM.node, headDOM.offset);
+                domSelExtended = true;
+            } catch (_) {
+            // In some cases with Chrome the selection is empty after calling
+            // collapse, even when it should be valid. This appears to be a bug, but
+            // it is difficult to isolate. If this happens fallback to the old path
+            // without using extend.
+            // Similarly, this could crash on Safari if the editor is hidden, and
+            // there was no selection.
+            }
+        }
+        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);
+    }
+    // Remove a subtree of the element tree that has been touched
+    // by a DOM change, so that the next update will redraw it.
+    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;
+    }
+}
+// A widget desc represents a widget decoration, which is a DOM node
+// drawn between the document nodes.
+export class WidgetViewDesc extends ViewDesc {
+    widget;
+    constructor(parent, getPos, widget, dom){
+        super(parent, [], getPos, dom, null), this.widget = widget;
+        this.widget = widget;
+    }
+    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;
+    }
+    get domAtom() {
+        return true;
+    }
+    get ignoreForSelection() {
+        return !!this.widget.type.spec.relaxedSide;
+    }
+    get side() {
+        return this.widget.type.side;
+    }
+}
+export class CompositionViewDesc extends ViewDesc {
+    textDOM;
+    text;
+    constructor(parent, getPos, dom, textDOM, text){
+        super(parent, [], getPos, 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;
+    }
+}
+// A mark desc represents a mark. May have multiple children,
+// depending on how the mark is split. Note that marks are drawn using
+// a fixed nesting order, for simplicity and predictability, so in
+// some cases they will be split more often than would appear
+// necessary.
+export class MarkViewDesc extends ViewDesc {
+    mark;
+    spec;
+    constructor(parent, children, getPos, mark, dom, contentDOM, spec){
+        super(parent, children, getPos, dom, contentDOM), this.mark = mark, this.spec = 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);
+        // Move dirty info to nearest node view
+        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;
+        }
+    }
+    ignoreMutation(mutation) {
+        return this.spec.ignoreMutation ? this.spec.ignoreMutation(mutation) : super.ignoreMutation(mutation);
+    }
+    destroy() {
+        if (this.spec.destroy) this.spec.destroy();
+        super.destroy();
+    }
+}
+// Node view descs are the main, most common type of view desc, and
+// correspond to an actual node in the document. Unlike mark descs,
+// they populate their child array themselves.
+export class NodeViewDesc extends ViewDesc {
+    node;
+    outerDeco;
+    innerDeco;
+    nodeDOM;
+    constructor(parent, children, getPos, node, outerDeco, innerDeco, dom, contentDOM, nodeDOM){
+        super(parent, children, getPos, dom, contentDOM), this.node = node, this.outerDeco = outerDeco, this.innerDeco = innerDeco, this.nodeDOM = nodeDOM;
+    }
+    parseRule(addedNodes) {
+        // Experimental kludge to allow opt-in re-parsing of nodes
+        if (this.node.type.spec.reparseInView) return null;
+        // FIXME the assumption that this can always return the current
+        // attrs means that if the user somehow manages to change the
+        // attrs in the dom, that won't be picked up. Not entirely sure
+        // whether this is a problem
+        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 {
+            // Chrome likes to randomly recreate parent nodes when
+            // backspacing things. When that happens, this tries to find the
+            // new parent.
+            for(let i = this.children.length - 1; i >= 0; i--){
+                const child = this.children[i];
+                // @ts-expect-error ...
+                if (this.dom.contains(child.dom.parentNode)) {
+                    // @ts-expect-error ...
+                    rule.contentElement = child.dom.parentNode;
+                    break;
+                }
+            }
+            if (!rule.contentElement) {
+                const found = addedNodes && addedNodes.find((n)=>n.nodeType == 1 && 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) {
+    // Omitted to avoid reproducing lots of unused code.
+    // Overidden elsewhere in case this is ever vendored.
+    }
+    // If this desc must be updated to match the given node decoration,
+    // do so and return true.
+    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) {
+        this.outerDeco = outerDeco;
+    }
+    // Mark this node as being the selected node.
+    selectNode() {
+        if (this.nodeDOM.nodeType == 1) this.nodeDOM.classList.add("ProseMirror-selectednode");
+        if (this.contentDOM || !this.node.type.spec.draggable) this.dom.draggable = true;
+    }
+    // Remove selected node marking from this node.
+    deselectNode() {
+        if (this.nodeDOM.nodeType == 1) {
+            this.nodeDOM.classList.remove("ProseMirror-selectednode");
+            if (this.contentDOM || !this.node.type.spec.draggable) this.dom.removeAttribute("draggable");
+        }
+    }
+    get domAtom() {
+        return this.node.isAtom;
+    }
+}
+export class TextViewDesc extends NodeViewDesc {
+    constructor(parent, children, getPos, node, outerDeco, innerDeco, dom, nodeDOM){
+        super(parent, children, getPos, node, outerDeco, innerDeco, dom, null, nodeDOM);
+    }
+    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);
+        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, this.node.text.length);
+        return super.localPosFromDOM(dom, offset, bias);
+    }
+    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 this.node.text == text;
+    }
+    ignoreMutation(mutation) {
+        return mutation.type !== "characterData" && mutation.type !== "selection";
+    }
+}
+// A dummy desc used to tag trailing BR or IMG nodes created to work
+// around contentEditable terribleness.
+export class TrailingHackViewDesc 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";
+    }
+}
+// A separate subclass is used for customized node views, so that the
+// extra checks only have to be made for nodes that are actually
+// customized.
+let CustomNodeViewDesc = class CustomNodeViewDesc extends NodeViewDesc {
+    spec;
+    constructor(parent, children, getPos, node, outerDeco, innerDeco, dom, contentDOM, nodeDOM, spec){
+        super(parent, children, getPos, node, outerDeco, innerDeco, dom, contentDOM, nodeDOM), this.spec = spec;
+    }
+    // A custom `update` method gets to decide whether the update goes
+    // through. If it does, and there's a `contentDOM` node, our logic
+    // updates the children.
+    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() {
+        this.spec.selectNode ? this.spec.selectNode.call(this) : super.selectNode();
+    }
+    deselectNode() {
+        this.spec.deselectNode ? this.spec.deselectNode.call(this) : super.deselectNode();
+    }
+    setSelection(anchor, head, view, force) {
+        this.spec.setSelection ? this.spec.setSelection.call(this, anchor, head, view.root) : 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);
+    }
+};
+export class ReactMarkViewDesc extends MarkViewDesc {
+    destroy() {
+        // React has already destroyed the children (if needed).
+        this.children = [];
+        super.destroy();
+    }
+}
+export class ReactNodeViewDesc extends CustomNodeViewDesc {
+    updateChildren(_view, _pos) {
+    // React has already updated the children.
+    }
+    updateOuterDeco(outerDeco) {
+        // React has already updated the decorations.
+        this.outerDeco = outerDeco;
+    }
+    destroy() {
+        // React has already destroyed the children (if needed).
+        this.children = [];
+        super.destroy();
+    }
+}
+export function sameOuterDeco(a, b) {
+    if (a.length != b.length) return false;
+    // @ts-expect-error ...
+    for(let i = 0; i < a.length; i++)if (!a[i].type.eq(b[i].type)) return false;
+    return true;
+}
+// Find a piece of text in an inline fragment, overlapping from-to.
+// Ported from prosemirror-view's findTextInFragment.
+export function findTextInFragment(frag, text, from, to) {
+    for(let i = 0, pos = 0; i < frag.childCount && pos <= to;){
+        const child = frag.child(i++);
+        const childStart = pos;
+        pos += child.nodeSize;
+        if (!child.isText) continue;
+        let str = child.text;
+        while(i < frag.childCount){
+            const next = frag.child(i++);
+            pos += next.nodeSize;
+            if (!next.isText) break;
+            str += next.text;
+        }
+        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;
+}