@tiptap/extension-code-block 2.0.0-beta.214 → 2.0.0-beta.215

package/dist/index.js

@@ -1,3441 +1,5 @@
 import { Node, mergeAttributes, textblockTypeInputRule } from '@tiptap/core';
-
-function findDiffStart(a, b, pos) {
-    for (let i = 0;; i++) {
-        if (i == a.childCount || i == b.childCount)
-            return a.childCount == b.childCount ? null : pos;
-        let childA = a.child(i), childB = b.child(i);
-        if (childA == childB) {
-            pos += childA.nodeSize;
-            continue;
-        }
-        if (!childA.sameMarkup(childB))
-            return pos;
-        if (childA.isText && childA.text != childB.text) {
-            for (let j = 0; childA.text[j] == childB.text[j]; j++)
-                pos++;
-            return pos;
-        }
-        if (childA.content.size || childB.content.size) {
-            let inner = findDiffStart(childA.content, childB.content, pos + 1);
-            if (inner != null)
-                return inner;
-        }
-        pos += childA.nodeSize;
-    }
-}
-function findDiffEnd(a, b, posA, posB) {
-    for (let iA = a.childCount, iB = b.childCount;;) {
-        if (iA == 0 || iB == 0)
-            return iA == iB ? null : { a: posA, b: posB };
-        let childA = a.child(--iA), childB = b.child(--iB), size = childA.nodeSize;
-        if (childA == childB) {
-            posA -= size;
-            posB -= size;
-            continue;
-        }
-        if (!childA.sameMarkup(childB))
-            return { a: posA, b: posB };
-        if (childA.isText && childA.text != childB.text) {
-            let same = 0, minSize = Math.min(childA.text.length, childB.text.length);
-            while (same < minSize && childA.text[childA.text.length - same - 1] == childB.text[childB.text.length - same - 1]) {
-                same++;
-                posA--;
-                posB--;
-            }
-            return { a: posA, b: posB };
-        }
-        if (childA.content.size || childB.content.size) {
-            let inner = findDiffEnd(childA.content, childB.content, posA - 1, posB - 1);
-            if (inner)
-                return inner;
-        }
-        posA -= size;
-        posB -= size;
-    }
-}
-
-/**
-A fragment represents a node's collection of child nodes.
-
-Like nodes, fragments are persistent data structures, and you
-should not mutate them or their content. Rather, you create new
-instances whenever needed. The API tries to make this easy.
-*/
-class Fragment {
-    /**
-    @internal
-    */
-    constructor(
-    /**
-    @internal
-    */
-    content, size) {
-        this.content = content;
-        this.size = size || 0;
-        if (size == null)
-            for (let i = 0; i < content.length; i++)
-                this.size += content[i].nodeSize;
-    }
-    /**
-    Invoke a callback for all descendant nodes between the given two
-    positions (relative to start of this fragment). Doesn't descend
-    into a node when the callback returns `false`.
-    */
-    nodesBetween(from, to, f, nodeStart = 0, parent) {
-        for (let i = 0, pos = 0; pos < to; i++) {
-            let child = this.content[i], end = pos + child.nodeSize;
-            if (end > from && f(child, nodeStart + pos, parent || null, i) !== false && child.content.size) {
-                let start = pos + 1;
-                child.nodesBetween(Math.max(0, from - start), Math.min(child.content.size, to - start), f, nodeStart + start);
-            }
-            pos = end;
-        }
-    }
-    /**
-    Call the given callback for every descendant node. `pos` will be
-    relative to the start of the fragment. The callback may return
-    `false` to prevent traversal of a given node's children.
-    */
-    descendants(f) {
-        this.nodesBetween(0, this.size, f);
-    }
-    /**
-    Extract the text between `from` and `to`. See the same method on
-    [`Node`](https://prosemirror.net/docs/ref/#model.Node.textBetween).
-    */
-    textBetween(from, to, blockSeparator, leafText) {
-        let text = "", separated = true;
-        this.nodesBetween(from, to, (node, pos) => {
-            if (node.isText) {
-                text += node.text.slice(Math.max(from, pos) - pos, to - pos);
-                separated = !blockSeparator;
-            }
-            else if (node.isLeaf) {
-                if (leafText) {
-                    text += typeof leafText === "function" ? leafText(node) : leafText;
-                }
-                else if (node.type.spec.leafText) {
-                    text += node.type.spec.leafText(node);
-                }
-                separated = !blockSeparator;
-            }
-            else if (!separated && node.isBlock) {
-                text += blockSeparator;
-                separated = true;
-            }
-        }, 0);
-        return text;
-    }
-    /**
-    Create a new fragment containing the combined content of this
-    fragment and the other.
-    */
-    append(other) {
-        if (!other.size)
-            return this;
-        if (!this.size)
-            return other;
-        let last = this.lastChild, first = other.firstChild, content = this.content.slice(), i = 0;
-        if (last.isText && last.sameMarkup(first)) {
-            content[content.length - 1] = last.withText(last.text + first.text);
-            i = 1;
-        }
-        for (; i < other.content.length; i++)
-            content.push(other.content[i]);
-        return new Fragment(content, this.size + other.size);
-    }
-    /**
-    Cut out the sub-fragment between the two given positions.
-    */
-    cut(from, to = this.size) {
-        if (from == 0 && to == this.size)
-            return this;
-        let result = [], size = 0;
-        if (to > from)
-            for (let i = 0, pos = 0; pos < to; i++) {
-                let child = this.content[i], end = pos + child.nodeSize;
-                if (end > from) {
-                    if (pos < from || end > to) {
-                        if (child.isText)
-                            child = child.cut(Math.max(0, from - pos), Math.min(child.text.length, to - pos));
-                        else
-                            child = child.cut(Math.max(0, from - pos - 1), Math.min(child.content.size, to - pos - 1));
-                    }
-                    result.push(child);
-                    size += child.nodeSize;
-                }
-                pos = end;
-            }
-        return new Fragment(result, size);
-    }
-    /**
-    @internal
-    */
-    cutByIndex(from, to) {
-        if (from == to)
-            return Fragment.empty;
-        if (from == 0 && to == this.content.length)
-            return this;
-        return new Fragment(this.content.slice(from, to));
-    }
-    /**
-    Create a new fragment in which the node at the given index is
-    replaced by the given node.
-    */
-    replaceChild(index, node) {
-        let current = this.content[index];
-        if (current == node)
-            return this;
-        let copy = this.content.slice();
-        let size = this.size + node.nodeSize - current.nodeSize;
-        copy[index] = node;
-        return new Fragment(copy, size);
-    }
-    /**
-    Create a new fragment by prepending the given node to this
-    fragment.
-    */
-    addToStart(node) {
-        return new Fragment([node].concat(this.content), this.size + node.nodeSize);
-    }
-    /**
-    Create a new fragment by appending the given node to this
-    fragment.
-    */
-    addToEnd(node) {
-        return new Fragment(this.content.concat(node), this.size + node.nodeSize);
-    }
-    /**
-    Compare this fragment to another one.
-    */
-    eq(other) {
-        if (this.content.length != other.content.length)
-            return false;
-        for (let i = 0; i < this.content.length; i++)
-            if (!this.content[i].eq(other.content[i]))
-                return false;
-        return true;
-    }
-    /**
-    The first child of the fragment, or `null` if it is empty.
-    */
-    get firstChild() { return this.content.length ? this.content[0] : null; }
-    /**
-    The last child of the fragment, or `null` if it is empty.
-    */
-    get lastChild() { return this.content.length ? this.content[this.content.length - 1] : null; }
-    /**
-    The number of child nodes in this fragment.
-    */
-    get childCount() { return this.content.length; }
-    /**
-    Get the child node at the given index. Raise an error when the
-    index is out of range.
-    */
-    child(index) {
-        let found = this.content[index];
-        if (!found)
-            throw new RangeError("Index " + index + " out of range for " + this);
-        return found;
-    }
-    /**
-    Get the child node at the given index, if it exists.
-    */
-    maybeChild(index) {
-        return this.content[index] || null;
-    }
-    /**
-    Call `f` for every child node, passing the node, its offset
-    into this parent node, and its index.
-    */
-    forEach(f) {
-        for (let i = 0, p = 0; i < this.content.length; i++) {
-            let child = this.content[i];
-            f(child, p, i);
-            p += child.nodeSize;
-        }
-    }
-    /**
-    Find the first position at which this fragment and another
-    fragment differ, or `null` if they are the same.
-    */
-    findDiffStart(other, pos = 0) {
-        return findDiffStart(this, other, pos);
-    }
-    /**
-    Find the first position, searching from the end, at which this
-    fragment and the given fragment differ, or `null` if they are
-    the same. Since this position will not be the same in both
-    nodes, an object with two separate positions is returned.
-    */
-    findDiffEnd(other, pos = this.size, otherPos = other.size) {
-        return findDiffEnd(this, other, pos, otherPos);
-    }
-    /**
-    Find the index and inner offset corresponding to a given relative
-    position in this fragment. The result object will be reused
-    (overwritten) the next time the function is called. (Not public.)
-    */
-    findIndex(pos, round = -1) {
-        if (pos == 0)
-            return retIndex(0, pos);
-        if (pos == this.size)
-            return retIndex(this.content.length, pos);
-        if (pos > this.size || pos < 0)
-            throw new RangeError(`Position ${pos} outside of fragment (${this})`);
-        for (let i = 0, curPos = 0;; i++) {
-            let cur = this.child(i), end = curPos + cur.nodeSize;
-            if (end >= pos) {
-                if (end == pos || round > 0)
-                    return retIndex(i + 1, end);
-                return retIndex(i, curPos);
-            }
-            curPos = end;
-        }
-    }
-    /**
-    Return a debugging string that describes this fragment.
-    */
-    toString() { return "<" + this.toStringInner() + ">"; }
-    /**
-    @internal
-    */
-    toStringInner() { return this.content.join(", "); }
-    /**
-    Create a JSON-serializeable representation of this fragment.
-    */
-    toJSON() {
-        return this.content.length ? this.content.map(n => n.toJSON()) : null;
-    }
-    /**
-    Deserialize a fragment from its JSON representation.
-    */
-    static fromJSON(schema, value) {
-        if (!value)
-            return Fragment.empty;
-        if (!Array.isArray(value))
-            throw new RangeError("Invalid input for Fragment.fromJSON");
-        return new Fragment(value.map(schema.nodeFromJSON));
-    }
-    /**
-    Build a fragment from an array of nodes. Ensures that adjacent
-    text nodes with the same marks are joined together.
-    */
-    static fromArray(array) {
-        if (!array.length)
-            return Fragment.empty;
-        let joined, size = 0;
-        for (let i = 0; i < array.length; i++) {
-            let node = array[i];
-            size += node.nodeSize;
-            if (i && node.isText && array[i - 1].sameMarkup(node)) {
-                if (!joined)
-                    joined = array.slice(0, i);
-                joined[joined.length - 1] = node
-                    .withText(joined[joined.length - 1].text + node.text);
-            }
-            else if (joined) {
-                joined.push(node);
-            }
-        }
-        return new Fragment(joined || array, size);
-    }
-    /**
-    Create a fragment from something that can be interpreted as a
-    set of nodes. For `null`, it returns the empty fragment. For a
-    fragment, the fragment itself. For a node or array of nodes, a
-    fragment containing those nodes.
-    */
-    static from(nodes) {
-        if (!nodes)
-            return Fragment.empty;
-        if (nodes instanceof Fragment)
-            return nodes;
-        if (Array.isArray(nodes))
-            return this.fromArray(nodes);
-        if (nodes.attrs)
-            return new Fragment([nodes], nodes.nodeSize);
-        throw new RangeError("Can not convert " + nodes + " to a Fragment" +
-            (nodes.nodesBetween ? " (looks like multiple versions of prosemirror-model were loaded)" : ""));
-    }
-}
-/**
-An empty fragment. Intended to be reused whenever a node doesn't
-contain anything (rather than allocating a new empty fragment for
-each leaf node).
-*/
-Fragment.empty = new Fragment([], 0);
-const found = { index: 0, offset: 0 };
-function retIndex(index, offset) {
-    found.index = index;
-    found.offset = offset;
-    return found;
-}
-
-function compareDeep(a, b) {
-    if (a === b)
-        return true;
-    if (!(a && typeof a == "object") ||
-        !(b && typeof b == "object"))
-        return false;
-    let array = Array.isArray(a);
-    if (Array.isArray(b) != array)
-        return false;
-    if (array) {
-        if (a.length != b.length)
-            return false;
-        for (let i = 0; i < a.length; i++)
-            if (!compareDeep(a[i], b[i]))
-                return false;
-    }
-    else {
-        for (let p in a)
-            if (!(p in b) || !compareDeep(a[p], b[p]))
-                return false;
-        for (let p in b)
-            if (!(p in a))
-                return false;
-    }
-    return true;
-}
-
-/**
-A mark is a piece of information that can be attached to a node,
-such as it being emphasized, in code font, or a link. It has a
-type and optionally a set of attributes that provide further
-information (such as the target of the link). Marks are created
-through a `Schema`, which controls which types exist and which
-attributes they have.
-*/
-class Mark {
-    /**
-    @internal
-    */
-    constructor(
-    /**
-    The type of this mark.
-    */
-    type, 
-    /**
-    The attributes associated with this mark.
-    */
-    attrs) {
-        this.type = type;
-        this.attrs = attrs;
-    }
-    /**
-    Given a set of marks, create a new set which contains this one as
-    well, in the right position. If this mark is already in the set,
-    the set itself is returned. If any marks that are set to be
-    [exclusive](https://prosemirror.net/docs/ref/#model.MarkSpec.excludes) with this mark are present,
-    those are replaced by this one.
-    */
-    addToSet(set) {
-        let copy, placed = false;
-        for (let i = 0; i < set.length; i++) {
-            let other = set[i];
-            if (this.eq(other))
-                return set;
-            if (this.type.excludes(other.type)) {
-                if (!copy)
-                    copy = set.slice(0, i);
-            }
-            else if (other.type.excludes(this.type)) {
-                return set;
-            }
-            else {
-                if (!placed && other.type.rank > this.type.rank) {
-                    if (!copy)
-                        copy = set.slice(0, i);
-                    copy.push(this);
-                    placed = true;
-                }
-                if (copy)
-                    copy.push(other);
-            }
-        }
-        if (!copy)
-            copy = set.slice();
-        if (!placed)
-            copy.push(this);
-        return copy;
-    }
-    /**
-    Remove this mark from the given set, returning a new set. If this
-    mark is not in the set, the set itself is returned.
-    */
-    removeFromSet(set) {
-        for (let i = 0; i < set.length; i++)
-            if (this.eq(set[i]))
-                return set.slice(0, i).concat(set.slice(i + 1));
-        return set;
-    }
-    /**
-    Test whether this mark is in the given set of marks.
-    */
-    isInSet(set) {
-        for (let i = 0; i < set.length; i++)
-            if (this.eq(set[i]))
-                return true;
-        return false;
-    }
-    /**
-    Test whether this mark has the same type and attributes as
-    another mark.
-    */
-    eq(other) {
-        return this == other ||
-            (this.type == other.type && compareDeep(this.attrs, other.attrs));
-    }
-    /**
-    Convert this mark to a JSON-serializeable representation.
-    */
-    toJSON() {
-        let obj = { type: this.type.name };
-        for (let _ in this.attrs) {
-            obj.attrs = this.attrs;
-            break;
-        }
-        return obj;
-    }
-    /**
-    Deserialize a mark from JSON.
-    */
-    static fromJSON(schema, json) {
-        if (!json)
-            throw new RangeError("Invalid input for Mark.fromJSON");
-        let type = schema.marks[json.type];
-        if (!type)
-            throw new RangeError(`There is no mark type ${json.type} in this schema`);
-        return type.create(json.attrs);
-    }
-    /**
-    Test whether two sets of marks are identical.
-    */
-    static sameSet(a, b) {
-        if (a == b)
-            return true;
-        if (a.length != b.length)
-            return false;
-        for (let i = 0; i < a.length; i++)
-            if (!a[i].eq(b[i]))
-                return false;
-        return true;
-    }
-    /**
-    Create a properly sorted mark set from null, a single mark, or an
-    unsorted array of marks.
-    */
-    static setFrom(marks) {
-        if (!marks || Array.isArray(marks) && marks.length == 0)
-            return Mark.none;
-        if (marks instanceof Mark)
-            return [marks];
-        let copy = marks.slice();
-        copy.sort((a, b) => a.type.rank - b.type.rank);
-        return copy;
-    }
-}
-/**
-The empty set of marks.
-*/
-Mark.none = [];
-
-/**
-Error type raised by [`Node.replace`](https://prosemirror.net/docs/ref/#model.Node.replace) when
-given an invalid replacement.
-*/
-class ReplaceError extends Error {
-}
-/*
-ReplaceError = function(this: any, message: string) {
-  let err = Error.call(this, message)
-  ;(err as any).__proto__ = ReplaceError.prototype
-  return err
-} as any
-
-ReplaceError.prototype = Object.create(Error.prototype)
-ReplaceError.prototype.constructor = ReplaceError
-ReplaceError.prototype.name = "ReplaceError"
-*/
-/**
-A slice represents a piece cut out of a larger document. It
-stores not only a fragment, but also the depth up to which nodes on
-both side are ‘open’ (cut through).
-*/
-class Slice {
-    /**
-    Create a slice. When specifying a non-zero open depth, you must
-    make sure that there are nodes of at least that depth at the
-    appropriate side of the fragment—i.e. if the fragment is an
-    empty paragraph node, `openStart` and `openEnd` can't be greater
-    than 1.
-    
-    It is not necessary for the content of open nodes to conform to
-    the schema's content constraints, though it should be a valid
-    start/end/middle for such a node, depending on which sides are
-    open.
-    */
-    constructor(
-    /**
-    The slice's content.
-    */
-    content, 
-    /**
-    The open depth at the start of the fragment.
-    */
-    openStart, 
-    /**
-    The open depth at the end.
-    */
-    openEnd) {
-        this.content = content;
-        this.openStart = openStart;
-        this.openEnd = openEnd;
-    }
-    /**
-    The size this slice would add when inserted into a document.
-    */
-    get size() {
-        return this.content.size - this.openStart - this.openEnd;
-    }
-    /**
-    @internal
-    */
-    insertAt(pos, fragment) {
-        let content = insertInto(this.content, pos + this.openStart, fragment);
-        return content && new Slice(content, this.openStart, this.openEnd);
-    }
-    /**
-    @internal
-    */
-    removeBetween(from, to) {
-        return new Slice(removeRange(this.content, from + this.openStart, to + this.openStart), this.openStart, this.openEnd);
-    }
-    /**
-    Tests whether this slice is equal to another slice.
-    */
-    eq(other) {
-        return this.content.eq(other.content) && this.openStart == other.openStart && this.openEnd == other.openEnd;
-    }
-    /**
-    @internal
-    */
-    toString() {
-        return this.content + "(" + this.openStart + "," + this.openEnd + ")";
-    }
-    /**
-    Convert a slice to a JSON-serializable representation.
-    */
-    toJSON() {
-        if (!this.content.size)
-            return null;
-        let json = { content: this.content.toJSON() };
-        if (this.openStart > 0)
-            json.openStart = this.openStart;
-        if (this.openEnd > 0)
-            json.openEnd = this.openEnd;
-        return json;
-    }
-    /**
-    Deserialize a slice from its JSON representation.
-    */
-    static fromJSON(schema, json) {
-        if (!json)
-            return Slice.empty;
-        let openStart = json.openStart || 0, openEnd = json.openEnd || 0;
-        if (typeof openStart != "number" || typeof openEnd != "number")
-            throw new RangeError("Invalid input for Slice.fromJSON");
-        return new Slice(Fragment.fromJSON(schema, json.content), openStart, openEnd);
-    }
-    /**
-    Create a slice from a fragment by taking the maximum possible
-    open value on both side of the fragment.
-    */
-    static maxOpen(fragment, openIsolating = true) {
-        let openStart = 0, openEnd = 0;
-        for (let n = fragment.firstChild; n && !n.isLeaf && (openIsolating || !n.type.spec.isolating); n = n.firstChild)
-            openStart++;
-        for (let n = fragment.lastChild; n && !n.isLeaf && (openIsolating || !n.type.spec.isolating); n = n.lastChild)
-            openEnd++;
-        return new Slice(fragment, openStart, openEnd);
-    }
-}
-/**
-The empty slice.
-*/
-Slice.empty = new Slice(Fragment.empty, 0, 0);
-function removeRange(content, from, to) {
-    let { index, offset } = content.findIndex(from), child = content.maybeChild(index);
-    let { index: indexTo, offset: offsetTo } = content.findIndex(to);
-    if (offset == from || child.isText) {
-        if (offsetTo != to && !content.child(indexTo).isText)
-            throw new RangeError("Removing non-flat range");
-        return content.cut(0, from).append(content.cut(to));
-    }
-    if (index != indexTo)
-        throw new RangeError("Removing non-flat range");
-    return content.replaceChild(index, child.copy(removeRange(child.content, from - offset - 1, to - offset - 1)));
-}
-function insertInto(content, dist, insert, parent) {
-    let { index, offset } = content.findIndex(dist), child = content.maybeChild(index);
-    if (offset == dist || child.isText) {
-        if (parent && !parent.canReplace(index, index, insert))
-            return null;
-        return content.cut(0, dist).append(insert).append(content.cut(dist));
-    }
-    let inner = insertInto(child.content, dist - offset - 1, insert);
-    return inner && content.replaceChild(index, child.copy(inner));
-}
-
-// For node types where all attrs have a default value (or which don't
-// have any attributes), build up a single reusable default attribute
-// object, and use it for all nodes that don't specify specific
-// attributes.
-function defaultAttrs(attrs) {
-    let defaults = Object.create(null);
-    for (let attrName in attrs) {
-        let attr = attrs[attrName];
-        if (!attr.hasDefault)
-            return null;
-        defaults[attrName] = attr.default;
-    }
-    return defaults;
-}
-function computeAttrs(attrs, value) {
-    let built = Object.create(null);
-    for (let name in attrs) {
-        let given = value && value[name];
-        if (given === undefined) {
-            let attr = attrs[name];
-            if (attr.hasDefault)
-                given = attr.default;
-            else
-                throw new RangeError("No value supplied for attribute " + name);
-        }
-        built[name] = given;
-    }
-    return built;
-}
-function initAttrs(attrs) {
-    let result = Object.create(null);
-    if (attrs)
-        for (let name in attrs)
-            result[name] = new Attribute(attrs[name]);
-    return result;
-}
-// Attribute descriptors
-class Attribute {
-    constructor(options) {
-        this.hasDefault = Object.prototype.hasOwnProperty.call(options, "default");
-        this.default = options.default;
-    }
-    get isRequired() {
-        return !this.hasDefault;
-    }
-}
-// Marks
-/**
-Like nodes, marks (which are associated with nodes to signify
-things like emphasis or being part of a link) are
-[tagged](https://prosemirror.net/docs/ref/#model.Mark.type) with type objects, which are
-instantiated once per `Schema`.
-*/
-class MarkType {
-    /**
-    @internal
-    */
-    constructor(
-    /**
-    The name of the mark type.
-    */
-    name, 
-    /**
-    @internal
-    */
-    rank, 
-    /**
-    The schema that this mark type instance is part of.
-    */
-    schema, 
-    /**
-    The spec on which the type is based.
-    */
-    spec) {
-        this.name = name;
-        this.rank = rank;
-        this.schema = schema;
-        this.spec = spec;
-        this.attrs = initAttrs(spec.attrs);
-        this.excluded = null;
-        let defaults = defaultAttrs(this.attrs);
-        this.instance = defaults ? new Mark(this, defaults) : null;
-    }
-    /**
-    Create a mark of this type. `attrs` may be `null` or an object
-    containing only some of the mark's attributes. The others, if
-    they have defaults, will be added.
-    */
-    create(attrs = null) {
-        if (!attrs && this.instance)
-            return this.instance;
-        return new Mark(this, computeAttrs(this.attrs, attrs));
-    }
-    /**
-    @internal
-    */
-    static compile(marks, schema) {
-        let result = Object.create(null), rank = 0;
-        marks.forEach((name, spec) => result[name] = new MarkType(name, rank++, schema, spec));
-        return result;
-    }
-    /**
-    When there is a mark of this type in the given set, a new set
-    without it is returned. Otherwise, the input set is returned.
-    */
-    removeFromSet(set) {
-        for (var i = 0; i < set.length; i++)
-            if (set[i].type == this) {
-                set = set.slice(0, i).concat(set.slice(i + 1));
-                i--;
-            }
-        return set;
-    }
-    /**
-    Tests whether there is a mark of this type in the given set.
-    */
-    isInSet(set) {
-        for (let i = 0; i < set.length; i++)
-            if (set[i].type == this)
-                return set[i];
-    }
-    /**
-    Queries whether a given mark type is
-    [excluded](https://prosemirror.net/docs/ref/#model.MarkSpec.excludes) by this one.
-    */
-    excludes(other) {
-        return this.excluded.indexOf(other) > -1;
-    }
-}
-
-// Recovery values encode a range index and an offset. They are
-// represented as numbers, because tons of them will be created when
-// mapping, for example, a large number of decorations. The number's
-// lower 16 bits provide the index, the remaining bits the offset.
-//
-// Note: We intentionally don't use bit shift operators to en- and
-// decode these, since those clip to 32 bits, which we might in rare
-// cases want to overflow. A 64-bit float can represent 48-bit
-// integers precisely.
-const lower16 = 0xffff;
-const factor16 = Math.pow(2, 16);
-function makeRecover(index, offset) { return index + offset * factor16; }
-function recoverIndex(value) { return value & lower16; }
-function recoverOffset(value) { return (value - (value & lower16)) / factor16; }
-const DEL_BEFORE = 1, DEL_AFTER = 2, DEL_ACROSS = 4, DEL_SIDE = 8;
-/**
-An object representing a mapped position with extra
-information.
-*/
-class MapResult {
-    /**
-    @internal
-    */
-    constructor(
-    /**
-    The mapped version of the position.
-    */
-    pos, 
-    /**
-    @internal
-    */
-    delInfo, 
-    /**
-    @internal
-    */
-    recover) {
-        this.pos = pos;
-        this.delInfo = delInfo;
-        this.recover = recover;
-    }
-    /**
-    Tells you whether the position was deleted, that is, whether the
-    step removed the token on the side queried (via the `assoc`)
-    argument from the document.
-    */
-    get deleted() { return (this.delInfo & DEL_SIDE) > 0; }
-    /**
-    Tells you whether the token before the mapped position was deleted.
-    */
-    get deletedBefore() { return (this.delInfo & (DEL_BEFORE | DEL_ACROSS)) > 0; }
-    /**
-    True when the token after the mapped position was deleted.
-    */
-    get deletedAfter() { return (this.delInfo & (DEL_AFTER | DEL_ACROSS)) > 0; }
-    /**
-    Tells whether any of the steps mapped through deletes across the
-    position (including both the token before and after the
-    position).
-    */
-    get deletedAcross() { return (this.delInfo & DEL_ACROSS) > 0; }
-}
-/**
-A map describing the deletions and insertions made by a step, which
-can be used to find the correspondence between positions in the
-pre-step version of a document and the same position in the
-post-step version.
-*/
-class StepMap {
-    /**
-    Create a position map. The modifications to the document are
-    represented as an array of numbers, in which each group of three
-    represents a modified chunk as `[start, oldSize, newSize]`.
-    */
-    constructor(
-    /**
-    @internal
-    */
-    ranges, 
-    /**
-    @internal
-    */
-    inverted = false) {
-        this.ranges = ranges;
-        this.inverted = inverted;
-        if (!ranges.length && StepMap.empty)
-            return StepMap.empty;
-    }
-    /**
-    @internal
-    */
-    recover(value) {
-        let diff = 0, index = recoverIndex(value);
-        if (!this.inverted)
-            for (let i = 0; i < index; i++)
-                diff += this.ranges[i * 3 + 2] - this.ranges[i * 3 + 1];
-        return this.ranges[index * 3] + diff + recoverOffset(value);
-    }
-    mapResult(pos, assoc = 1) { return this._map(pos, assoc, false); }
-    map(pos, assoc = 1) { return this._map(pos, assoc, true); }
-    /**
-    @internal
-    */
-    _map(pos, assoc, simple) {
-        let diff = 0, oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
-        for (let i = 0; i < this.ranges.length; i += 3) {
-            let start = this.ranges[i] - (this.inverted ? diff : 0);
-            if (start > pos)
-                break;
-            let oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex], end = start + oldSize;
-            if (pos <= end) {
-                let side = !oldSize ? assoc : pos == start ? -1 : pos == end ? 1 : assoc;
-                let result = start + diff + (side < 0 ? 0 : newSize);
-                if (simple)
-                    return result;
-                let recover = pos == (assoc < 0 ? start : end) ? null : makeRecover(i / 3, pos - start);
-                let del = pos == start ? DEL_AFTER : pos == end ? DEL_BEFORE : DEL_ACROSS;
-                if (assoc < 0 ? pos != start : pos != end)
-                    del |= DEL_SIDE;
-                return new MapResult(result, del, recover);
-            }
-            diff += newSize - oldSize;
-        }
-        return simple ? pos + diff : new MapResult(pos + diff, 0, null);
-    }
-    /**
-    @internal
-    */
-    touches(pos, recover) {
-        let diff = 0, index = recoverIndex(recover);
-        let oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
-        for (let i = 0; i < this.ranges.length; i += 3) {
-            let start = this.ranges[i] - (this.inverted ? diff : 0);
-            if (start > pos)
-                break;
-            let oldSize = this.ranges[i + oldIndex], end = start + oldSize;
-            if (pos <= end && i == index * 3)
-                return true;
-            diff += this.ranges[i + newIndex] - oldSize;
-        }
-        return false;
-    }
-    /**
-    Calls the given function on each of the changed ranges included in
-    this map.
-    */
-    forEach(f) {
-        let oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
-        for (let i = 0, diff = 0; i < this.ranges.length; i += 3) {
-            let start = this.ranges[i], oldStart = start - (this.inverted ? diff : 0), newStart = start + (this.inverted ? 0 : diff);
-            let oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex];
-            f(oldStart, oldStart + oldSize, newStart, newStart + newSize);
-            diff += newSize - oldSize;
-        }
-    }
-    /**
-    Create an inverted version of this map. The result can be used to
-    map positions in the post-step document to the pre-step document.
-    */
-    invert() {
-        return new StepMap(this.ranges, !this.inverted);
-    }
-    /**
-    @internal
-    */
-    toString() {
-        return (this.inverted ? "-" : "") + JSON.stringify(this.ranges);
-    }
-    /**
-    Create a map that moves all positions by offset `n` (which may be
-    negative). This can be useful when applying steps meant for a
-    sub-document to a larger document, or vice-versa.
-    */
-    static offset(n) {
-        return n == 0 ? StepMap.empty : new StepMap(n < 0 ? [0, -n, 0] : [0, 0, n]);
-    }
-}
-/**
-A StepMap that contains no changed ranges.
-*/
-StepMap.empty = new StepMap([]);
-/**
-A mapping represents a pipeline of zero or more [step
-maps](https://prosemirror.net/docs/ref/#transform.StepMap). It has special provisions for losslessly
-handling mapping positions through a series of steps in which some
-steps are inverted versions of earlier steps. (This comes up when
-‘[rebasing](/docs/guide/#transform.rebasing)’ steps for
-collaboration or history management.)
-*/
-class Mapping {
-    /**
-    Create a new mapping with the given position maps.
-    */
-    constructor(
-    /**
-    The step maps in this mapping.
-    */
-    maps = [], 
-    /**
-    @internal
-    */
-    mirror, 
-    /**
-    The starting position in the `maps` array, used when `map` or
-    `mapResult` is called.
-    */
-    from = 0, 
-    /**
-    The end position in the `maps` array.
-    */
-    to = maps.length) {
-        this.maps = maps;
-        this.mirror = mirror;
-        this.from = from;
-        this.to = to;
-    }
-    /**
-    Create a mapping that maps only through a part of this one.
-    */
-    slice(from = 0, to = this.maps.length) {
-        return new Mapping(this.maps, this.mirror, from, to);
-    }
-    /**
-    @internal
-    */
-    copy() {
-        return new Mapping(this.maps.slice(), this.mirror && this.mirror.slice(), this.from, this.to);
-    }
-    /**
-    Add a step map to the end of this mapping. If `mirrors` is
-    given, it should be the index of the step map that is the mirror
-    image of this one.
-    */
-    appendMap(map, mirrors) {
-        this.to = this.maps.push(map);
-        if (mirrors != null)
-            this.setMirror(this.maps.length - 1, mirrors);
-    }
-    /**
-    Add all the step maps in a given mapping to this one (preserving
-    mirroring information).
-    */
-    appendMapping(mapping) {
-        for (let i = 0, startSize = this.maps.length; i < mapping.maps.length; i++) {
-            let mirr = mapping.getMirror(i);
-            this.appendMap(mapping.maps[i], mirr != null && mirr < i ? startSize + mirr : undefined);
-        }
-    }
-    /**
-    Finds the offset of the step map that mirrors the map at the
-    given offset, in this mapping (as per the second argument to
-    `appendMap`).
-    */
-    getMirror(n) {
-        if (this.mirror)
-            for (let i = 0; i < this.mirror.length; i++)
-                if (this.mirror[i] == n)
-                    return this.mirror[i + (i % 2 ? -1 : 1)];
-    }
-    /**
-    @internal
-    */
-    setMirror(n, m) {
-        if (!this.mirror)
-            this.mirror = [];
-        this.mirror.push(n, m);
-    }
-    /**
-    Append the inverse of the given mapping to this one.
-    */
-    appendMappingInverted(mapping) {
-        for (let i = mapping.maps.length - 1, totalSize = this.maps.length + mapping.maps.length; i >= 0; i--) {
-            let mirr = mapping.getMirror(i);
-            this.appendMap(mapping.maps[i].invert(), mirr != null && mirr > i ? totalSize - mirr - 1 : undefined);
-        }
-    }
-    /**
-    Create an inverted version of this mapping.
-    */
-    invert() {
-        let inverse = new Mapping;
-        inverse.appendMappingInverted(this);
-        return inverse;
-    }
-    /**
-    Map a position through this mapping.
-    */
-    map(pos, assoc = 1) {
-        if (this.mirror)
-            return this._map(pos, assoc, true);
-        for (let i = this.from; i < this.to; i++)
-            pos = this.maps[i].map(pos, assoc);
-        return pos;
-    }
-    /**
-    Map a position through this mapping, returning a mapping
-    result.
-    */
-    mapResult(pos, assoc = 1) { return this._map(pos, assoc, false); }
-    /**
-    @internal
-    */
-    _map(pos, assoc, simple) {
-        let delInfo = 0;
-        for (let i = this.from; i < this.to; i++) {
-            let map = this.maps[i], result = map.mapResult(pos, assoc);
-            if (result.recover != null) {
-                let corr = this.getMirror(i);
-                if (corr != null && corr > i && corr < this.to) {
-                    i = corr;
-                    pos = this.maps[corr].recover(result.recover);
-                    continue;
-                }
-            }
-            delInfo |= result.delInfo;
-            pos = result.pos;
-        }
-        return simple ? pos : new MapResult(pos, delInfo, null);
-    }
-}
-
-const stepsByID = Object.create(null);
-/**
-A step object represents an atomic change. It generally applies
-only to the document it was created for, since the positions
-stored in it will only make sense for that document.
-
-New steps are defined by creating classes that extend `Step`,
-overriding the `apply`, `invert`, `map`, `getMap` and `fromJSON`
-methods, and registering your class with a unique
-JSON-serialization identifier using
-[`Step.jsonID`](https://prosemirror.net/docs/ref/#transform.Step^jsonID).
-*/
-class Step {
-    /**
-    Get the step map that represents the changes made by this step,
-    and which can be used to transform between positions in the old
-    and the new document.
-    */
-    getMap() { return StepMap.empty; }
-    /**
-    Try to merge this step with another one, to be applied directly
-    after it. Returns the merged step when possible, null if the
-    steps can't be merged.
-    */
-    merge(other) { return null; }
-    /**
-    Deserialize a step from its JSON representation. Will call
-    through to the step class' own implementation of this method.
-    */
-    static fromJSON(schema, json) {
-        if (!json || !json.stepType)
-            throw new RangeError("Invalid input for Step.fromJSON");
-        let type = stepsByID[json.stepType];
-        if (!type)
-            throw new RangeError(`No step type ${json.stepType} defined`);
-        return type.fromJSON(schema, json);
-    }
-    /**
-    To be able to serialize steps to JSON, each step needs a string
-    ID to attach to its JSON representation. Use this method to
-    register an ID for your step classes. Try to pick something
-    that's unlikely to clash with steps from other modules.
-    */
-    static jsonID(id, stepClass) {
-        if (id in stepsByID)
-            throw new RangeError("Duplicate use of step JSON ID " + id);
-        stepsByID[id] = stepClass;
-        stepClass.prototype.jsonID = id;
-        return stepClass;
-    }
-}
-/**
-The result of [applying](https://prosemirror.net/docs/ref/#transform.Step.apply) a step. Contains either a
-new document or a failure value.
-*/
-class StepResult {
-    /**
-    @internal
-    */
-    constructor(
-    /**
-    The transformed document, if successful.
-    */
-    doc, 
-    /**
-    The failure message, if unsuccessful.
-    */
-    failed) {
-        this.doc = doc;
-        this.failed = failed;
-    }
-    /**
-    Create a successful step result.
-    */
-    static ok(doc) { return new StepResult(doc, null); }
-    /**
-    Create a failed step result.
-    */
-    static fail(message) { return new StepResult(null, message); }
-    /**
-    Call [`Node.replace`](https://prosemirror.net/docs/ref/#model.Node.replace) with the given
-    arguments. Create a successful result if it succeeds, and a
-    failed one if it throws a `ReplaceError`.
-    */
-    static fromReplace(doc, from, to, slice) {
-        try {
-            return StepResult.ok(doc.replace(from, to, slice));
-        }
-        catch (e) {
-            if (e instanceof ReplaceError)
-                return StepResult.fail(e.message);
-            throw e;
-        }
-    }
-}
-
-function mapFragment(fragment, f, parent) {
-    let mapped = [];
-    for (let i = 0; i < fragment.childCount; i++) {
-        let child = fragment.child(i);
-        if (child.content.size)
-            child = child.copy(mapFragment(child.content, f, child));
-        if (child.isInline)
-            child = f(child, parent, i);
-        mapped.push(child);
-    }
-    return Fragment.fromArray(mapped);
-}
-/**
-Add a mark to all inline content between two positions.
-*/
-class AddMarkStep extends Step {
-    /**
-    Create a mark step.
-    */
-    constructor(
-    /**
-    The start of the marked range.
-    */
-    from, 
-    /**
-    The end of the marked range.
-    */
-    to, 
-    /**
-    The mark to add.
-    */
-    mark) {
-        super();
-        this.from = from;
-        this.to = to;
-        this.mark = mark;
-    }
-    apply(doc) {
-        let oldSlice = doc.slice(this.from, this.to), $from = doc.resolve(this.from);
-        let parent = $from.node($from.sharedDepth(this.to));
-        let slice = new Slice(mapFragment(oldSlice.content, (node, parent) => {
-            if (!node.isAtom || !parent.type.allowsMarkType(this.mark.type))
-                return node;
-            return node.mark(this.mark.addToSet(node.marks));
-        }, parent), oldSlice.openStart, oldSlice.openEnd);
-        return StepResult.fromReplace(doc, this.from, this.to, slice);
-    }
-    invert() {
-        return new RemoveMarkStep(this.from, this.to, this.mark);
-    }
-    map(mapping) {
-        let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-        if (from.deleted && to.deleted || from.pos >= to.pos)
-            return null;
-        return new AddMarkStep(from.pos, to.pos, this.mark);
-    }
-    merge(other) {
-        if (other instanceof AddMarkStep &&
-            other.mark.eq(this.mark) &&
-            this.from <= other.to && this.to >= other.from)
-            return new AddMarkStep(Math.min(this.from, other.from), Math.max(this.to, other.to), this.mark);
-        return null;
-    }
-    toJSON() {
-        return { stepType: "addMark", mark: this.mark.toJSON(),
-            from: this.from, to: this.to };
-    }
-    /**
-    @internal
-    */
-    static fromJSON(schema, json) {
-        if (typeof json.from != "number" || typeof json.to != "number")
-            throw new RangeError("Invalid input for AddMarkStep.fromJSON");
-        return new AddMarkStep(json.from, json.to, schema.markFromJSON(json.mark));
-    }
-}
-Step.jsonID("addMark", AddMarkStep);
-/**
-Remove a mark from all inline content between two positions.
-*/
-class RemoveMarkStep extends Step {
-    /**
-    Create a mark-removing step.
-    */
-    constructor(
-    /**
-    The start of the unmarked range.
-    */
-    from, 
-    /**
-    The end of the unmarked range.
-    */
-    to, 
-    /**
-    The mark to remove.
-    */
-    mark) {
-        super();
-        this.from = from;
-        this.to = to;
-        this.mark = mark;
-    }
-    apply(doc) {
-        let oldSlice = doc.slice(this.from, this.to);
-        let slice = new Slice(mapFragment(oldSlice.content, node => {
-            return node.mark(this.mark.removeFromSet(node.marks));
-        }, doc), oldSlice.openStart, oldSlice.openEnd);
-        return StepResult.fromReplace(doc, this.from, this.to, slice);
-    }
-    invert() {
-        return new AddMarkStep(this.from, this.to, this.mark);
-    }
-    map(mapping) {
-        let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-        if (from.deleted && to.deleted || from.pos >= to.pos)
-            return null;
-        return new RemoveMarkStep(from.pos, to.pos, this.mark);
-    }
-    merge(other) {
-        if (other instanceof RemoveMarkStep &&
-            other.mark.eq(this.mark) &&
-            this.from <= other.to && this.to >= other.from)
-            return new RemoveMarkStep(Math.min(this.from, other.from), Math.max(this.to, other.to), this.mark);
-        return null;
-    }
-    toJSON() {
-        return { stepType: "removeMark", mark: this.mark.toJSON(),
-            from: this.from, to: this.to };
-    }
-    /**
-    @internal
-    */
-    static fromJSON(schema, json) {
-        if (typeof json.from != "number" || typeof json.to != "number")
-            throw new RangeError("Invalid input for RemoveMarkStep.fromJSON");
-        return new RemoveMarkStep(json.from, json.to, schema.markFromJSON(json.mark));
-    }
-}
-Step.jsonID("removeMark", RemoveMarkStep);
-/**
-Add a mark to a specific node.
-*/
-class AddNodeMarkStep extends Step {
-    /**
-    Create a node mark step.
-    */
-    constructor(
-    /**
-    The position of the target node.
-    */
-    pos, 
-    /**
-    The mark to add.
-    */
-    mark) {
-        super();
-        this.pos = pos;
-        this.mark = mark;
-    }
-    apply(doc) {
-        let node = doc.nodeAt(this.pos);
-        if (!node)
-            return StepResult.fail("No node at mark step's position");
-        let updated = node.type.create(node.attrs, null, this.mark.addToSet(node.marks));
-        return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
-    }
-    invert(doc) {
-        let node = doc.nodeAt(this.pos);
-        if (node) {
-            let newSet = this.mark.addToSet(node.marks);
-            if (newSet.length == node.marks.length) {
-                for (let i = 0; i < node.marks.length; i++)
-                    if (!node.marks[i].isInSet(newSet))
-                        return new AddNodeMarkStep(this.pos, node.marks[i]);
-                return new AddNodeMarkStep(this.pos, this.mark);
-            }
-        }
-        return new RemoveNodeMarkStep(this.pos, this.mark);
-    }
-    map(mapping) {
-        let pos = mapping.mapResult(this.pos, 1);
-        return pos.deletedAfter ? null : new AddNodeMarkStep(pos.pos, this.mark);
-    }
-    toJSON() {
-        return { stepType: "addNodeMark", pos: this.pos, mark: this.mark.toJSON() };
-    }
-    /**
-    @internal
-    */
-    static fromJSON(schema, json) {
-        if (typeof json.pos != "number")
-            throw new RangeError("Invalid input for AddNodeMarkStep.fromJSON");
-        return new AddNodeMarkStep(json.pos, schema.markFromJSON(json.mark));
-    }
-}
-Step.jsonID("addNodeMark", AddNodeMarkStep);
-/**
-Remove a mark from a specific node.
-*/
-class RemoveNodeMarkStep extends Step {
-    /**
-    Create a mark-removing step.
-    */
-    constructor(
-    /**
-    The position of the target node.
-    */
-    pos, 
-    /**
-    The mark to remove.
-    */
-    mark) {
-        super();
-        this.pos = pos;
-        this.mark = mark;
-    }
-    apply(doc) {
-        let node = doc.nodeAt(this.pos);
-        if (!node)
-            return StepResult.fail("No node at mark step's position");
-        let updated = node.type.create(node.attrs, null, this.mark.removeFromSet(node.marks));
-        return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
-    }
-    invert(doc) {
-        let node = doc.nodeAt(this.pos);
-        if (!node || !this.mark.isInSet(node.marks))
-            return this;
-        return new AddNodeMarkStep(this.pos, this.mark);
-    }
-    map(mapping) {
-        let pos = mapping.mapResult(this.pos, 1);
-        return pos.deletedAfter ? null : new RemoveNodeMarkStep(pos.pos, this.mark);
-    }
-    toJSON() {
-        return { stepType: "removeNodeMark", pos: this.pos, mark: this.mark.toJSON() };
-    }
-    /**
-    @internal
-    */
-    static fromJSON(schema, json) {
-        if (typeof json.pos != "number")
-            throw new RangeError("Invalid input for RemoveNodeMarkStep.fromJSON");
-        return new RemoveNodeMarkStep(json.pos, schema.markFromJSON(json.mark));
-    }
-}
-Step.jsonID("removeNodeMark", RemoveNodeMarkStep);
-
-/**
-Replace a part of the document with a slice of new content.
-*/
-class ReplaceStep extends Step {
-    /**
-    The given `slice` should fit the 'gap' between `from` and
-    `to`—the depths must line up, and the surrounding nodes must be
-    able to be joined with the open sides of the slice. When
-    `structure` is true, the step will fail if the content between
-    from and to is not just a sequence of closing and then opening
-    tokens (this is to guard against rebased replace steps
-    overwriting something they weren't supposed to).
-    */
-    constructor(
-    /**
-    The start position of the replaced range.
-    */
-    from, 
-    /**
-    The end position of the replaced range.
-    */
-    to, 
-    /**
-    The slice to insert.
-    */
-    slice, 
-    /**
-    @internal
-    */
-    structure = false) {
-        super();
-        this.from = from;
-        this.to = to;
-        this.slice = slice;
-        this.structure = structure;
-    }
-    apply(doc) {
-        if (this.structure && contentBetween(doc, this.from, this.to))
-            return StepResult.fail("Structure replace would overwrite content");
-        return StepResult.fromReplace(doc, this.from, this.to, this.slice);
-    }
-    getMap() {
-        return new StepMap([this.from, this.to - this.from, this.slice.size]);
-    }
-    invert(doc) {
-        return new ReplaceStep(this.from, this.from + this.slice.size, doc.slice(this.from, this.to));
-    }
-    map(mapping) {
-        let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-        if (from.deletedAcross && to.deletedAcross)
-            return null;
-        return new ReplaceStep(from.pos, Math.max(from.pos, to.pos), this.slice);
-    }
-    merge(other) {
-        if (!(other instanceof ReplaceStep) || other.structure || this.structure)
-            return null;
-        if (this.from + this.slice.size == other.from && !this.slice.openEnd && !other.slice.openStart) {
-            let slice = this.slice.size + other.slice.size == 0 ? Slice.empty
-                : new Slice(this.slice.content.append(other.slice.content), this.slice.openStart, other.slice.openEnd);
-            return new ReplaceStep(this.from, this.to + (other.to - other.from), slice, this.structure);
-        }
-        else if (other.to == this.from && !this.slice.openStart && !other.slice.openEnd) {
-            let slice = this.slice.size + other.slice.size == 0 ? Slice.empty
-                : new Slice(other.slice.content.append(this.slice.content), other.slice.openStart, this.slice.openEnd);
-            return new ReplaceStep(other.from, this.to, slice, this.structure);
-        }
-        else {
-            return null;
-        }
-    }
-    toJSON() {
-        let json = { stepType: "replace", from: this.from, to: this.to };
-        if (this.slice.size)
-            json.slice = this.slice.toJSON();
-        if (this.structure)
-            json.structure = true;
-        return json;
-    }
-    /**
-    @internal
-    */
-    static fromJSON(schema, json) {
-        if (typeof json.from != "number" || typeof json.to != "number")
-            throw new RangeError("Invalid input for ReplaceStep.fromJSON");
-        return new ReplaceStep(json.from, json.to, Slice.fromJSON(schema, json.slice), !!json.structure);
-    }
-}
-Step.jsonID("replace", ReplaceStep);
-/**
-Replace a part of the document with a slice of content, but
-preserve a range of the replaced content by moving it into the
-slice.
-*/
-class ReplaceAroundStep extends Step {
-    /**
-    Create a replace-around step with the given range and gap.
-    `insert` should be the point in the slice into which the content
-    of the gap should be moved. `structure` has the same meaning as
-    it has in the [`ReplaceStep`](https://prosemirror.net/docs/ref/#transform.ReplaceStep) class.
-    */
-    constructor(
-    /**
-    The start position of the replaced range.
-    */
-    from, 
-    /**
-    The end position of the replaced range.
-    */
-    to, 
-    /**
-    The start of preserved range.
-    */
-    gapFrom, 
-    /**
-    The end of preserved range.
-    */
-    gapTo, 
-    /**
-    The slice to insert.
-    */
-    slice, 
-    /**
-    The position in the slice where the preserved range should be
-    inserted.
-    */
-    insert, 
-    /**
-    @internal
-    */
-    structure = false) {
-        super();
-        this.from = from;
-        this.to = to;
-        this.gapFrom = gapFrom;
-        this.gapTo = gapTo;
-        this.slice = slice;
-        this.insert = insert;
-        this.structure = structure;
-    }
-    apply(doc) {
-        if (this.structure && (contentBetween(doc, this.from, this.gapFrom) ||
-            contentBetween(doc, this.gapTo, this.to)))
-            return StepResult.fail("Structure gap-replace would overwrite content");
-        let gap = doc.slice(this.gapFrom, this.gapTo);
-        if (gap.openStart || gap.openEnd)
-            return StepResult.fail("Gap is not a flat range");
-        let inserted = this.slice.insertAt(this.insert, gap.content);
-        if (!inserted)
-            return StepResult.fail("Content does not fit in gap");
-        return StepResult.fromReplace(doc, this.from, this.to, inserted);
-    }
-    getMap() {
-        return new StepMap([this.from, this.gapFrom - this.from, this.insert,
-            this.gapTo, this.to - this.gapTo, this.slice.size - this.insert]);
-    }
-    invert(doc) {
-        let gap = this.gapTo - this.gapFrom;
-        return new ReplaceAroundStep(this.from, this.from + this.slice.size + gap, this.from + this.insert, this.from + this.insert + gap, doc.slice(this.from, this.to).removeBetween(this.gapFrom - this.from, this.gapTo - this.from), this.gapFrom - this.from, this.structure);
-    }
-    map(mapping) {
-        let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-        let gapFrom = mapping.map(this.gapFrom, -1), gapTo = mapping.map(this.gapTo, 1);
-        if ((from.deletedAcross && to.deletedAcross) || gapFrom < from.pos || gapTo > to.pos)
-            return null;
-        return new ReplaceAroundStep(from.pos, to.pos, gapFrom, gapTo, this.slice, this.insert, this.structure);
-    }
-    toJSON() {
-        let json = { stepType: "replaceAround", from: this.from, to: this.to,
-            gapFrom: this.gapFrom, gapTo: this.gapTo, insert: this.insert };
-        if (this.slice.size)
-            json.slice = this.slice.toJSON();
-        if (this.structure)
-            json.structure = true;
-        return json;
-    }
-    /**
-    @internal
-    */
-    static fromJSON(schema, json) {
-        if (typeof json.from != "number" || typeof json.to != "number" ||
-            typeof json.gapFrom != "number" || typeof json.gapTo != "number" || typeof json.insert != "number")
-            throw new RangeError("Invalid input for ReplaceAroundStep.fromJSON");
-        return new ReplaceAroundStep(json.from, json.to, json.gapFrom, json.gapTo, Slice.fromJSON(schema, json.slice), json.insert, !!json.structure);
-    }
-}
-Step.jsonID("replaceAround", ReplaceAroundStep);
-function contentBetween(doc, from, to) {
-    let $from = doc.resolve(from), dist = to - from, depth = $from.depth;
-    while (dist > 0 && depth > 0 && $from.indexAfter(depth) == $from.node(depth).childCount) {
-        depth--;
-        dist--;
-    }
-    if (dist > 0) {
-        let next = $from.node(depth).maybeChild($from.indexAfter(depth));
-        while (dist > 0) {
-            if (!next || next.isLeaf)
-                return true;
-            next = next.firstChild;
-            dist--;
-        }
-    }
-    return false;
-}
-
-function addMark(tr, from, to, mark) {
-    let removed = [], added = [];
-    let removing, adding;
-    tr.doc.nodesBetween(from, to, (node, pos, parent) => {
-        if (!node.isInline)
-            return;
-        let marks = node.marks;
-        if (!mark.isInSet(marks) && parent.type.allowsMarkType(mark.type)) {
-            let start = Math.max(pos, from), end = Math.min(pos + node.nodeSize, to);
-            let newSet = mark.addToSet(marks);
-            for (let i = 0; i < marks.length; i++) {
-                if (!marks[i].isInSet(newSet)) {
-                    if (removing && removing.to == start && removing.mark.eq(marks[i]))
-                        removing.to = end;
-                    else
-                        removed.push(removing = new RemoveMarkStep(start, end, marks[i]));
-                }
-            }
-            if (adding && adding.to == start)
-                adding.to = end;
-            else
-                added.push(adding = new AddMarkStep(start, end, mark));
-        }
-    });
-    removed.forEach(s => tr.step(s));
-    added.forEach(s => tr.step(s));
-}
-function removeMark(tr, from, to, mark) {
-    let matched = [], step = 0;
-    tr.doc.nodesBetween(from, to, (node, pos) => {
-        if (!node.isInline)
-            return;
-        step++;
-        let toRemove = null;
-        if (mark instanceof MarkType) {
-            let set = node.marks, found;
-            while (found = mark.isInSet(set)) {
-                (toRemove || (toRemove = [])).push(found);
-                set = found.removeFromSet(set);
-            }
-        }
-        else if (mark) {
-            if (mark.isInSet(node.marks))
-                toRemove = [mark];
-        }
-        else {
-            toRemove = node.marks;
-        }
-        if (toRemove && toRemove.length) {
-            let end = Math.min(pos + node.nodeSize, to);
-            for (let i = 0; i < toRemove.length; i++) {
-                let style = toRemove[i], found;
-                for (let j = 0; j < matched.length; j++) {
-                    let m = matched[j];
-                    if (m.step == step - 1 && style.eq(matched[j].style))
-                        found = m;
-                }
-                if (found) {
-                    found.to = end;
-                    found.step = step;
-                }
-                else {
-                    matched.push({ style, from: Math.max(pos, from), to: end, step });
-                }
-            }
-        }
-    });
-    matched.forEach(m => tr.step(new RemoveMarkStep(m.from, m.to, m.style)));
-}
-function clearIncompatible(tr, pos, parentType, match = parentType.contentMatch) {
-    let node = tr.doc.nodeAt(pos);
-    let delSteps = [], cur = pos + 1;
-    for (let i = 0; i < node.childCount; i++) {
-        let child = node.child(i), end = cur + child.nodeSize;
-        let allowed = match.matchType(child.type);
-        if (!allowed) {
-            delSteps.push(new ReplaceStep(cur, end, Slice.empty));
-        }
-        else {
-            match = allowed;
-            for (let j = 0; j < child.marks.length; j++)
-                if (!parentType.allowsMarkType(child.marks[j].type))
-                    tr.step(new RemoveMarkStep(cur, end, child.marks[j]));
-        }
-        cur = end;
-    }
-    if (!match.validEnd) {
-        let fill = match.fillBefore(Fragment.empty, true);
-        tr.replace(cur, cur, new Slice(fill, 0, 0));
-    }
-    for (let i = delSteps.length - 1; i >= 0; i--)
-        tr.step(delSteps[i]);
-}
-function lift(tr, range, target) {
-    let { $from, $to, depth } = range;
-    let gapStart = $from.before(depth + 1), gapEnd = $to.after(depth + 1);
-    let start = gapStart, end = gapEnd;
-    let before = Fragment.empty, openStart = 0;
-    for (let d = depth, splitting = false; d > target; d--)
-        if (splitting || $from.index(d) > 0) {
-            splitting = true;
-            before = Fragment.from($from.node(d).copy(before));
-            openStart++;
-        }
-        else {
-            start--;
-        }
-    let after = Fragment.empty, openEnd = 0;
-    for (let d = depth, splitting = false; d > target; d--)
-        if (splitting || $to.after(d + 1) < $to.end(d)) {
-            splitting = true;
-            after = Fragment.from($to.node(d).copy(after));
-            openEnd++;
-        }
-        else {
-            end++;
-        }
-    tr.step(new ReplaceAroundStep(start, end, gapStart, gapEnd, new Slice(before.append(after), openStart, openEnd), before.size - openStart, true));
-}
-function wrap(tr, range, wrappers) {
-    let content = Fragment.empty;
-    for (let i = wrappers.length - 1; i >= 0; i--) {
-        if (content.size) {
-            let match = wrappers[i].type.contentMatch.matchFragment(content);
-            if (!match || !match.validEnd)
-                throw new RangeError("Wrapper type given to Transform.wrap does not form valid content of its parent wrapper");
-        }
-        content = Fragment.from(wrappers[i].type.create(wrappers[i].attrs, content));
-    }
-    let start = range.start, end = range.end;
-    tr.step(new ReplaceAroundStep(start, end, start, end, new Slice(content, 0, 0), wrappers.length, true));
-}
-function setBlockType(tr, from, to, type, attrs) {
-    if (!type.isTextblock)
-        throw new RangeError("Type given to setBlockType should be a textblock");
-    let mapFrom = tr.steps.length;
-    tr.doc.nodesBetween(from, to, (node, pos) => {
-        if (node.isTextblock && !node.hasMarkup(type, attrs) && canChangeType(tr.doc, tr.mapping.slice(mapFrom).map(pos), type)) {
-            // Ensure all markup that isn't allowed in the new node type is cleared
-            tr.clearIncompatible(tr.mapping.slice(mapFrom).map(pos, 1), type);
-            let mapping = tr.mapping.slice(mapFrom);
-            let startM = mapping.map(pos, 1), endM = mapping.map(pos + node.nodeSize, 1);
-            tr.step(new ReplaceAroundStep(startM, endM, startM + 1, endM - 1, new Slice(Fragment.from(type.create(attrs, null, node.marks)), 0, 0), 1, true));
-            return false;
-        }
-    });
-}
-function canChangeType(doc, pos, type) {
-    let $pos = doc.resolve(pos), index = $pos.index();
-    return $pos.parent.canReplaceWith(index, index + 1, type);
-}
-/**
-Change the type, attributes, and/or marks of the node at `pos`.
-When `type` isn't given, the existing node type is preserved,
-*/
-function setNodeMarkup(tr, pos, type, attrs, marks) {
-    let node = tr.doc.nodeAt(pos);
-    if (!node)
-        throw new RangeError("No node at given position");
-    if (!type)
-        type = node.type;
-    let newNode = type.create(attrs, null, marks || node.marks);
-    if (node.isLeaf)
-        return tr.replaceWith(pos, pos + node.nodeSize, newNode);
-    if (!type.validContent(node.content))
-        throw new RangeError("Invalid content for node type " + type.name);
-    tr.step(new ReplaceAroundStep(pos, pos + node.nodeSize, pos + 1, pos + node.nodeSize - 1, new Slice(Fragment.from(newNode), 0, 0), 1, true));
-}
-function split(tr, pos, depth = 1, typesAfter) {
-    let $pos = tr.doc.resolve(pos), before = Fragment.empty, after = Fragment.empty;
-    for (let d = $pos.depth, e = $pos.depth - depth, i = depth - 1; d > e; d--, i--) {
-        before = Fragment.from($pos.node(d).copy(before));
-        let typeAfter = typesAfter && typesAfter[i];
-        after = Fragment.from(typeAfter ? typeAfter.type.create(typeAfter.attrs, after) : $pos.node(d).copy(after));
-    }
-    tr.step(new ReplaceStep(pos, pos, new Slice(before.append(after), depth, depth), true));
-}
-function join(tr, pos, depth) {
-    let step = new ReplaceStep(pos - depth, pos + depth, Slice.empty, true);
-    tr.step(step);
-}
-/**
-Try to find a point where a node of the given type can be inserted
-near `pos`, by searching up the node hierarchy when `pos` itself
-isn't a valid place but is at the start or end of a node. Return
-null if no position was found.
-*/
-function insertPoint(doc, pos, nodeType) {
-    let $pos = doc.resolve(pos);
-    if ($pos.parent.canReplaceWith($pos.index(), $pos.index(), nodeType))
-        return pos;
-    if ($pos.parentOffset == 0)
-        for (let d = $pos.depth - 1; d >= 0; d--) {
-            let index = $pos.index(d);
-            if ($pos.node(d).canReplaceWith(index, index, nodeType))
-                return $pos.before(d + 1);
-            if (index > 0)
-                return null;
-        }
-    if ($pos.parentOffset == $pos.parent.content.size)
-        for (let d = $pos.depth - 1; d >= 0; d--) {
-            let index = $pos.indexAfter(d);
-            if ($pos.node(d).canReplaceWith(index, index, nodeType))
-                return $pos.after(d + 1);
-            if (index < $pos.node(d).childCount)
-                return null;
-        }
-    return null;
-}
-
-/**
-‘Fit’ a slice into a given position in the document, producing a
-[step](https://prosemirror.net/docs/ref/#transform.Step) that inserts it. Will return null if
-there's no meaningful way to insert the slice here, or inserting it
-would be a no-op (an empty slice over an empty range).
-*/
-function replaceStep(doc, from, to = from, slice = Slice.empty) {
-    if (from == to && !slice.size)
-        return null;
-    let $from = doc.resolve(from), $to = doc.resolve(to);
-    // Optimization -- avoid work if it's obvious that it's not needed.
-    if (fitsTrivially($from, $to, slice))
-        return new ReplaceStep(from, to, slice);
-    return new Fitter($from, $to, slice).fit();
-}
-function fitsTrivially($from, $to, slice) {
-    return !slice.openStart && !slice.openEnd && $from.start() == $to.start() &&
-        $from.parent.canReplace($from.index(), $to.index(), slice.content);
-}
-// Algorithm for 'placing' the elements of a slice into a gap:
-//
-// We consider the content of each node that is open to the left to be
-// independently placeable. I.e. in <p("foo"), p("bar")>, when the
-// paragraph on the left is open, "foo" can be placed (somewhere on
-// the left side of the replacement gap) independently from p("bar").
-//
-// This class tracks the state of the placement progress in the
-// following properties:
-//
-//  - `frontier` holds a stack of `{type, match}` objects that
-//    represent the open side of the replacement. It starts at
-//    `$from`, then moves forward as content is placed, and is finally
-//    reconciled with `$to`.
-//
-//  - `unplaced` is a slice that represents the content that hasn't
-//    been placed yet.
-//
-//  - `placed` is a fragment of placed content. Its open-start value
-//    is implicit in `$from`, and its open-end value in `frontier`.
-class Fitter {
-    constructor($from, $to, unplaced) {
-        this.$from = $from;
-        this.$to = $to;
-        this.unplaced = unplaced;
-        this.frontier = [];
-        this.placed = Fragment.empty;
-        for (let i = 0; i <= $from.depth; i++) {
-            let node = $from.node(i);
-            this.frontier.push({
-                type: node.type,
-                match: node.contentMatchAt($from.indexAfter(i))
-            });
-        }
-        for (let i = $from.depth; i > 0; i--)
-            this.placed = Fragment.from($from.node(i).copy(this.placed));
-    }
-    get depth() { return this.frontier.length - 1; }
-    fit() {
-        // As long as there's unplaced content, try to place some of it.
-        // If that fails, either increase the open score of the unplaced
-        // slice, or drop nodes from it, and then try again.
-        while (this.unplaced.size) {
-            let fit = this.findFittable();
-            if (fit)
-                this.placeNodes(fit);
-            else
-                this.openMore() || this.dropNode();
-        }
-        // When there's inline content directly after the frontier _and_
-        // directly after `this.$to`, we must generate a `ReplaceAround`
-        // step that pulls that content into the node after the frontier.
-        // That means the fitting must be done to the end of the textblock
-        // node after `this.$to`, not `this.$to` itself.
-        let moveInline = this.mustMoveInline(), placedSize = this.placed.size - this.depth - this.$from.depth;
-        let $from = this.$from, $to = this.close(moveInline < 0 ? this.$to : $from.doc.resolve(moveInline));
-        if (!$to)
-            return null;
-        // If closing to `$to` succeeded, create a step
-        let content = this.placed, openStart = $from.depth, openEnd = $to.depth;
-        while (openStart && openEnd && content.childCount == 1) { // Normalize by dropping open parent nodes
-            content = content.firstChild.content;
-            openStart--;
-            openEnd--;
-        }
-        let slice = new Slice(content, openStart, openEnd);
-        if (moveInline > -1)
-            return new ReplaceAroundStep($from.pos, moveInline, this.$to.pos, this.$to.end(), slice, placedSize);
-        if (slice.size || $from.pos != this.$to.pos) // Don't generate no-op steps
-            return new ReplaceStep($from.pos, $to.pos, slice);
-        return null;
-    }
-    // Find a position on the start spine of `this.unplaced` that has
-    // content that can be moved somewhere on the frontier. Returns two
-    // depths, one for the slice and one for the frontier.
-    findFittable() {
-        // Only try wrapping nodes (pass 2) after finding a place without
-        // wrapping failed.
-        for (let pass = 1; pass <= 2; pass++) {
-            for (let sliceDepth = this.unplaced.openStart; sliceDepth >= 0; sliceDepth--) {
-                let fragment, parent = null;
-                if (sliceDepth) {
-                    parent = contentAt(this.unplaced.content, sliceDepth - 1).firstChild;
-                    fragment = parent.content;
-                }
-                else {
-                    fragment = this.unplaced.content;
-                }
-                let first = fragment.firstChild;
-                for (let frontierDepth = this.depth; frontierDepth >= 0; frontierDepth--) {
-                    let { type, match } = this.frontier[frontierDepth], wrap, inject = null;
-                    // In pass 1, if the next node matches, or there is no next
-                    // node but the parents look compatible, we've found a
-                    // place.
-                    if (pass == 1 && (first ? match.matchType(first.type) || (inject = match.fillBefore(Fragment.from(first), false))
-                        : parent && type.compatibleContent(parent.type)))
-                        return { sliceDepth, frontierDepth, parent, inject };
-                    // In pass 2, look for a set of wrapping nodes that make
-                    // `first` fit here.
-                    else if (pass == 2 && first && (wrap = match.findWrapping(first.type)))
-                        return { sliceDepth, frontierDepth, parent, wrap };
-                    // Don't continue looking further up if the parent node
-                    // would fit here.
-                    if (parent && match.matchType(parent.type))
-                        break;
-                }
-            }
-        }
-    }
-    openMore() {
-        let { content, openStart, openEnd } = this.unplaced;
-        let inner = contentAt(content, openStart);
-        if (!inner.childCount || inner.firstChild.isLeaf)
-            return false;
-        this.unplaced = new Slice(content, openStart + 1, Math.max(openEnd, inner.size + openStart >= content.size - openEnd ? openStart + 1 : 0));
-        return true;
-    }
-    dropNode() {
-        let { content, openStart, openEnd } = this.unplaced;
-        let inner = contentAt(content, openStart);
-        if (inner.childCount <= 1 && openStart > 0) {
-            let openAtEnd = content.size - openStart <= openStart + inner.size;
-            this.unplaced = new Slice(dropFromFragment(content, openStart - 1, 1), openStart - 1, openAtEnd ? openStart - 1 : openEnd);
-        }
-        else {
-            this.unplaced = new Slice(dropFromFragment(content, openStart, 1), openStart, openEnd);
-        }
-    }
-    // Move content from the unplaced slice at `sliceDepth` to the
-    // frontier node at `frontierDepth`. Close that frontier node when
-    // applicable.
-    placeNodes({ sliceDepth, frontierDepth, parent, inject, wrap }) {
-        while (this.depth > frontierDepth)
-            this.closeFrontierNode();
-        if (wrap)
-            for (let i = 0; i < wrap.length; i++)
-                this.openFrontierNode(wrap[i]);
-        let slice = this.unplaced, fragment = parent ? parent.content : slice.content;
-        let openStart = slice.openStart - sliceDepth;
-        let taken = 0, add = [];
-        let { match, type } = this.frontier[frontierDepth];
-        if (inject) {
-            for (let i = 0; i < inject.childCount; i++)
-                add.push(inject.child(i));
-            match = match.matchFragment(inject);
-        }
-        // Computes the amount of (end) open nodes at the end of the
-        // fragment. When 0, the parent is open, but no more. When
-        // negative, nothing is open.
-        let openEndCount = (fragment.size + sliceDepth) - (slice.content.size - slice.openEnd);
-        // Scan over the fragment, fitting as many child nodes as
-        // possible.
-        while (taken < fragment.childCount) {
-            let next = fragment.child(taken), matches = match.matchType(next.type);
-            if (!matches)
-                break;
-            taken++;
-            if (taken > 1 || openStart == 0 || next.content.size) { // Drop empty open nodes
-                match = matches;
-                add.push(closeNodeStart(next.mark(type.allowedMarks(next.marks)), taken == 1 ? openStart : 0, taken == fragment.childCount ? openEndCount : -1));
-            }
-        }
-        let toEnd = taken == fragment.childCount;
-        if (!toEnd)
-            openEndCount = -1;
-        this.placed = addToFragment(this.placed, frontierDepth, Fragment.from(add));
-        this.frontier[frontierDepth].match = match;
-        // If the parent types match, and the entire node was moved, and
-        // it's not open, close this frontier node right away.
-        if (toEnd && openEndCount < 0 && parent && parent.type == this.frontier[this.depth].type && this.frontier.length > 1)
-            this.closeFrontierNode();
-        // Add new frontier nodes for any open nodes at the end.
-        for (let i = 0, cur = fragment; i < openEndCount; i++) {
-            let node = cur.lastChild;
-            this.frontier.push({ type: node.type, match: node.contentMatchAt(node.childCount) });
-            cur = node.content;
-        }
-        // Update `this.unplaced`. Drop the entire node from which we
-        // placed it we got to its end, otherwise just drop the placed
-        // nodes.
-        this.unplaced = !toEnd ? new Slice(dropFromFragment(slice.content, sliceDepth, taken), slice.openStart, slice.openEnd)
-            : sliceDepth == 0 ? Slice.empty
-                : new Slice(dropFromFragment(slice.content, sliceDepth - 1, 1), sliceDepth - 1, openEndCount < 0 ? slice.openEnd : sliceDepth - 1);
-    }
-    mustMoveInline() {
-        if (!this.$to.parent.isTextblock)
-            return -1;
-        let top = this.frontier[this.depth], level;
-        if (!top.type.isTextblock || !contentAfterFits(this.$to, this.$to.depth, top.type, top.match, false) ||
-            (this.$to.depth == this.depth && (level = this.findCloseLevel(this.$to)) && level.depth == this.depth))
-            return -1;
-        let { depth } = this.$to, after = this.$to.after(depth);
-        while (depth > 1 && after == this.$to.end(--depth))
-            ++after;
-        return after;
-    }
-    findCloseLevel($to) {
-        scan: for (let i = Math.min(this.depth, $to.depth); i >= 0; i--) {
-            let { match, type } = this.frontier[i];
-            let dropInner = i < $to.depth && $to.end(i + 1) == $to.pos + ($to.depth - (i + 1));
-            let fit = contentAfterFits($to, i, type, match, dropInner);
-            if (!fit)
-                continue;
-            for (let d = i - 1; d >= 0; d--) {
-                let { match, type } = this.frontier[d];
-                let matches = contentAfterFits($to, d, type, match, true);
-                if (!matches || matches.childCount)
-                    continue scan;
-            }
-            return { depth: i, fit, move: dropInner ? $to.doc.resolve($to.after(i + 1)) : $to };
-        }
-    }
-    close($to) {
-        let close = this.findCloseLevel($to);
-        if (!close)
-            return null;
-        while (this.depth > close.depth)
-            this.closeFrontierNode();
-        if (close.fit.childCount)
-            this.placed = addToFragment(this.placed, close.depth, close.fit);
-        $to = close.move;
-        for (let d = close.depth + 1; d <= $to.depth; d++) {
-            let node = $to.node(d), add = node.type.contentMatch.fillBefore(node.content, true, $to.index(d));
-            this.openFrontierNode(node.type, node.attrs, add);
-        }
-        return $to;
-    }
-    openFrontierNode(type, attrs = null, content) {
-        let top = this.frontier[this.depth];
-        top.match = top.match.matchType(type);
-        this.placed = addToFragment(this.placed, this.depth, Fragment.from(type.create(attrs, content)));
-        this.frontier.push({ type, match: type.contentMatch });
-    }
-    closeFrontierNode() {
-        let open = this.frontier.pop();
-        let add = open.match.fillBefore(Fragment.empty, true);
-        if (add.childCount)
-            this.placed = addToFragment(this.placed, this.frontier.length, add);
-    }
-}
-function dropFromFragment(fragment, depth, count) {
-    if (depth == 0)
-        return fragment.cutByIndex(count, fragment.childCount);
-    return fragment.replaceChild(0, fragment.firstChild.copy(dropFromFragment(fragment.firstChild.content, depth - 1, count)));
-}
-function addToFragment(fragment, depth, content) {
-    if (depth == 0)
-        return fragment.append(content);
-    return fragment.replaceChild(fragment.childCount - 1, fragment.lastChild.copy(addToFragment(fragment.lastChild.content, depth - 1, content)));
-}
-function contentAt(fragment, depth) {
-    for (let i = 0; i < depth; i++)
-        fragment = fragment.firstChild.content;
-    return fragment;
-}
-function closeNodeStart(node, openStart, openEnd) {
-    if (openStart <= 0)
-        return node;
-    let frag = node.content;
-    if (openStart > 1)
-        frag = frag.replaceChild(0, closeNodeStart(frag.firstChild, openStart - 1, frag.childCount == 1 ? openEnd - 1 : 0));
-    if (openStart > 0) {
-        frag = node.type.contentMatch.fillBefore(frag).append(frag);
-        if (openEnd <= 0)
-            frag = frag.append(node.type.contentMatch.matchFragment(frag).fillBefore(Fragment.empty, true));
-    }
-    return node.copy(frag);
-}
-function contentAfterFits($to, depth, type, match, open) {
-    let node = $to.node(depth), index = open ? $to.indexAfter(depth) : $to.index(depth);
-    if (index == node.childCount && !type.compatibleContent(node.type))
-        return null;
-    let fit = match.fillBefore(node.content, true, index);
-    return fit && !invalidMarks(type, node.content, index) ? fit : null;
-}
-function invalidMarks(type, fragment, start) {
-    for (let i = start; i < fragment.childCount; i++)
-        if (!type.allowsMarks(fragment.child(i).marks))
-            return true;
-    return false;
-}
-function definesContent(type) {
-    return type.spec.defining || type.spec.definingForContent;
-}
-function replaceRange(tr, from, to, slice) {
-    if (!slice.size)
-        return tr.deleteRange(from, to);
-    let $from = tr.doc.resolve(from), $to = tr.doc.resolve(to);
-    if (fitsTrivially($from, $to, slice))
-        return tr.step(new ReplaceStep(from, to, slice));
-    let targetDepths = coveredDepths($from, tr.doc.resolve(to));
-    // Can't replace the whole document, so remove 0 if it's present
-    if (targetDepths[targetDepths.length - 1] == 0)
-        targetDepths.pop();
-    // Negative numbers represent not expansion over the whole node at
-    // that depth, but replacing from $from.before(-D) to $to.pos.
-    let preferredTarget = -($from.depth + 1);
-    targetDepths.unshift(preferredTarget);
-    // This loop picks a preferred target depth, if one of the covering
-    // depths is not outside of a defining node, and adds negative
-    // depths for any depth that has $from at its start and does not
-    // cross a defining node.
-    for (let d = $from.depth, pos = $from.pos - 1; d > 0; d--, pos--) {
-        let spec = $from.node(d).type.spec;
-        if (spec.defining || spec.definingAsContext || spec.isolating)
-            break;
-        if (targetDepths.indexOf(d) > -1)
-            preferredTarget = d;
-        else if ($from.before(d) == pos)
-            targetDepths.splice(1, 0, -d);
-    }
-    // Try to fit each possible depth of the slice into each possible
-    // target depth, starting with the preferred depths.
-    let preferredTargetIndex = targetDepths.indexOf(preferredTarget);
-    let leftNodes = [], preferredDepth = slice.openStart;
-    for (let content = slice.content, i = 0;; i++) {
-        let node = content.firstChild;
-        leftNodes.push(node);
-        if (i == slice.openStart)
-            break;
-        content = node.content;
-    }
-    // Back up preferredDepth to cover defining textblocks directly
-    // above it, possibly skipping a non-defining textblock.
-    for (let d = preferredDepth - 1; d >= 0; d--) {
-        let type = leftNodes[d].type, def = definesContent(type);
-        if (def && $from.node(preferredTargetIndex).type != type)
-            preferredDepth = d;
-        else if (def || !type.isTextblock)
-            break;
-    }
-    for (let j = slice.openStart; j >= 0; j--) {
-        let openDepth = (j + preferredDepth + 1) % (slice.openStart + 1);
-        let insert = leftNodes[openDepth];
-        if (!insert)
-            continue;
-        for (let i = 0; i < targetDepths.length; i++) {
-            // Loop over possible expansion levels, starting with the
-            // preferred one
-            let targetDepth = targetDepths[(i + preferredTargetIndex) % targetDepths.length], expand = true;
-            if (targetDepth < 0) {
-                expand = false;
-                targetDepth = -targetDepth;
-            }
-            let parent = $from.node(targetDepth - 1), index = $from.index(targetDepth - 1);
-            if (parent.canReplaceWith(index, index, insert.type, insert.marks))
-                return tr.replace($from.before(targetDepth), expand ? $to.after(targetDepth) : to, new Slice(closeFragment(slice.content, 0, slice.openStart, openDepth), openDepth, slice.openEnd));
-        }
-    }
-    let startSteps = tr.steps.length;
-    for (let i = targetDepths.length - 1; i >= 0; i--) {
-        tr.replace(from, to, slice);
-        if (tr.steps.length > startSteps)
-            break;
-        let depth = targetDepths[i];
-        if (depth < 0)
-            continue;
-        from = $from.before(depth);
-        to = $to.after(depth);
-    }
-}
-function closeFragment(fragment, depth, oldOpen, newOpen, parent) {
-    if (depth < oldOpen) {
-        let first = fragment.firstChild;
-        fragment = fragment.replaceChild(0, first.copy(closeFragment(first.content, depth + 1, oldOpen, newOpen, first)));
-    }
-    if (depth > newOpen) {
-        let match = parent.contentMatchAt(0);
-        let start = match.fillBefore(fragment).append(fragment);
-        fragment = start.append(match.matchFragment(start).fillBefore(Fragment.empty, true));
-    }
-    return fragment;
-}
-function replaceRangeWith(tr, from, to, node) {
-    if (!node.isInline && from == to && tr.doc.resolve(from).parent.content.size) {
-        let point = insertPoint(tr.doc, from, node.type);
-        if (point != null)
-            from = to = point;
-    }
-    tr.replaceRange(from, to, new Slice(Fragment.from(node), 0, 0));
-}
-function deleteRange(tr, from, to) {
-    let $from = tr.doc.resolve(from), $to = tr.doc.resolve(to);
-    let covered = coveredDepths($from, $to);
-    for (let i = 0; i < covered.length; i++) {
-        let depth = covered[i], last = i == covered.length - 1;
-        if ((last && depth == 0) || $from.node(depth).type.contentMatch.validEnd)
-            return tr.delete($from.start(depth), $to.end(depth));
-        if (depth > 0 && (last || $from.node(depth - 1).canReplace($from.index(depth - 1), $to.indexAfter(depth - 1))))
-            return tr.delete($from.before(depth), $to.after(depth));
-    }
-    for (let d = 1; d <= $from.depth && d <= $to.depth; d++) {
-        if (from - $from.start(d) == $from.depth - d && to > $from.end(d) && $to.end(d) - to != $to.depth - d)
-            return tr.delete($from.before(d), to);
-    }
-    tr.delete(from, to);
-}
-// Returns an array of all depths for which $from - $to spans the
-// whole content of the nodes at that depth.
-function coveredDepths($from, $to) {
-    let result = [], minDepth = Math.min($from.depth, $to.depth);
-    for (let d = minDepth; d >= 0; d--) {
-        let start = $from.start(d);
-        if (start < $from.pos - ($from.depth - d) ||
-            $to.end(d) > $to.pos + ($to.depth - d) ||
-            $from.node(d).type.spec.isolating ||
-            $to.node(d).type.spec.isolating)
-            break;
-        if (start == $to.start(d) ||
-            (d == $from.depth && d == $to.depth && $from.parent.inlineContent && $to.parent.inlineContent &&
-                d && $to.start(d - 1) == start - 1))
-            result.push(d);
-    }
-    return result;
-}
-
-/**
-Update an attribute in a specific node.
-*/
-class AttrStep extends Step {
-    /**
-    Construct an attribute step.
-    */
-    constructor(
-    /**
-    The position of the target node.
-    */
-    pos, 
-    /**
-    The attribute to set.
-    */
-    attr, 
-    // The attribute's new value.
-    value) {
-        super();
-        this.pos = pos;
-        this.attr = attr;
-        this.value = value;
-    }
-    apply(doc) {
-        let node = doc.nodeAt(this.pos);
-        if (!node)
-            return StepResult.fail("No node at attribute step's position");
-        let attrs = Object.create(null);
-        for (let name in node.attrs)
-            attrs[name] = node.attrs[name];
-        attrs[this.attr] = this.value;
-        let updated = node.type.create(attrs, null, node.marks);
-        return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
-    }
-    getMap() {
-        return StepMap.empty;
-    }
-    invert(doc) {
-        return new AttrStep(this.pos, this.attr, doc.nodeAt(this.pos).attrs[this.attr]);
-    }
-    map(mapping) {
-        let pos = mapping.mapResult(this.pos, 1);
-        return pos.deletedAfter ? null : new AttrStep(pos.pos, this.attr, this.value);
-    }
-    toJSON() {
-        return { stepType: "attr", pos: this.pos, attr: this.attr, value: this.value };
-    }
-    static fromJSON(schema, json) {
-        if (typeof json.pos != "number" || typeof json.attr != "string")
-            throw new RangeError("Invalid input for AttrStep.fromJSON");
-        return new AttrStep(json.pos, json.attr, json.value);
-    }
-}
-Step.jsonID("attr", AttrStep);
-
-/**
-@internal
-*/
-let TransformError = class extends Error {
-};
-TransformError = function TransformError(message) {
-    let err = Error.call(this, message);
-    err.__proto__ = TransformError.prototype;
-    return err;
-};
-TransformError.prototype = Object.create(Error.prototype);
-TransformError.prototype.constructor = TransformError;
-TransformError.prototype.name = "TransformError";
-/**
-Abstraction to build up and track an array of
-[steps](https://prosemirror.net/docs/ref/#transform.Step) representing a document transformation.
-
-Most transforming methods return the `Transform` object itself, so
-that they can be chained.
-*/
-class Transform {
-    /**
-    Create a transform that starts with the given document.
-    */
-    constructor(
-    /**
-    The current document (the result of applying the steps in the
-    transform).
-    */
-    doc) {
-        this.doc = doc;
-        /**
-        The steps in this transform.
-        */
-        this.steps = [];
-        /**
-        The documents before each of the steps.
-        */
-        this.docs = [];
-        /**
-        A mapping with the maps for each of the steps in this transform.
-        */
-        this.mapping = new Mapping;
-    }
-    /**
-    The starting document.
-    */
-    get before() { return this.docs.length ? this.docs[0] : this.doc; }
-    /**
-    Apply a new step in this transform, saving the result. Throws an
-    error when the step fails.
-    */
-    step(step) {
-        let result = this.maybeStep(step);
-        if (result.failed)
-            throw new TransformError(result.failed);
-        return this;
-    }
-    /**
-    Try to apply a step in this transformation, ignoring it if it
-    fails. Returns the step result.
-    */
-    maybeStep(step) {
-        let result = step.apply(this.doc);
-        if (!result.failed)
-            this.addStep(step, result.doc);
-        return result;
-    }
-    /**
-    True when the document has been changed (when there are any
-    steps).
-    */
-    get docChanged() {
-        return this.steps.length > 0;
-    }
-    /**
-    @internal
-    */
-    addStep(step, doc) {
-        this.docs.push(this.doc);
-        this.steps.push(step);
-        this.mapping.appendMap(step.getMap());
-        this.doc = doc;
-    }
-    /**
-    Replace the part of the document between `from` and `to` with the
-    given `slice`.
-    */
-    replace(from, to = from, slice = Slice.empty) {
-        let step = replaceStep(this.doc, from, to, slice);
-        if (step)
-            this.step(step);
-        return this;
-    }
-    /**
-    Replace the given range with the given content, which may be a
-    fragment, node, or array of nodes.
-    */
-    replaceWith(from, to, content) {
-        return this.replace(from, to, new Slice(Fragment.from(content), 0, 0));
-    }
-    /**
-    Delete the content between the given positions.
-    */
-    delete(from, to) {
-        return this.replace(from, to, Slice.empty);
-    }
-    /**
-    Insert the given content at the given position.
-    */
-    insert(pos, content) {
-        return this.replaceWith(pos, pos, content);
-    }
-    /**
-    Replace a range of the document with a given slice, using
-    `from`, `to`, and the slice's
-    [`openStart`](https://prosemirror.net/docs/ref/#model.Slice.openStart) property as hints, rather
-    than fixed start and end points. This method may grow the
-    replaced area or close open nodes in the slice in order to get a
-    fit that is more in line with WYSIWYG expectations, by dropping
-    fully covered parent nodes of the replaced region when they are
-    marked [non-defining as
-    context](https://prosemirror.net/docs/ref/#model.NodeSpec.definingAsContext), or including an
-    open parent node from the slice that _is_ marked as [defining
-    its content](https://prosemirror.net/docs/ref/#model.NodeSpec.definingForContent).
-    
-    This is the method, for example, to handle paste. The similar
-    [`replace`](https://prosemirror.net/docs/ref/#transform.Transform.replace) method is a more
-    primitive tool which will _not_ move the start and end of its given
-    range, and is useful in situations where you need more precise
-    control over what happens.
-    */
-    replaceRange(from, to, slice) {
-        replaceRange(this, from, to, slice);
-        return this;
-    }
-    /**
-    Replace the given range with a node, but use `from` and `to` as
-    hints, rather than precise positions. When from and to are the same
-    and are at the start or end of a parent node in which the given
-    node doesn't fit, this method may _move_ them out towards a parent
-    that does allow the given node to be placed. When the given range
-    completely covers a parent node, this method may completely replace
-    that parent node.
-    */
-    replaceRangeWith(from, to, node) {
-        replaceRangeWith(this, from, to, node);
-        return this;
-    }
-    /**
-    Delete the given range, expanding it to cover fully covered
-    parent nodes until a valid replace is found.
-    */
-    deleteRange(from, to) {
-        deleteRange(this, from, to);
-        return this;
-    }
-    /**
-    Split the content in the given range off from its parent, if there
-    is sibling content before or after it, and move it up the tree to
-    the depth specified by `target`. You'll probably want to use
-    [`liftTarget`](https://prosemirror.net/docs/ref/#transform.liftTarget) to compute `target`, to make
-    sure the lift is valid.
-    */
-    lift(range, target) {
-        lift(this, range, target);
-        return this;
-    }
-    /**
-    Join the blocks around the given position. If depth is 2, their
-    last and first siblings are also joined, and so on.
-    */
-    join(pos, depth = 1) {
-        join(this, pos, depth);
-        return this;
-    }
-    /**
-    Wrap the given [range](https://prosemirror.net/docs/ref/#model.NodeRange) in the given set of wrappers.
-    The wrappers are assumed to be valid in this position, and should
-    probably be computed with [`findWrapping`](https://prosemirror.net/docs/ref/#transform.findWrapping).
-    */
-    wrap(range, wrappers) {
-        wrap(this, range, wrappers);
-        return this;
-    }
-    /**
-    Set the type of all textblocks (partly) between `from` and `to` to
-    the given node type with the given attributes.
-    */
-    setBlockType(from, to = from, type, attrs = null) {
-        setBlockType(this, from, to, type, attrs);
-        return this;
-    }
-    /**
-    Change the type, attributes, and/or marks of the node at `pos`.
-    When `type` isn't given, the existing node type is preserved,
-    */
-    setNodeMarkup(pos, type, attrs = null, marks = []) {
-        setNodeMarkup(this, pos, type, attrs, marks);
-        return this;
-    }
-    /**
-    Set a single attribute on a given node to a new value.
-    */
-    setNodeAttribute(pos, attr, value) {
-        this.step(new AttrStep(pos, attr, value));
-        return this;
-    }
-    /**
-    Add a mark to the node at position `pos`.
-    */
-    addNodeMark(pos, mark) {
-        this.step(new AddNodeMarkStep(pos, mark));
-        return this;
-    }
-    /**
-    Remove a mark (or a mark of the given type) from the node at
-    position `pos`.
-    */
-    removeNodeMark(pos, mark) {
-        if (!(mark instanceof Mark)) {
-            let node = this.doc.nodeAt(pos);
-            if (!node)
-                throw new RangeError("No node at position " + pos);
-            mark = mark.isInSet(node.marks);
-            if (!mark)
-                return this;
-        }
-        this.step(new RemoveNodeMarkStep(pos, mark));
-        return this;
-    }
-    /**
-    Split the node at the given position, and optionally, if `depth` is
-    greater than one, any number of nodes above that. By default, the
-    parts split off will inherit the node type of the original node.
-    This can be changed by passing an array of types and attributes to
-    use after the split.
-    */
-    split(pos, depth = 1, typesAfter) {
-        split(this, pos, depth, typesAfter);
-        return this;
-    }
-    /**
-    Add the given mark to the inline content between `from` and `to`.
-    */
-    addMark(from, to, mark) {
-        addMark(this, from, to, mark);
-        return this;
-    }
-    /**
-    Remove marks from inline nodes between `from` and `to`. When
-    `mark` is a single mark, remove precisely that mark. When it is
-    a mark type, remove all marks of that type. When it is null,
-    remove all marks of any type.
-    */
-    removeMark(from, to, mark) {
-        removeMark(this, from, to, mark);
-        return this;
-    }
-    /**
-    Removes all marks and nodes from the content of the node at
-    `pos` that don't match the given new parent node type. Accepts
-    an optional starting [content match](https://prosemirror.net/docs/ref/#model.ContentMatch) as
-    third argument.
-    */
-    clearIncompatible(pos, parentType, match) {
-        clearIncompatible(this, pos, parentType, match);
-        return this;
-    }
-}
-
-const classesById = Object.create(null);
-/**
-Superclass for editor selections. Every selection type should
-extend this. Should not be instantiated directly.
-*/
-class Selection {
-    /**
-    Initialize a selection with the head and anchor and ranges. If no
-    ranges are given, constructs a single range across `$anchor` and
-    `$head`.
-    */
-    constructor(
-    /**
-    The resolved anchor of the selection (the side that stays in
-    place when the selection is modified).
-    */
-    $anchor, 
-    /**
-    The resolved head of the selection (the side that moves when
-    the selection is modified).
-    */
-    $head, ranges) {
-        this.$anchor = $anchor;
-        this.$head = $head;
-        this.ranges = ranges || [new SelectionRange($anchor.min($head), $anchor.max($head))];
-    }
-    /**
-    The selection's anchor, as an unresolved position.
-    */
-    get anchor() { return this.$anchor.pos; }
-    /**
-    The selection's head.
-    */
-    get head() { return this.$head.pos; }
-    /**
-    The lower bound of the selection's main range.
-    */
-    get from() { return this.$from.pos; }
-    /**
-    The upper bound of the selection's main range.
-    */
-    get to() { return this.$to.pos; }
-    /**
-    The resolved lower  bound of the selection's main range.
-    */
-    get $from() {
-        return this.ranges[0].$from;
-    }
-    /**
-    The resolved upper bound of the selection's main range.
-    */
-    get $to() {
-        return this.ranges[0].$to;
-    }
-    /**
-    Indicates whether the selection contains any content.
-    */
-    get empty() {
-        let ranges = this.ranges;
-        for (let i = 0; i < ranges.length; i++)
-            if (ranges[i].$from.pos != ranges[i].$to.pos)
-                return false;
-        return true;
-    }
-    /**
-    Get the content of this selection as a slice.
-    */
-    content() {
-        return this.$from.doc.slice(this.from, this.to, true);
-    }
-    /**
-    Replace the selection with a slice or, if no slice is given,
-    delete the selection. Will append to the given transaction.
-    */
-    replace(tr, content = Slice.empty) {
-        // Put the new selection at the position after the inserted
-        // content. When that ended in an inline node, search backwards,
-        // to get the position after that node. If not, search forward.
-        let lastNode = content.content.lastChild, lastParent = null;
-        for (let i = 0; i < content.openEnd; i++) {
-            lastParent = lastNode;
-            lastNode = lastNode.lastChild;
-        }
-        let mapFrom = tr.steps.length, ranges = this.ranges;
-        for (let i = 0; i < ranges.length; i++) {
-            let { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);
-            tr.replaceRange(mapping.map($from.pos), mapping.map($to.pos), i ? Slice.empty : content);
-            if (i == 0)
-                selectionToInsertionEnd(tr, mapFrom, (lastNode ? lastNode.isInline : lastParent && lastParent.isTextblock) ? -1 : 1);
-        }
-    }
-    /**
-    Replace the selection with the given node, appending the changes
-    to the given transaction.
-    */
-    replaceWith(tr, node) {
-        let mapFrom = tr.steps.length, ranges = this.ranges;
-        for (let i = 0; i < ranges.length; i++) {
-            let { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);
-            let from = mapping.map($from.pos), to = mapping.map($to.pos);
-            if (i) {
-                tr.deleteRange(from, to);
-            }
-            else {
-                tr.replaceRangeWith(from, to, node);
-                selectionToInsertionEnd(tr, mapFrom, node.isInline ? -1 : 1);
-            }
-        }
-    }
-    /**
-    Find a valid cursor or leaf node selection starting at the given
-    position and searching back if `dir` is negative, and forward if
-    positive. When `textOnly` is true, only consider cursor
-    selections. Will return null when no valid selection position is
-    found.
-    */
-    static findFrom($pos, dir, textOnly = false) {
-        let inner = $pos.parent.inlineContent ? new TextSelection($pos)
-            : findSelectionIn($pos.node(0), $pos.parent, $pos.pos, $pos.index(), dir, textOnly);
-        if (inner)
-            return inner;
-        for (let depth = $pos.depth - 1; depth >= 0; depth--) {
-            let found = dir < 0
-                ? findSelectionIn($pos.node(0), $pos.node(depth), $pos.before(depth + 1), $pos.index(depth), dir, textOnly)
-                : findSelectionIn($pos.node(0), $pos.node(depth), $pos.after(depth + 1), $pos.index(depth) + 1, dir, textOnly);
-            if (found)
-                return found;
-        }
-        return null;
-    }
-    /**
-    Find a valid cursor or leaf node selection near the given
-    position. Searches forward first by default, but if `bias` is
-    negative, it will search backwards first.
-    */
-    static near($pos, bias = 1) {
-        return this.findFrom($pos, bias) || this.findFrom($pos, -bias) || new AllSelection($pos.node(0));
-    }
-    /**
-    Find the cursor or leaf node selection closest to the start of
-    the given document. Will return an
-    [`AllSelection`](https://prosemirror.net/docs/ref/#state.AllSelection) if no valid position
-    exists.
-    */
-    static atStart(doc) {
-        return findSelectionIn(doc, doc, 0, 0, 1) || new AllSelection(doc);
-    }
-    /**
-    Find the cursor or leaf node selection closest to the end of the
-    given document.
-    */
-    static atEnd(doc) {
-        return findSelectionIn(doc, doc, doc.content.size, doc.childCount, -1) || new AllSelection(doc);
-    }
-    /**
-    Deserialize the JSON representation of a selection. Must be
-    implemented for custom classes (as a static class method).
-    */
-    static fromJSON(doc, json) {
-        if (!json || !json.type)
-            throw new RangeError("Invalid input for Selection.fromJSON");
-        let cls = classesById[json.type];
-        if (!cls)
-            throw new RangeError(`No selection type ${json.type} defined`);
-        return cls.fromJSON(doc, json);
-    }
-    /**
-    To be able to deserialize selections from JSON, custom selection
-    classes must register themselves with an ID string, so that they
-    can be disambiguated. Try to pick something that's unlikely to
-    clash with classes from other modules.
-    */
-    static jsonID(id, selectionClass) {
-        if (id in classesById)
-            throw new RangeError("Duplicate use of selection JSON ID " + id);
-        classesById[id] = selectionClass;
-        selectionClass.prototype.jsonID = id;
-        return selectionClass;
-    }
-    /**
-    Get a [bookmark](https://prosemirror.net/docs/ref/#state.SelectionBookmark) for this selection,
-    which is a value that can be mapped without having access to a
-    current document, and later resolved to a real selection for a
-    given document again. (This is used mostly by the history to
-    track and restore old selections.) The default implementation of
-    this method just converts the selection to a text selection and
-    returns the bookmark for that.
-    */
-    getBookmark() {
-        return TextSelection.between(this.$anchor, this.$head).getBookmark();
-    }
-}
-Selection.prototype.visible = true;
-/**
-Represents a selected range in a document.
-*/
-class SelectionRange {
-    /**
-    Create a range.
-    */
-    constructor(
-    /**
-    The lower bound of the range.
-    */
-    $from, 
-    /**
-    The upper bound of the range.
-    */
-    $to) {
-        this.$from = $from;
-        this.$to = $to;
-    }
-}
-let warnedAboutTextSelection = false;
-function checkTextSelection($pos) {
-    if (!warnedAboutTextSelection && !$pos.parent.inlineContent) {
-        warnedAboutTextSelection = true;
-        console["warn"]("TextSelection endpoint not pointing into a node with inline content (" + $pos.parent.type.name + ")");
-    }
-}
-/**
-A text selection represents a classical editor selection, with a
-head (the moving side) and anchor (immobile side), both of which
-point into textblock nodes. It can be empty (a regular cursor
-position).
-*/
-class TextSelection extends Selection {
-    /**
-    Construct a text selection between the given points.
-    */
-    constructor($anchor, $head = $anchor) {
-        checkTextSelection($anchor);
-        checkTextSelection($head);
-        super($anchor, $head);
-    }
-    /**
-    Returns a resolved position if this is a cursor selection (an
-    empty text selection), and null otherwise.
-    */
-    get $cursor() { return this.$anchor.pos == this.$head.pos ? this.$head : null; }
-    map(doc, mapping) {
-        let $head = doc.resolve(mapping.map(this.head));
-        if (!$head.parent.inlineContent)
-            return Selection.near($head);
-        let $anchor = doc.resolve(mapping.map(this.anchor));
-        return new TextSelection($anchor.parent.inlineContent ? $anchor : $head, $head);
-    }
-    replace(tr, content = Slice.empty) {
-        super.replace(tr, content);
-        if (content == Slice.empty) {
-            let marks = this.$from.marksAcross(this.$to);
-            if (marks)
-                tr.ensureMarks(marks);
-        }
-    }
-    eq(other) {
-        return other instanceof TextSelection && other.anchor == this.anchor && other.head == this.head;
-    }
-    getBookmark() {
-        return new TextBookmark(this.anchor, this.head);
-    }
-    toJSON() {
-        return { type: "text", anchor: this.anchor, head: this.head };
-    }
-    /**
-    @internal
-    */
-    static fromJSON(doc, json) {
-        if (typeof json.anchor != "number" || typeof json.head != "number")
-            throw new RangeError("Invalid input for TextSelection.fromJSON");
-        return new TextSelection(doc.resolve(json.anchor), doc.resolve(json.head));
-    }
-    /**
-    Create a text selection from non-resolved positions.
-    */
-    static create(doc, anchor, head = anchor) {
-        let $anchor = doc.resolve(anchor);
-        return new this($anchor, head == anchor ? $anchor : doc.resolve(head));
-    }
-    /**
-    Return a text selection that spans the given positions or, if
-    they aren't text positions, find a text selection near them.
-    `bias` determines whether the method searches forward (default)
-    or backwards (negative number) first. Will fall back to calling
-    [`Selection.near`](https://prosemirror.net/docs/ref/#state.Selection^near) when the document
-    doesn't contain a valid text position.
-    */
-    static between($anchor, $head, bias) {
-        let dPos = $anchor.pos - $head.pos;
-        if (!bias || dPos)
-            bias = dPos >= 0 ? 1 : -1;
-        if (!$head.parent.inlineContent) {
-            let found = Selection.findFrom($head, bias, true) || Selection.findFrom($head, -bias, true);
-            if (found)
-                $head = found.$head;
-            else
-                return Selection.near($head, bias);
-        }
-        if (!$anchor.parent.inlineContent) {
-            if (dPos == 0) {
-                $anchor = $head;
-            }
-            else {
-                $anchor = (Selection.findFrom($anchor, -bias, true) || Selection.findFrom($anchor, bias, true)).$anchor;
-                if (($anchor.pos < $head.pos) != (dPos < 0))
-                    $anchor = $head;
-            }
-        }
-        return new TextSelection($anchor, $head);
-    }
-}
-Selection.jsonID("text", TextSelection);
-class TextBookmark {
-    constructor(anchor, head) {
-        this.anchor = anchor;
-        this.head = head;
-    }
-    map(mapping) {
-        return new TextBookmark(mapping.map(this.anchor), mapping.map(this.head));
-    }
-    resolve(doc) {
-        return TextSelection.between(doc.resolve(this.anchor), doc.resolve(this.head));
-    }
-}
-/**
-A node selection is a selection that points at a single node. All
-nodes marked [selectable](https://prosemirror.net/docs/ref/#model.NodeSpec.selectable) can be the
-target of a node selection. In such a selection, `from` and `to`
-point directly before and after the selected node, `anchor` equals
-`from`, and `head` equals `to`..
-*/
-class NodeSelection extends Selection {
-    /**
-    Create a node selection. Does not verify the validity of its
-    argument.
-    */
-    constructor($pos) {
-        let node = $pos.nodeAfter;
-        let $end = $pos.node(0).resolve($pos.pos + node.nodeSize);
-        super($pos, $end);
-        this.node = node;
-    }
-    map(doc, mapping) {
-        let { deleted, pos } = mapping.mapResult(this.anchor);
-        let $pos = doc.resolve(pos);
-        if (deleted)
-            return Selection.near($pos);
-        return new NodeSelection($pos);
-    }
-    content() {
-        return new Slice(Fragment.from(this.node), 0, 0);
-    }
-    eq(other) {
-        return other instanceof NodeSelection && other.anchor == this.anchor;
-    }
-    toJSON() {
-        return { type: "node", anchor: this.anchor };
-    }
-    getBookmark() { return new NodeBookmark(this.anchor); }
-    /**
-    @internal
-    */
-    static fromJSON(doc, json) {
-        if (typeof json.anchor != "number")
-            throw new RangeError("Invalid input for NodeSelection.fromJSON");
-        return new NodeSelection(doc.resolve(json.anchor));
-    }
-    /**
-    Create a node selection from non-resolved positions.
-    */
-    static create(doc, from) {
-        return new NodeSelection(doc.resolve(from));
-    }
-    /**
-    Determines whether the given node may be selected as a node
-    selection.
-    */
-    static isSelectable(node) {
-        return !node.isText && node.type.spec.selectable !== false;
-    }
-}
-NodeSelection.prototype.visible = false;
-Selection.jsonID("node", NodeSelection);
-class NodeBookmark {
-    constructor(anchor) {
-        this.anchor = anchor;
-    }
-    map(mapping) {
-        let { deleted, pos } = mapping.mapResult(this.anchor);
-        return deleted ? new TextBookmark(pos, pos) : new NodeBookmark(pos);
-    }
-    resolve(doc) {
-        let $pos = doc.resolve(this.anchor), node = $pos.nodeAfter;
-        if (node && NodeSelection.isSelectable(node))
-            return new NodeSelection($pos);
-        return Selection.near($pos);
-    }
-}
-/**
-A selection type that represents selecting the whole document
-(which can not necessarily be expressed with a text selection, when
-there are for example leaf block nodes at the start or end of the
-document).
-*/
-class AllSelection extends Selection {
-    /**
-    Create an all-selection over the given document.
-    */
-    constructor(doc) {
-        super(doc.resolve(0), doc.resolve(doc.content.size));
-    }
-    replace(tr, content = Slice.empty) {
-        if (content == Slice.empty) {
-            tr.delete(0, tr.doc.content.size);
-            let sel = Selection.atStart(tr.doc);
-            if (!sel.eq(tr.selection))
-                tr.setSelection(sel);
-        }
-        else {
-            super.replace(tr, content);
-        }
-    }
-    toJSON() { return { type: "all" }; }
-    /**
-    @internal
-    */
-    static fromJSON(doc) { return new AllSelection(doc); }
-    map(doc) { return new AllSelection(doc); }
-    eq(other) { return other instanceof AllSelection; }
-    getBookmark() { return AllBookmark; }
-}
-Selection.jsonID("all", AllSelection);
-const AllBookmark = {
-    map() { return this; },
-    resolve(doc) { return new AllSelection(doc); }
-};
-// FIXME we'll need some awareness of text direction when scanning for selections
-// Try to find a selection inside the given node. `pos` points at the
-// position where the search starts. When `text` is true, only return
-// text selections.
-function findSelectionIn(doc, node, pos, index, dir, text = false) {
-    if (node.inlineContent)
-        return TextSelection.create(doc, pos);
-    for (let i = index - (dir > 0 ? 0 : 1); dir > 0 ? i < node.childCount : i >= 0; i += dir) {
-        let child = node.child(i);
-        if (!child.isAtom) {
-            let inner = findSelectionIn(doc, child, pos + dir, dir < 0 ? child.childCount : 0, dir, text);
-            if (inner)
-                return inner;
-        }
-        else if (!text && NodeSelection.isSelectable(child)) {
-            return NodeSelection.create(doc, pos - (dir < 0 ? child.nodeSize : 0));
-        }
-        pos += child.nodeSize * dir;
-    }
-    return null;
-}
-function selectionToInsertionEnd(tr, startLen, bias) {
-    let last = tr.steps.length - 1;
-    if (last < startLen)
-        return;
-    let step = tr.steps[last];
-    if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep))
-        return;
-    let map = tr.mapping.maps[last], end;
-    map.forEach((_from, _to, _newFrom, newTo) => { if (end == null)
-        end = newTo; });
-    tr.setSelection(Selection.near(tr.doc.resolve(end), bias));
-}
-
-const UPDATED_SEL = 1, UPDATED_MARKS = 2, UPDATED_SCROLL = 4;
-/**
-An editor state transaction, which can be applied to a state to
-create an updated state. Use
-[`EditorState.tr`](https://prosemirror.net/docs/ref/#state.EditorState.tr) to create an instance.
-
-Transactions track changes to the document (they are a subclass of
-[`Transform`](https://prosemirror.net/docs/ref/#transform.Transform)), but also other state changes,
-like selection updates and adjustments of the set of [stored
-marks](https://prosemirror.net/docs/ref/#state.EditorState.storedMarks). In addition, you can store
-metadata properties in a transaction, which are extra pieces of
-information that client code or plugins can use to describe what a
-transaction represents, so that they can update their [own
-state](https://prosemirror.net/docs/ref/#state.StateField) accordingly.
-
-The [editor view](https://prosemirror.net/docs/ref/#view.EditorView) uses a few metadata properties:
-it will attach a property `"pointer"` with the value `true` to
-selection transactions directly caused by mouse or touch input, and
-a `"uiEvent"` property of that may be `"paste"`, `"cut"`, or `"drop"`.
-*/
-class Transaction extends Transform {
-    /**
-    @internal
-    */
-    constructor(state) {
-        super(state.doc);
-        // The step count for which the current selection is valid.
-        this.curSelectionFor = 0;
-        // Bitfield to track which aspects of the state were updated by
-        // this transaction.
-        this.updated = 0;
-        // Object used to store metadata properties for the transaction.
-        this.meta = Object.create(null);
-        this.time = Date.now();
-        this.curSelection = state.selection;
-        this.storedMarks = state.storedMarks;
-    }
-    /**
-    The transaction's current selection. This defaults to the editor
-    selection [mapped](https://prosemirror.net/docs/ref/#state.Selection.map) through the steps in the
-    transaction, but can be overwritten with
-    [`setSelection`](https://prosemirror.net/docs/ref/#state.Transaction.setSelection).
-    */
-    get selection() {
-        if (this.curSelectionFor < this.steps.length) {
-            this.curSelection = this.curSelection.map(this.doc, this.mapping.slice(this.curSelectionFor));
-            this.curSelectionFor = this.steps.length;
-        }
-        return this.curSelection;
-    }
-    /**
-    Update the transaction's current selection. Will determine the
-    selection that the editor gets when the transaction is applied.
-    */
-    setSelection(selection) {
-        if (selection.$from.doc != this.doc)
-            throw new RangeError("Selection passed to setSelection must point at the current document");
-        this.curSelection = selection;
-        this.curSelectionFor = this.steps.length;
-        this.updated = (this.updated | UPDATED_SEL) & ~UPDATED_MARKS;
-        this.storedMarks = null;
-        return this;
-    }
-    /**
-    Whether the selection was explicitly updated by this transaction.
-    */
-    get selectionSet() {
-        return (this.updated & UPDATED_SEL) > 0;
-    }
-    /**
-    Set the current stored marks.
-    */
-    setStoredMarks(marks) {
-        this.storedMarks = marks;
-        this.updated |= UPDATED_MARKS;
-        return this;
-    }
-    /**
-    Make sure the current stored marks or, if that is null, the marks
-    at the selection, match the given set of marks. Does nothing if
-    this is already the case.
-    */
-    ensureMarks(marks) {
-        if (!Mark.sameSet(this.storedMarks || this.selection.$from.marks(), marks))
-            this.setStoredMarks(marks);
-        return this;
-    }
-    /**
-    Add a mark to the set of stored marks.
-    */
-    addStoredMark(mark) {
-        return this.ensureMarks(mark.addToSet(this.storedMarks || this.selection.$head.marks()));
-    }
-    /**
-    Remove a mark or mark type from the set of stored marks.
-    */
-    removeStoredMark(mark) {
-        return this.ensureMarks(mark.removeFromSet(this.storedMarks || this.selection.$head.marks()));
-    }
-    /**
-    Whether the stored marks were explicitly set for this transaction.
-    */
-    get storedMarksSet() {
-        return (this.updated & UPDATED_MARKS) > 0;
-    }
-    /**
-    @internal
-    */
-    addStep(step, doc) {
-        super.addStep(step, doc);
-        this.updated = this.updated & ~UPDATED_MARKS;
-        this.storedMarks = null;
-    }
-    /**
-    Update the timestamp for the transaction.
-    */
-    setTime(time) {
-        this.time = time;
-        return this;
-    }
-    /**
-    Replace the current selection with the given slice.
-    */
-    replaceSelection(slice) {
-        this.selection.replace(this, slice);
-        return this;
-    }
-    /**
-    Replace the selection with the given node. When `inheritMarks` is
-    true and the content is inline, it inherits the marks from the
-    place where it is inserted.
-    */
-    replaceSelectionWith(node, inheritMarks = true) {
-        let selection = this.selection;
-        if (inheritMarks)
-            node = node.mark(this.storedMarks || (selection.empty ? selection.$from.marks() : (selection.$from.marksAcross(selection.$to) || Mark.none)));
-        selection.replaceWith(this, node);
-        return this;
-    }
-    /**
-    Delete the selection.
-    */
-    deleteSelection() {
-        this.selection.replace(this);
-        return this;
-    }
-    /**
-    Replace the given range, or the selection if no range is given,
-    with a text node containing the given string.
-    */
-    insertText(text, from, to) {
-        let schema = this.doc.type.schema;
-        if (from == null) {
-            if (!text)
-                return this.deleteSelection();
-            return this.replaceSelectionWith(schema.text(text), true);
-        }
-        else {
-            if (to == null)
-                to = from;
-            to = to == null ? from : to;
-            if (!text)
-                return this.deleteRange(from, to);
-            let marks = this.storedMarks;
-            if (!marks) {
-                let $from = this.doc.resolve(from);
-                marks = to == from ? $from.marks() : $from.marksAcross(this.doc.resolve(to));
-            }
-            this.replaceRangeWith(from, to, schema.text(text, marks));
-            if (!this.selection.empty)
-                this.setSelection(Selection.near(this.selection.$to));
-            return this;
-        }
-    }
-    /**
-    Store a metadata property in this transaction, keyed either by
-    name or by plugin.
-    */
-    setMeta(key, value) {
-        this.meta[typeof key == "string" ? key : key.key] = value;
-        return this;
-    }
-    /**
-    Retrieve a metadata property for a given name or plugin.
-    */
-    getMeta(key) {
-        return this.meta[typeof key == "string" ? key : key.key];
-    }
-    /**
-    Returns true if this transaction doesn't contain any metadata,
-    and can thus safely be extended.
-    */
-    get isGeneric() {
-        for (let _ in this.meta)
-            return false;
-        return true;
-    }
-    /**
-    Indicate that the editor should scroll the selection into view
-    when updated to the state produced by this transaction.
-    */
-    scrollIntoView() {
-        this.updated |= UPDATED_SCROLL;
-        return this;
-    }
-    /**
-    True when this transaction has had `scrollIntoView` called on it.
-    */
-    get scrolledIntoView() {
-        return (this.updated & UPDATED_SCROLL) > 0;
-    }
-}
-
-function bind(f, self) {
-    return !self || !f ? f : f.bind(self);
-}
-class FieldDesc {
-    constructor(name, desc, self) {
-        this.name = name;
-        this.init = bind(desc.init, self);
-        this.apply = bind(desc.apply, self);
-    }
-}
-[
-    new FieldDesc("doc", {
-        init(config) { return config.doc || config.schema.topNodeType.createAndFill(); },
-        apply(tr) { return tr.doc; }
-    }),
-    new FieldDesc("selection", {
-        init(config, instance) { return config.selection || Selection.atStart(instance.doc); },
-        apply(tr) { return tr.selection; }
-    }),
-    new FieldDesc("storedMarks", {
-        init(config) { return config.storedMarks || null; },
-        apply(tr, _marks, _old, state) { return state.selection.$cursor ? tr.storedMarks : null; }
-    }),
-    new FieldDesc("scrollToSelection", {
-        init() { return 0; },
-        apply(tr, prev) { return tr.scrolledIntoView ? prev + 1 : prev; }
-    })
-];
-
-function bindProps(obj, self, target) {
-    for (let prop in obj) {
-        let val = obj[prop];
-        if (val instanceof Function)
-            val = val.bind(self);
-        else if (prop == "handleDOMEvents")
-            val = bindProps(val, self, {});
-        target[prop] = val;
-    }
-    return target;
-}
-/**
-Plugins bundle functionality that can be added to an editor.
-They are part of the [editor state](https://prosemirror.net/docs/ref/#state.EditorState) and
-may influence that state and the view that contains it.
-*/
-class Plugin {
-    /**
-    Create a plugin.
-    */
-    constructor(
-    /**
-    The plugin's [spec object](https://prosemirror.net/docs/ref/#state.PluginSpec).
-    */
-    spec) {
-        this.spec = spec;
-        /**
-        The [props](https://prosemirror.net/docs/ref/#view.EditorProps) exported by this plugin.
-        */
-        this.props = {};
-        if (spec.props)
-            bindProps(spec.props, this, this.props);
-        this.key = spec.key ? spec.key.key : createKey("plugin");
-    }
-    /**
-    Extract the plugin's state field from an editor state.
-    */
-    getState(state) { return state[this.key]; }
-}
-const keys = Object.create(null);
-function createKey(name) {
-    if (name in keys)
-        return name + "$" + ++keys[name];
-    keys[name] = 0;
-    return name + "$";
-}
-/**
-A key is used to [tag](https://prosemirror.net/docs/ref/#state.PluginSpec.key) plugins in a way
-that makes it possible to find them, given an editor state.
-Assigning a key does mean only one plugin of that type can be
-active in a state.
-*/
-class PluginKey {
-    /**
-    Create a plugin key.
-    */
-    constructor(name = "key") { this.key = createKey(name); }
-    /**
-    Get the active plugin with this key, if any, from an editor
-    state.
-    */
-    get(state) { return state.config.pluginsByKey[this.key]; }
-    /**
-    Get the plugin's state from an editor state.
-    */
-    getState(state) { return state[this.key]; }
-}
+import { Plugin, PluginKey, TextSelection } from '@tiptap/pm/state';
 
 const backtickInputRegex = /^```([a-z]+)?[\s\n]$/;
 const tildeInputRegex = /^~~~([a-z]+)?[\s\n]$/;