@jvs-milkdown/components 1.0.0

package/lib/code-block/index.js

@@ -0,0 +1,4160 @@
+import { $ctx, $view } from '@jvs-milkdown/utils';
+import { codeBlockSchema } from '@jvs-milkdown/preset-commonmark';
+import { Compartment, EditorState } from '@codemirror/state';
+import { EditorView, drawSelection, keymap } from '@codemirror/view';
+import { h, Fragment as Fragment$1, defineComponent, ref, watch, computed, onMounted, onUnmounted, watchEffect, createApp } from 'vue';
+import clsx from 'clsx';
+import DOMPurify from 'dompurify';
+import { computePosition } from '@floating-ui/dom';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+function withMeta(plugin, meta) {
+  Object.assign(plugin, {
+    meta: __spreadValues({
+      package: "@jvs-milkdown/components"
+    }, meta)
+  });
+  return plugin;
+}
+
+const defaultConfig = {
+  extensions: [],
+  languages: [],
+  expandIcon: "\u2B07",
+  searchIcon: "\u{1F50D}",
+  clearSearchIcon: "\u232B",
+  searchPlaceholder: "Search language",
+  noResultText: "No result",
+  copyText: "Copy",
+  copyIcon: "\u{1F4CB}",
+  onCopy: () => {
+  },
+  renderLanguage: (language) => language,
+  renderPreview: () => null,
+  previewToggleButton: (previewOnlyMode) => previewOnlyMode ? "Edit" : "Hide",
+  previewLabel: "Preview",
+  previewLoading: "Loading..."
+};
+const codeBlockConfig = $ctx(defaultConfig, "codeBlockConfigCtx");
+withMeta(codeBlockConfig, {
+  displayName: "Config<code-block>",
+  group: "CodeBlock"
+});
+
+class LanguageLoader {
+  constructor(languages) {
+    this.languages = languages;
+    this.map = {};
+    languages.forEach((language) => {
+      language.alias.forEach((alias) => {
+        this.map[alias] = language;
+      });
+    });
+  }
+  getAll() {
+    return this.languages.map((language) => {
+      return {
+        name: language.name,
+        alias: language.alias
+      };
+    });
+  }
+  load(languageName) {
+    const languageMap = this.map;
+    const language = languageMap[languageName.toLowerCase()];
+    if (!language) return Promise.resolve(void 0);
+    if (language.support) return Promise.resolve(language.support);
+    return language.load();
+  }
+}
+
+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(
+    /**
+    The child nodes in this fragment.
+    */
+    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 = "", first = true;
+        this.nodesBetween(from, to, (node, pos) => {
+            let nodeText = node.isText ? node.text.slice(Math.max(from, pos) - pos, to - pos)
+                : !node.isLeaf ? ""
+                    : leafText ? (typeof leafText === "function" ? leafText(node) : leafText)
+                        : node.type.spec.leafText ? node.type.spec.leafText(node)
+                            : "";
+            if (node.isBlock && (node.isLeaf && nodeText || node.isTextblock) && blockSeparator) {
+                if (first)
+                    first = false;
+                else
+                    text += blockSeparator;
+            }
+            text += nodeText;
+        }, 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. @internal
+    */
+    findIndex(pos) {
+        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)
+                    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;
+}
+
+/**
+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, child);
+    return inner && content.replaceChild(index, child.copy(inner));
+}
+
+// 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](https://prosemirror.net/docs/guide/#transform.rebasing)’ steps for
+collaboration or history management.)
+*/
+class Mapping {
+    /**
+    Create a new mapping with the given position maps.
+    */
+    constructor(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 ? maps.length : 0) {
+        this.mirror = mirror;
+        this.from = from;
+        this.to = to;
+        this._maps = maps || [];
+        this.ownData = !(maps || mirror);
+    }
+    /**
+    The step maps in this mapping.
+    */
+    get maps() { return this._maps; }
+    /**
+    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);
+    }
+    /**
+    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) {
+        if (!this.ownData) {
+            this._maps = this._maps.slice();
+            this.mirror = this.mirror && this.mirror.slice();
+            this.ownData = true;
+        }
+        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, this.structure);
+    }
+    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 = this.from == this.gapFrom ? from.pos : mapping.map(this.gapFrom, -1);
+        let gapTo = this.to == this.gapTo ? to.pos : 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 canCut(node, start, end) {
+    return (start == 0 || node.canReplace(start, node.childCount)) &&
+        (end == node.childCount || node.canReplace(0, end));
+}
+/**
+Try to find a target depth to which the content in the given range
+can be lifted. Will not go across
+[isolating](https://prosemirror.net/docs/ref/#model.NodeSpec.isolating) parent nodes.
+*/
+function liftTarget(range) {
+    let parent = range.parent;
+    let content = parent.content.cutByIndex(range.startIndex, range.endIndex);
+    for (let depth = range.depth, contentBefore = 0, contentAfter = 0;; --depth) {
+        let node = range.$from.node(depth);
+        let index = range.$from.index(depth) + contentBefore, endIndex = range.$to.indexAfter(depth) - contentAfter;
+        if (depth < range.depth && node.canReplace(index, endIndex, content))
+            return depth;
+        if (depth == 0 || node.type.spec.isolating || !canCut(node, index, endIndex))
+            break;
+        if (index)
+            contentBefore = 1;
+        if (endIndex < node.childCount)
+            contentAfter = 1;
+    }
+    return null;
+}
+/**
+Check whether splitting at the given position is allowed.
+*/
+function canSplit(doc, pos, depth = 1, typesAfter) {
+    let $pos = doc.resolve(pos), base = $pos.depth - depth;
+    let innerType = (typesAfter && typesAfter[typesAfter.length - 1]) || $pos.parent;
+    if (base < 0 || $pos.parent.type.spec.isolating ||
+        !$pos.parent.canReplace($pos.index(), $pos.parent.childCount) ||
+        !innerType.type.validContent($pos.parent.content.cutByIndex($pos.index(), $pos.parent.childCount)))
+        return false;
+    for (let d = $pos.depth - 1, i = depth - 2; d > base; d--, i--) {
+        let node = $pos.node(d), index = $pos.index(d);
+        if (node.type.spec.isolating)
+            return false;
+        let rest = node.content.cutByIndex(index, node.childCount);
+        let overrideChild = typesAfter && typesAfter[i + 1];
+        if (overrideChild)
+            rest = rest.replaceChild(0, overrideChild.type.create(overrideChild.attrs));
+        let after = (typesAfter && typesAfter[i]) || node;
+        if (!node.canReplace(index + 1, node.childCount) || !after.type.validContent(rest))
+            return false;
+    }
+    let index = $pos.indexAfter(base);
+    let baseType = typesAfter && typesAfter[0];
+    return $pos.node(base).canReplaceWith(index, index, baseType ? baseType.type : $pos.node(base + 1).type);
+}
+/**
+Test whether the blocks before and after a given position can be
+joined.
+*/
+function canJoin(doc, pos) {
+    let $pos = doc.resolve(pos), index = $pos.index();
+    return joinable($pos.nodeBefore, $pos.nodeAfter) &&
+        $pos.parent.canReplace(index, index + 1);
+}
+function canAppendWithSubstitutedLinebreaks(a, b) {
+    if (!b.content.size)
+        a.type.compatibleContent(b.type);
+    let match = a.contentMatchAt(a.childCount);
+    let { linebreakReplacement } = a.type.schema;
+    for (let i = 0; i < b.childCount; i++) {
+        let child = b.child(i);
+        let type = child.type == linebreakReplacement ? a.type.schema.nodes.text : child.type;
+        match = match.matchType(type);
+        if (!match)
+            return false;
+        if (!a.type.allowsMarks(child.marks))
+            return false;
+    }
+    return match.validEnd;
+}
+function joinable(a, b) {
+    return !!(a && b && !a.isLeaf && canAppendWithSubstitutedLinebreaks(a, b));
+}
+
+/**
+‘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() {
+        let startDepth = this.unplaced.openStart;
+        for (let cur = this.unplaced.content, d = 0, openEnd = this.unplaced.openEnd; d < startDepth; d++) {
+            let node = cur.firstChild;
+            if (cur.childCount > 1)
+                openEnd = 0;
+            if (node.type.spec.isolating && openEnd <= d) {
+                startDepth = d;
+                break;
+            }
+            cur = node.content;
+        }
+        // Only try wrapping nodes (pass 2) after finding a place without
+        // wrapping failed.
+        for (let pass = 1; pass <= 2; pass++) {
+            for (let sliceDepth = pass == 1 ? startDepth : 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;
+}
+
+/**
+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);
+/**
+Update an attribute in the doc node.
+*/
+class DocAttrStep extends Step {
+    /**
+    Construct an attribute step.
+    */
+    constructor(
+    /**
+    The attribute to set.
+    */
+    attr, 
+    // The attribute's new value.
+    value) {
+        super();
+        this.attr = attr;
+        this.value = value;
+    }
+    apply(doc) {
+        let attrs = Object.create(null);
+        for (let name in doc.attrs)
+            attrs[name] = doc.attrs[name];
+        attrs[this.attr] = this.value;
+        let updated = doc.type.create(attrs, doc.content, doc.marks);
+        return StepResult.ok(updated);
+    }
+    getMap() {
+        return StepMap.empty;
+    }
+    invert(doc) {
+        return new DocAttrStep(this.attr, doc.attrs[this.attr]);
+    }
+    map(mapping) {
+        return this;
+    }
+    toJSON() {
+        return { stepType: "docAttr", attr: this.attr, value: this.value };
+    }
+    static fromJSON(schema, json) {
+        if (typeof json.attr != "string")
+            throw new RangeError("Invalid input for DocAttrStep.fromJSON");
+        return new DocAttrStep(json.attr, json.value);
+    }
+}
+Step.jsonID("docAttr", DocAttrStep);
+
+/**
+@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";
+
+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));
+}
+
+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; }
+    })
+];
+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]; }
+}
+
+/**
+Delete the selection, if there is one.
+*/
+const deleteSelection = (state, dispatch) => {
+    if (state.selection.empty)
+        return false;
+    if (dispatch)
+        dispatch(state.tr.deleteSelection().scrollIntoView());
+    return true;
+};
+function atBlockStart(state, view) {
+    let { $cursor } = state.selection;
+    if (!$cursor || (view ? !view.endOfTextblock("backward", state)
+        : $cursor.parentOffset > 0))
+        return null;
+    return $cursor;
+}
+/**
+If the selection is empty and at the start of a textblock, try to
+reduce the distance between that block and the one before it—if
+there's a block directly before it that can be joined, join them.
+If not, try to move the selected block closer to the next one in
+the document structure by lifting it out of its parent or moving it
+into a parent of the previous block. Will use the view for accurate
+(bidi-aware) start-of-textblock detection if given.
+*/
+const joinBackward = (state, dispatch, view) => {
+    let $cursor = atBlockStart(state, view);
+    if (!$cursor)
+        return false;
+    let $cut = findCutBefore($cursor);
+    // If there is no node before this, try to lift
+    if (!$cut) {
+        let range = $cursor.blockRange(), target = range && liftTarget(range);
+        if (target == null)
+            return false;
+        if (dispatch)
+            dispatch(state.tr.lift(range, target).scrollIntoView());
+        return true;
+    }
+    let before = $cut.nodeBefore;
+    // Apply the joining algorithm
+    if (deleteBarrier(state, $cut, dispatch, -1))
+        return true;
+    // If the node below has no content and the node above is
+    // selectable, delete the node below and select the one above.
+    if ($cursor.parent.content.size == 0 &&
+        (textblockAt(before, "end") || NodeSelection.isSelectable(before))) {
+        for (let depth = $cursor.depth;; depth--) {
+            let delStep = replaceStep(state.doc, $cursor.before(depth), $cursor.after(depth), Slice.empty);
+            if (delStep && delStep.slice.size < delStep.to - delStep.from) {
+                if (dispatch) {
+                    let tr = state.tr.step(delStep);
+                    tr.setSelection(textblockAt(before, "end")
+                        ? Selection.findFrom(tr.doc.resolve(tr.mapping.map($cut.pos, -1)), -1)
+                        : NodeSelection.create(tr.doc, $cut.pos - before.nodeSize));
+                    dispatch(tr.scrollIntoView());
+                }
+                return true;
+            }
+            if (depth == 1 || $cursor.node(depth - 1).childCount > 1)
+                break;
+        }
+    }
+    // If the node before is an atom, delete it
+    if (before.isAtom && $cut.depth == $cursor.depth - 1) {
+        if (dispatch)
+            dispatch(state.tr.delete($cut.pos - before.nodeSize, $cut.pos).scrollIntoView());
+        return true;
+    }
+    return false;
+};
+function textblockAt(node, side, only = false) {
+    for (let scan = node; scan; scan = (side == "start" ? scan.firstChild : scan.lastChild)) {
+        if (scan.isTextblock)
+            return true;
+        if (only && scan.childCount != 1)
+            return false;
+    }
+    return false;
+}
+/**
+When the selection is empty and at the start of a textblock, select
+the node before that textblock, if possible. This is intended to be
+bound to keys like backspace, after
+[`joinBackward`](https://prosemirror.net/docs/ref/#commands.joinBackward) or other deleting
+commands, as a fall-back behavior when the schema doesn't allow
+deletion at the selected point.
+*/
+const selectNodeBackward = (state, dispatch, view) => {
+    let { $head, empty } = state.selection, $cut = $head;
+    if (!empty)
+        return false;
+    if ($head.parent.isTextblock) {
+        if (view ? !view.endOfTextblock("backward", state) : $head.parentOffset > 0)
+            return false;
+        $cut = findCutBefore($head);
+    }
+    let node = $cut && $cut.nodeBefore;
+    if (!node || !NodeSelection.isSelectable(node))
+        return false;
+    if (dispatch)
+        dispatch(state.tr.setSelection(NodeSelection.create(state.doc, $cut.pos - node.nodeSize)).scrollIntoView());
+    return true;
+};
+function findCutBefore($pos) {
+    if (!$pos.parent.type.spec.isolating)
+        for (let i = $pos.depth - 1; i >= 0; i--) {
+            if ($pos.index(i) > 0)
+                return $pos.doc.resolve($pos.before(i + 1));
+            if ($pos.node(i).type.spec.isolating)
+                break;
+        }
+    return null;
+}
+function atBlockEnd(state, view) {
+    let { $cursor } = state.selection;
+    if (!$cursor || (view ? !view.endOfTextblock("forward", state)
+        : $cursor.parentOffset < $cursor.parent.content.size))
+        return null;
+    return $cursor;
+}
+/**
+If the selection is empty and the cursor is at the end of a
+textblock, try to reduce or remove the boundary between that block
+and the one after it, either by joining them or by moving the other
+block closer to this one in the tree structure. Will use the view
+for accurate start-of-textblock detection if given.
+*/
+const joinForward = (state, dispatch, view) => {
+    let $cursor = atBlockEnd(state, view);
+    if (!$cursor)
+        return false;
+    let $cut = findCutAfter($cursor);
+    // If there is no node after this, there's nothing to do
+    if (!$cut)
+        return false;
+    let after = $cut.nodeAfter;
+    // Try the joining algorithm
+    if (deleteBarrier(state, $cut, dispatch, 1))
+        return true;
+    // If the node above has no content and the node below is
+    // selectable, delete the node above and select the one below.
+    if ($cursor.parent.content.size == 0 &&
+        (textblockAt(after, "start") || NodeSelection.isSelectable(after))) {
+        let delStep = replaceStep(state.doc, $cursor.before(), $cursor.after(), Slice.empty);
+        if (delStep && delStep.slice.size < delStep.to - delStep.from) {
+            if (dispatch) {
+                let tr = state.tr.step(delStep);
+                tr.setSelection(textblockAt(after, "start") ? Selection.findFrom(tr.doc.resolve(tr.mapping.map($cut.pos)), 1)
+                    : NodeSelection.create(tr.doc, tr.mapping.map($cut.pos)));
+                dispatch(tr.scrollIntoView());
+            }
+            return true;
+        }
+    }
+    // If the next node is an atom, delete it
+    if (after.isAtom && $cut.depth == $cursor.depth - 1) {
+        if (dispatch)
+            dispatch(state.tr.delete($cut.pos, $cut.pos + after.nodeSize).scrollIntoView());
+        return true;
+    }
+    return false;
+};
+/**
+When the selection is empty and at the end of a textblock, select
+the node coming after that textblock, if possible. This is intended
+to be bound to keys like delete, after
+[`joinForward`](https://prosemirror.net/docs/ref/#commands.joinForward) and similar deleting
+commands, to provide a fall-back behavior when the schema doesn't
+allow deletion at the selected point.
+*/
+const selectNodeForward = (state, dispatch, view) => {
+    let { $head, empty } = state.selection, $cut = $head;
+    if (!empty)
+        return false;
+    if ($head.parent.isTextblock) {
+        if (view ? !view.endOfTextblock("forward", state) : $head.parentOffset < $head.parent.content.size)
+            return false;
+        $cut = findCutAfter($head);
+    }
+    let node = $cut && $cut.nodeAfter;
+    if (!node || !NodeSelection.isSelectable(node))
+        return false;
+    if (dispatch)
+        dispatch(state.tr.setSelection(NodeSelection.create(state.doc, $cut.pos)).scrollIntoView());
+    return true;
+};
+function findCutAfter($pos) {
+    if (!$pos.parent.type.spec.isolating)
+        for (let i = $pos.depth - 1; i >= 0; i--) {
+            let parent = $pos.node(i);
+            if ($pos.index(i) + 1 < parent.childCount)
+                return $pos.doc.resolve($pos.after(i + 1));
+            if (parent.type.spec.isolating)
+                break;
+        }
+    return null;
+}
+/**
+If the selection is in a node whose type has a truthy
+[`code`](https://prosemirror.net/docs/ref/#model.NodeSpec.code) property in its spec, replace the
+selection with a newline character.
+*/
+const newlineInCode = (state, dispatch) => {
+    let { $head, $anchor } = state.selection;
+    if (!$head.parent.type.spec.code || !$head.sameParent($anchor))
+        return false;
+    if (dispatch)
+        dispatch(state.tr.insertText("\n").scrollIntoView());
+    return true;
+};
+function defaultBlockAt(match) {
+    for (let i = 0; i < match.edgeCount; i++) {
+        let { type } = match.edge(i);
+        if (type.isTextblock && !type.hasRequiredAttrs())
+            return type;
+    }
+    return null;
+}
+/**
+When the selection is in a node with a truthy
+[`code`](https://prosemirror.net/docs/ref/#model.NodeSpec.code) property in its spec, create a
+default block after the code block, and move the cursor there.
+*/
+const exitCode = (state, dispatch) => {
+    let { $head, $anchor } = state.selection;
+    if (!$head.parent.type.spec.code || !$head.sameParent($anchor))
+        return false;
+    let above = $head.node(-1), after = $head.indexAfter(-1), type = defaultBlockAt(above.contentMatchAt(after));
+    if (!type || !above.canReplaceWith(after, after, type))
+        return false;
+    if (dispatch) {
+        let pos = $head.after(), tr = state.tr.replaceWith(pos, pos, type.createAndFill());
+        tr.setSelection(Selection.near(tr.doc.resolve(pos), 1));
+        dispatch(tr.scrollIntoView());
+    }
+    return true;
+};
+/**
+If a block node is selected, create an empty paragraph before (if
+it is its parent's first child) or after it.
+*/
+const createParagraphNear = (state, dispatch) => {
+    let sel = state.selection, { $from, $to } = sel;
+    if (sel instanceof AllSelection || $from.parent.inlineContent || $to.parent.inlineContent)
+        return false;
+    let type = defaultBlockAt($to.parent.contentMatchAt($to.indexAfter()));
+    if (!type || !type.isTextblock)
+        return false;
+    if (dispatch) {
+        let side = (!$from.parentOffset && $to.index() < $to.parent.childCount ? $from : $to).pos;
+        let tr = state.tr.insert(side, type.createAndFill());
+        tr.setSelection(TextSelection.create(tr.doc, side + 1));
+        dispatch(tr.scrollIntoView());
+    }
+    return true;
+};
+/**
+If the cursor is in an empty textblock that can be lifted, lift the
+block.
+*/
+const liftEmptyBlock = (state, dispatch) => {
+    let { $cursor } = state.selection;
+    if (!$cursor || $cursor.parent.content.size)
+        return false;
+    if ($cursor.depth > 1 && $cursor.after() != $cursor.end(-1)) {
+        let before = $cursor.before();
+        if (canSplit(state.doc, before)) {
+            if (dispatch)
+                dispatch(state.tr.split(before).scrollIntoView());
+            return true;
+        }
+    }
+    let range = $cursor.blockRange(), target = range && liftTarget(range);
+    if (target == null)
+        return false;
+    if (dispatch)
+        dispatch(state.tr.lift(range, target).scrollIntoView());
+    return true;
+};
+/**
+Create a variant of [`splitBlock`](https://prosemirror.net/docs/ref/#commands.splitBlock) that uses
+a custom function to determine the type of the newly split off block.
+*/
+function splitBlockAs(splitNode) {
+    return (state, dispatch) => {
+        let { $from, $to } = state.selection;
+        if (state.selection instanceof NodeSelection && state.selection.node.isBlock) {
+            if (!$from.parentOffset || !canSplit(state.doc, $from.pos))
+                return false;
+            if (dispatch)
+                dispatch(state.tr.split($from.pos).scrollIntoView());
+            return true;
+        }
+        if (!$from.depth)
+            return false;
+        let types = [];
+        let splitDepth, deflt, atEnd = false, atStart = false;
+        for (let d = $from.depth;; d--) {
+            let node = $from.node(d);
+            if (node.isBlock) {
+                atEnd = $from.end(d) == $from.pos + ($from.depth - d);
+                atStart = $from.start(d) == $from.pos - ($from.depth - d);
+                deflt = defaultBlockAt($from.node(d - 1).contentMatchAt($from.indexAfter(d - 1)));
+                types.unshift((atEnd && deflt ? { type: deflt } : null));
+                splitDepth = d;
+                break;
+            }
+            else {
+                if (d == 1)
+                    return false;
+                types.unshift(null);
+            }
+        }
+        let tr = state.tr;
+        if (state.selection instanceof TextSelection || state.selection instanceof AllSelection)
+            tr.deleteSelection();
+        let splitPos = tr.mapping.map($from.pos);
+        let can = canSplit(tr.doc, splitPos, types.length, types);
+        if (!can) {
+            types[0] = deflt ? { type: deflt } : null;
+            can = canSplit(tr.doc, splitPos, types.length, types);
+        }
+        if (!can)
+            return false;
+        tr.split(splitPos, types.length, types);
+        if (!atEnd && atStart && $from.node(splitDepth).type != deflt) {
+            let first = tr.mapping.map($from.before(splitDepth)), $first = tr.doc.resolve(first);
+            if (deflt && $from.node(splitDepth - 1).canReplaceWith($first.index(), $first.index() + 1, deflt))
+                tr.setNodeMarkup(tr.mapping.map($from.before(splitDepth)), deflt);
+        }
+        if (dispatch)
+            dispatch(tr.scrollIntoView());
+        return true;
+    };
+}
+/**
+Split the parent block of the selection. If the selection is a text
+selection, also delete its content.
+*/
+const splitBlock = splitBlockAs();
+function joinMaybeClear(state, $pos, dispatch) {
+    let before = $pos.nodeBefore, after = $pos.nodeAfter, index = $pos.index();
+    if (!before || !after || !before.type.compatibleContent(after.type))
+        return false;
+    if (!before.content.size && $pos.parent.canReplace(index - 1, index)) {
+        if (dispatch)
+            dispatch(state.tr.delete($pos.pos - before.nodeSize, $pos.pos).scrollIntoView());
+        return true;
+    }
+    if (!$pos.parent.canReplace(index, index + 1) || !(after.isTextblock || canJoin(state.doc, $pos.pos)))
+        return false;
+    if (dispatch)
+        dispatch(state.tr.join($pos.pos).scrollIntoView());
+    return true;
+}
+function deleteBarrier(state, $cut, dispatch, dir) {
+    let before = $cut.nodeBefore, after = $cut.nodeAfter, conn, match;
+    let isolated = before.type.spec.isolating || after.type.spec.isolating;
+    if (!isolated && joinMaybeClear(state, $cut, dispatch))
+        return true;
+    let canDelAfter = !isolated && $cut.parent.canReplace($cut.index(), $cut.index() + 1);
+    if (canDelAfter &&
+        (conn = (match = before.contentMatchAt(before.childCount)).findWrapping(after.type)) &&
+        match.matchType(conn[0] || after.type).validEnd) {
+        if (dispatch) {
+            let end = $cut.pos + after.nodeSize, wrap = Fragment.empty;
+            for (let i = conn.length - 1; i >= 0; i--)
+                wrap = Fragment.from(conn[i].create(null, wrap));
+            wrap = Fragment.from(before.copy(wrap));
+            let tr = state.tr.step(new ReplaceAroundStep($cut.pos - 1, end, $cut.pos, end, new Slice(wrap, 1, 0), conn.length, true));
+            let $joinAt = tr.doc.resolve(end + 2 * conn.length);
+            if ($joinAt.nodeAfter && $joinAt.nodeAfter.type == before.type &&
+                canJoin(tr.doc, $joinAt.pos))
+                tr.join($joinAt.pos);
+            dispatch(tr.scrollIntoView());
+        }
+        return true;
+    }
+    let selAfter = after.type.spec.isolating || (dir > 0 && isolated) ? null : Selection.findFrom($cut, 1);
+    let range = selAfter && selAfter.$from.blockRange(selAfter.$to), target = range && liftTarget(range);
+    if (target != null && target >= $cut.depth) {
+        if (dispatch)
+            dispatch(state.tr.lift(range, target).scrollIntoView());
+        return true;
+    }
+    if (canDelAfter && textblockAt(after, "start", true) && textblockAt(before, "end")) {
+        let at = before, wrap = [];
+        for (;;) {
+            wrap.push(at);
+            if (at.isTextblock)
+                break;
+            at = at.lastChild;
+        }
+        let afterText = after, afterDepth = 1;
+        for (; !afterText.isTextblock; afterText = afterText.firstChild)
+            afterDepth++;
+        if (at.canReplace(at.childCount, at.childCount, afterText.content)) {
+            if (dispatch) {
+                let end = Fragment.empty;
+                for (let i = wrap.length - 1; i >= 0; i--)
+                    end = Fragment.from(wrap[i].copy(end));
+                let tr = state.tr.step(new ReplaceAroundStep($cut.pos - wrap.length, $cut.pos + after.nodeSize, $cut.pos + afterDepth, $cut.pos + after.nodeSize - afterDepth, new Slice(end, wrap.length, 0), 0, true));
+                dispatch(tr.scrollIntoView());
+            }
+            return true;
+        }
+    }
+    return false;
+}
+/**
+Combine a number of command functions into a single function (which
+calls them one by one until one returns true).
+*/
+function chainCommands(...commands) {
+    return function (state, dispatch, view) {
+        for (let i = 0; i < commands.length; i++)
+            if (commands[i](state, dispatch, view))
+                return true;
+        return false;
+    };
+}
+chainCommands(deleteSelection, joinBackward, selectNodeBackward);
+chainCommands(deleteSelection, joinForward, selectNodeForward);
+/**
+A basic keymap containing bindings not specific to any schema.
+Binds the following keys (when multiple commands are listed, they
+are chained with [`chainCommands`](https://prosemirror.net/docs/ref/#commands.chainCommands)):
+
+* **Enter** to `newlineInCode`, `createParagraphNear`, `liftEmptyBlock`, `splitBlock`
+* **Mod-Enter** to `exitCode`
+* **Backspace** and **Mod-Backspace** to `deleteSelection`, `joinBackward`, `selectNodeBackward`
+* **Delete** and **Mod-Delete** to `deleteSelection`, `joinForward`, `selectNodeForward`
+* **Mod-Delete** to `deleteSelection`, `joinForward`, `selectNodeForward`
+* **Mod-a** to `selectAll`
+*/
+({
+    "Enter": chainCommands(newlineInCode, createParagraphNear, liftEmptyBlock, splitBlock)});
+typeof navigator != "undefined" ? /Mac|iP(hone|[oa]d)/.test(navigator.platform)
+    // @ts-ignore
+    : typeof os != "undefined" && os.platform ? os.platform() == "darwin" : false;
+
+var GOOD_LEAF_SIZE = 200;
+
+// :: class<T> A rope sequence is a persistent sequence data structure
+// that supports appending, prepending, and slicing without doing a
+// full copy. It is represented as a mostly-balanced tree.
+var RopeSequence = function RopeSequence () {};
+
+RopeSequence.prototype.append = function append (other) {
+  if (!other.length) { return this }
+  other = RopeSequence.from(other);
+
+  return (!this.length && other) ||
+    (other.length < GOOD_LEAF_SIZE && this.leafAppend(other)) ||
+    (this.length < GOOD_LEAF_SIZE && other.leafPrepend(this)) ||
+    this.appendInner(other)
+};
+
+// :: (union<[T], RopeSequence<T>>) → RopeSequence<T>
+// Prepend an array or other rope to this one, returning a new rope.
+RopeSequence.prototype.prepend = function prepend (other) {
+  if (!other.length) { return this }
+  return RopeSequence.from(other).append(this)
+};
+
+RopeSequence.prototype.appendInner = function appendInner (other) {
+  return new Append(this, other)
+};
+
+// :: (?number, ?number) → RopeSequence<T>
+// Create a rope repesenting a sub-sequence of this rope.
+RopeSequence.prototype.slice = function slice (from, to) {
+    if ( from === void 0 ) from = 0;
+    if ( to === void 0 ) to = this.length;
+
+  if (from >= to) { return RopeSequence.empty }
+  return this.sliceInner(Math.max(0, from), Math.min(this.length, to))
+};
+
+// :: (number) → T
+// Retrieve the element at the given position from this rope.
+RopeSequence.prototype.get = function get (i) {
+  if (i < 0 || i >= this.length) { return undefined }
+  return this.getInner(i)
+};
+
+// :: ((element: T, index: number) → ?bool, ?number, ?number)
+// Call the given function for each element between the given
+// indices. This tends to be more efficient than looping over the
+// indices and calling `get`, because it doesn't have to descend the
+// tree for every element.
+RopeSequence.prototype.forEach = function forEach (f, from, to) {
+    if ( from === void 0 ) from = 0;
+    if ( to === void 0 ) to = this.length;
+
+  if (from <= to)
+    { this.forEachInner(f, from, to, 0); }
+  else
+    { this.forEachInvertedInner(f, from, to, 0); }
+};
+
+// :: ((element: T, index: number) → U, ?number, ?number) → [U]
+// Map the given functions over the elements of the rope, producing
+// a flat array.
+RopeSequence.prototype.map = function map (f, from, to) {
+    if ( from === void 0 ) from = 0;
+    if ( to === void 0 ) to = this.length;
+
+  var result = [];
+  this.forEach(function (elt, i) { return result.push(f(elt, i)); }, from, to);
+  return result
+};
+
+// :: (?union<[T], RopeSequence<T>>) → RopeSequence<T>
+// Create a rope representing the given array, or return the rope
+// itself if a rope was given.
+RopeSequence.from = function from (values) {
+  if (values instanceof RopeSequence) { return values }
+  return values && values.length ? new Leaf(values) : RopeSequence.empty
+};
+
+var Leaf = /*@__PURE__*/(function (RopeSequence) {
+  function Leaf(values) {
+    RopeSequence.call(this);
+    this.values = values;
+  }
+
+  if ( RopeSequence ) Leaf.__proto__ = RopeSequence;
+  Leaf.prototype = Object.create( RopeSequence && RopeSequence.prototype );
+  Leaf.prototype.constructor = Leaf;
+
+  var prototypeAccessors = { length: { configurable: true },depth: { configurable: true } };
+
+  Leaf.prototype.flatten = function flatten () {
+    return this.values
+  };
+
+  Leaf.prototype.sliceInner = function sliceInner (from, to) {
+    if (from == 0 && to == this.length) { return this }
+    return new Leaf(this.values.slice(from, to))
+  };
+
+  Leaf.prototype.getInner = function getInner (i) {
+    return this.values[i]
+  };
+
+  Leaf.prototype.forEachInner = function forEachInner (f, from, to, start) {
+    for (var i = from; i < to; i++)
+      { if (f(this.values[i], start + i) === false) { return false } }
+  };
+
+  Leaf.prototype.forEachInvertedInner = function forEachInvertedInner (f, from, to, start) {
+    for (var i = from - 1; i >= to; i--)
+      { if (f(this.values[i], start + i) === false) { return false } }
+  };
+
+  Leaf.prototype.leafAppend = function leafAppend (other) {
+    if (this.length + other.length <= GOOD_LEAF_SIZE)
+      { return new Leaf(this.values.concat(other.flatten())) }
+  };
+
+  Leaf.prototype.leafPrepend = function leafPrepend (other) {
+    if (this.length + other.length <= GOOD_LEAF_SIZE)
+      { return new Leaf(other.flatten().concat(this.values)) }
+  };
+
+  prototypeAccessors.length.get = function () { return this.values.length };
+
+  prototypeAccessors.depth.get = function () { return 0 };
+
+  Object.defineProperties( Leaf.prototype, prototypeAccessors );
+
+  return Leaf;
+}(RopeSequence));
+
+// :: RopeSequence
+// The empty rope sequence.
+RopeSequence.empty = new Leaf([]);
+
+var Append = /*@__PURE__*/(function (RopeSequence) {
+  function Append(left, right) {
+    RopeSequence.call(this);
+    this.left = left;
+    this.right = right;
+    this.length = left.length + right.length;
+    this.depth = Math.max(left.depth, right.depth) + 1;
+  }
+
+  if ( RopeSequence ) Append.__proto__ = RopeSequence;
+  Append.prototype = Object.create( RopeSequence && RopeSequence.prototype );
+  Append.prototype.constructor = Append;
+
+  Append.prototype.flatten = function flatten () {
+    return this.left.flatten().concat(this.right.flatten())
+  };
+
+  Append.prototype.getInner = function getInner (i) {
+    return i < this.left.length ? this.left.get(i) : this.right.get(i - this.left.length)
+  };
+
+  Append.prototype.forEachInner = function forEachInner (f, from, to, start) {
+    var leftLen = this.left.length;
+    if (from < leftLen &&
+        this.left.forEachInner(f, from, Math.min(to, leftLen), start) === false)
+      { return false }
+    if (to > leftLen &&
+        this.right.forEachInner(f, Math.max(from - leftLen, 0), Math.min(this.length, to) - leftLen, start + leftLen) === false)
+      { return false }
+  };
+
+  Append.prototype.forEachInvertedInner = function forEachInvertedInner (f, from, to, start) {
+    var leftLen = this.left.length;
+    if (from > leftLen &&
+        this.right.forEachInvertedInner(f, from - leftLen, Math.max(to, leftLen) - leftLen, start + leftLen) === false)
+      { return false }
+    if (to < leftLen &&
+        this.left.forEachInvertedInner(f, Math.min(from, leftLen), to, start) === false)
+      { return false }
+  };
+
+  Append.prototype.sliceInner = function sliceInner (from, to) {
+    if (from == 0 && to == this.length) { return this }
+    var leftLen = this.left.length;
+    if (to <= leftLen) { return this.left.slice(from, to) }
+    if (from >= leftLen) { return this.right.slice(from - leftLen, to - leftLen) }
+    return this.left.slice(from, leftLen).append(this.right.slice(0, to - leftLen))
+  };
+
+  Append.prototype.leafAppend = function leafAppend (other) {
+    var inner = this.right.leafAppend(other);
+    if (inner) { return new Append(this.left, inner) }
+  };
+
+  Append.prototype.leafPrepend = function leafPrepend (other) {
+    var inner = this.left.leafPrepend(other);
+    if (inner) { return new Append(inner, this.right) }
+  };
+
+  Append.prototype.appendInner = function appendInner (other) {
+    if (this.left.depth >= Math.max(this.right.depth, other.depth) + 1)
+      { return new Append(this.left, new Append(this.right, other)) }
+    return new Append(this, other)
+  };
+
+  return Append;
+}(RopeSequence));
+
+// ProseMirror's history isn't simply a way to roll back to a previous
+// state, because ProseMirror supports applying changes without adding
+// them to the history (for example during collaboration).
+//
+// To this end, each 'Branch' (one for the undo history and one for
+// the redo history) keeps an array of 'Items', which can optionally
+// hold a step (an actual undoable change), and always hold a position
+// map (which is needed to move changes below them to apply to the
+// current document).
+//
+// An item that has both a step and a selection bookmark is the start
+// of an 'event' — a group of changes that will be undone or redone at
+// once. (It stores only the bookmark, since that way we don't have to
+// provide a document until the selection is actually applied, which
+// is useful when compressing.)
+// Used to schedule history compression
+const max_empty_items = 500;
+class Branch {
+    constructor(items, eventCount) {
+        this.items = items;
+        this.eventCount = eventCount;
+    }
+    // Pop the latest event off the branch's history and apply it
+    // to a document transform.
+    popEvent(state, preserveItems) {
+        if (this.eventCount == 0)
+            return null;
+        let end = this.items.length;
+        for (;; end--) {
+            let next = this.items.get(end - 1);
+            if (next.selection) {
+                --end;
+                break;
+            }
+        }
+        let remap, mapFrom;
+        if (preserveItems) {
+            remap = this.remapping(end, this.items.length);
+            mapFrom = remap.maps.length;
+        }
+        let transform = state.tr;
+        let selection, remaining;
+        let addAfter = [], addBefore = [];
+        this.items.forEach((item, i) => {
+            if (!item.step) {
+                if (!remap) {
+                    remap = this.remapping(end, i + 1);
+                    mapFrom = remap.maps.length;
+                }
+                mapFrom--;
+                addBefore.push(item);
+                return;
+            }
+            if (remap) {
+                addBefore.push(new Item(item.map));
+                let step = item.step.map(remap.slice(mapFrom)), map;
+                if (step && transform.maybeStep(step).doc) {
+                    map = transform.mapping.maps[transform.mapping.maps.length - 1];
+                    addAfter.push(new Item(map, undefined, undefined, addAfter.length + addBefore.length));
+                }
+                mapFrom--;
+                if (map)
+                    remap.appendMap(map, mapFrom);
+            }
+            else {
+                transform.maybeStep(item.step);
+            }
+            if (item.selection) {
+                selection = remap ? item.selection.map(remap.slice(mapFrom)) : item.selection;
+                remaining = new Branch(this.items.slice(0, end).append(addBefore.reverse().concat(addAfter)), this.eventCount - 1);
+                return false;
+            }
+        }, this.items.length, 0);
+        return { remaining: remaining, transform, selection: selection };
+    }
+    // Create a new branch with the given transform added.
+    addTransform(transform, selection, histOptions, preserveItems) {
+        let newItems = [], eventCount = this.eventCount;
+        let oldItems = this.items, lastItem = !preserveItems && oldItems.length ? oldItems.get(oldItems.length - 1) : null;
+        for (let i = 0; i < transform.steps.length; i++) {
+            let step = transform.steps[i].invert(transform.docs[i]);
+            let item = new Item(transform.mapping.maps[i], step, selection), merged;
+            if (merged = lastItem && lastItem.merge(item)) {
+                item = merged;
+                if (i)
+                    newItems.pop();
+                else
+                    oldItems = oldItems.slice(0, oldItems.length - 1);
+            }
+            newItems.push(item);
+            if (selection) {
+                eventCount++;
+                selection = undefined;
+            }
+            if (!preserveItems)
+                lastItem = item;
+        }
+        let overflow = eventCount - histOptions.depth;
+        if (overflow > DEPTH_OVERFLOW) {
+            oldItems = cutOffEvents(oldItems, overflow);
+            eventCount -= overflow;
+        }
+        return new Branch(oldItems.append(newItems), eventCount);
+    }
+    remapping(from, to) {
+        let maps = new Mapping;
+        this.items.forEach((item, i) => {
+            let mirrorPos = item.mirrorOffset != null && i - item.mirrorOffset >= from
+                ? maps.maps.length - item.mirrorOffset : undefined;
+            maps.appendMap(item.map, mirrorPos);
+        }, from, to);
+        return maps;
+    }
+    addMaps(array) {
+        if (this.eventCount == 0)
+            return this;
+        return new Branch(this.items.append(array.map(map => new Item(map))), this.eventCount);
+    }
+    // When the collab module receives remote changes, the history has
+    // to know about those, so that it can adjust the steps that were
+    // rebased on top of the remote changes, and include the position
+    // maps for the remote changes in its array of items.
+    rebased(rebasedTransform, rebasedCount) {
+        if (!this.eventCount)
+            return this;
+        let rebasedItems = [], start = Math.max(0, this.items.length - rebasedCount);
+        let mapping = rebasedTransform.mapping;
+        let newUntil = rebasedTransform.steps.length;
+        let eventCount = this.eventCount;
+        this.items.forEach(item => { if (item.selection)
+            eventCount--; }, start);
+        let iRebased = rebasedCount;
+        this.items.forEach(item => {
+            let pos = mapping.getMirror(--iRebased);
+            if (pos == null)
+                return;
+            newUntil = Math.min(newUntil, pos);
+            let map = mapping.maps[pos];
+            if (item.step) {
+                let step = rebasedTransform.steps[pos].invert(rebasedTransform.docs[pos]);
+                let selection = item.selection && item.selection.map(mapping.slice(iRebased + 1, pos));
+                if (selection)
+                    eventCount++;
+                rebasedItems.push(new Item(map, step, selection));
+            }
+            else {
+                rebasedItems.push(new Item(map));
+            }
+        }, start);
+        let newMaps = [];
+        for (let i = rebasedCount; i < newUntil; i++)
+            newMaps.push(new Item(mapping.maps[i]));
+        let items = this.items.slice(0, start).append(newMaps).append(rebasedItems);
+        let branch = new Branch(items, eventCount);
+        if (branch.emptyItemCount() > max_empty_items)
+            branch = branch.compress(this.items.length - rebasedItems.length);
+        return branch;
+    }
+    emptyItemCount() {
+        let count = 0;
+        this.items.forEach(item => { if (!item.step)
+            count++; });
+        return count;
+    }
+    // Compressing a branch means rewriting it to push the air (map-only
+    // items) out. During collaboration, these naturally accumulate
+    // because each remote change adds one. The `upto` argument is used
+    // to ensure that only the items below a given level are compressed,
+    // because `rebased` relies on a clean, untouched set of items in
+    // order to associate old items with rebased steps.
+    compress(upto = this.items.length) {
+        let remap = this.remapping(0, upto), mapFrom = remap.maps.length;
+        let items = [], events = 0;
+        this.items.forEach((item, i) => {
+            if (i >= upto) {
+                items.push(item);
+                if (item.selection)
+                    events++;
+            }
+            else if (item.step) {
+                let step = item.step.map(remap.slice(mapFrom)), map = step && step.getMap();
+                mapFrom--;
+                if (map)
+                    remap.appendMap(map, mapFrom);
+                if (step) {
+                    let selection = item.selection && item.selection.map(remap.slice(mapFrom));
+                    if (selection)
+                        events++;
+                    let newItem = new Item(map.invert(), step, selection), merged, last = items.length - 1;
+                    if (merged = items.length && items[last].merge(newItem))
+                        items[last] = merged;
+                    else
+                        items.push(newItem);
+                }
+            }
+            else if (item.map) {
+                mapFrom--;
+            }
+        }, this.items.length, 0);
+        return new Branch(RopeSequence.from(items.reverse()), events);
+    }
+}
+Branch.empty = new Branch(RopeSequence.empty, 0);
+function cutOffEvents(items, n) {
+    let cutPoint;
+    items.forEach((item, i) => {
+        if (item.selection && (n-- == 0)) {
+            cutPoint = i;
+            return false;
+        }
+    });
+    return items.slice(cutPoint);
+}
+class Item {
+    constructor(
+    // The (forward) step map for this item.
+    map, 
+    // The inverted step
+    step, 
+    // If this is non-null, this item is the start of a group, and
+    // this selection is the starting selection for the group (the one
+    // that was active before the first step was applied)
+    selection, 
+    // If this item is the inverse of a previous mapping on the stack,
+    // this points at the inverse's offset
+    mirrorOffset) {
+        this.map = map;
+        this.step = step;
+        this.selection = selection;
+        this.mirrorOffset = mirrorOffset;
+    }
+    merge(other) {
+        if (this.step && other.step && !other.selection) {
+            let step = other.step.merge(this.step);
+            if (step)
+                return new Item(step.getMap().invert(), step, this.selection);
+        }
+    }
+}
+// The value of the state field that tracks undo/redo history for that
+// state. Will be stored in the plugin state when the history plugin
+// is active.
+class HistoryState {
+    constructor(done, undone, prevRanges, prevTime, prevComposition) {
+        this.done = done;
+        this.undone = undone;
+        this.prevRanges = prevRanges;
+        this.prevTime = prevTime;
+        this.prevComposition = prevComposition;
+    }
+}
+const DEPTH_OVERFLOW = 20;
+// Apply the latest event from one branch to the document and shift the event
+// onto the other branch.
+function histTransaction(history, state, redo) {
+    let preserveItems = mustPreserveItems(state);
+    let histOptions = historyKey.get(state).spec.config;
+    let pop = (redo ? history.undone : history.done).popEvent(state, preserveItems);
+    if (!pop)
+        return null;
+    let selection = pop.selection.resolve(pop.transform.doc);
+    let added = (redo ? history.done : history.undone).addTransform(pop.transform, state.selection.getBookmark(), histOptions, preserveItems);
+    let newHist = new HistoryState(redo ? added : pop.remaining, redo ? pop.remaining : added, null, 0, -1);
+    return pop.transform.setSelection(selection).setMeta(historyKey, { redo, historyState: newHist });
+}
+let cachedPreserveItems = false, cachedPreserveItemsPlugins = null;
+// Check whether any plugin in the given state has a
+// `historyPreserveItems` property in its spec, in which case we must
+// preserve steps exactly as they came in, so that they can be
+// rebased.
+function mustPreserveItems(state) {
+    let plugins = state.plugins;
+    if (cachedPreserveItemsPlugins != plugins) {
+        cachedPreserveItems = false;
+        cachedPreserveItemsPlugins = plugins;
+        for (let i = 0; i < plugins.length; i++)
+            if (plugins[i].spec.historyPreserveItems) {
+                cachedPreserveItems = true;
+                break;
+            }
+    }
+    return cachedPreserveItems;
+}
+const historyKey = new PluginKey("history");
+new PluginKey("closeHistory");
+function buildCommand(redo, scroll) {
+    return (state, dispatch) => {
+        let hist = historyKey.getState(state);
+        if (!hist || (redo ? hist.undone : hist.done).eventCount == 0)
+            return false;
+        if (dispatch) {
+            let tr = histTransaction(hist, state, redo);
+            if (tr)
+                dispatch(scroll ? tr.scrollIntoView() : tr);
+        }
+        return true;
+    };
+}
+/**
+A command function that undoes the last change, if any.
+*/
+const undo = buildCommand(false, true);
+/**
+A command function that redoes the last undone change, if any.
+*/
+const redo = buildCommand(true, true);
+
+function keepAlive(..._args) {
+}
+
+keepAlive(h);
+function Icon({ icon, class: className, onClick }) {
+  return /* @__PURE__ */ h(
+    "span",
+    {
+      class: clsx("milkdown-icon", className),
+      onPointerdown: onClick,
+      innerHTML: icon ? DOMPurify.sanitize(icon.trim()) : void 0
+    }
+  );
+}
+Icon.props = {
+  icon: {
+    type: String,
+    required: false
+  },
+  class: {
+    type: String,
+    required: false
+  },
+  onClick: {
+    type: Function,
+    required: false
+  }
+};
+
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+keepAlive(h, Fragment$1);
+function copyToClipboard(text) {
+  return __async(this, null, function* () {
+    try {
+      return navigator.clipboard.writeText(text);
+    } catch (e) {
+      const element = document.createElement("textarea");
+      const previouslyFocusedElement = document.activeElement;
+      element.value = text;
+      element.setAttribute("readonly", "");
+      element.style.contain = "strict";
+      element.style.position = "absolute";
+      element.style.left = "-9999px";
+      element.style.fontSize = "12pt";
+      const selection = document.getSelection();
+      const originalRange = selection ? selection.rangeCount > 0 && selection.getRangeAt(0) : null;
+      document.body.appendChild(element);
+      element.select();
+      element.selectionStart = 0;
+      element.selectionEnd = text.length;
+      document.execCommand("copy");
+      document.body.removeChild(element);
+      if (originalRange) {
+        selection.removeAllRanges();
+        selection.addRange(originalRange);
+      }
+      if (previouslyFocusedElement) {
+        previouslyFocusedElement.focus();
+      }
+    }
+  });
+}
+const CopyButton = defineComponent({
+  props: {
+    copyText: {
+      type: String,
+      required: true
+    },
+    copyIcon: {
+      type: String,
+      required: true
+    },
+    onCopy: {
+      type: Function,
+      required: true
+    },
+    text: {
+      type: String,
+      required: true
+    }
+  },
+  setup(props) {
+    const onCopyCode = () => {
+      copyToClipboard(props.text).then(() => props.onCopy(props.text)).catch(console.error);
+    };
+    return () => {
+      return /* @__PURE__ */ h(Fragment$1, null, /* @__PURE__ */ h("button", { type: "button", class: "copy-button", onClick: onCopyCode }, /* @__PURE__ */ h(Icon, { icon: props.copyIcon }), props.copyText));
+    };
+  }
+});
+
+keepAlive(h, Fragment$1);
+const LanguagePicker = defineComponent({
+  props: {
+    language: {
+      type: Object,
+      required: true
+    },
+    getReadOnly: {
+      type: Function,
+      required: true
+    },
+    config: {
+      type: Object,
+      required: true
+    },
+    getAllLanguages: {
+      type: Function,
+      required: true
+    },
+    setLanguage: {
+      type: Function,
+      required: true
+    }
+  },
+  setup({ language, config, setLanguage, getAllLanguages, getReadOnly }) {
+    const triggerRef = ref();
+    const showPicker = ref(false);
+    const searchRef = ref();
+    const pickerRef = ref();
+    const filter = ref("");
+    watch([showPicker, triggerRef, pickerRef], () => {
+      filter.value = "";
+      const picker = triggerRef.value;
+      const languageList = pickerRef.value;
+      if (!picker || !languageList) return;
+      computePosition(picker, languageList, {
+        placement: "bottom-start"
+      }).then(({ x, y }) => {
+        Object.assign(languageList.style, {
+          left: `${x}px`,
+          top: `${y}px`
+        });
+      }).catch(console.error);
+    });
+    const onTogglePicker = (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+      if (getReadOnly()) return;
+      const next = !showPicker.value;
+      showPicker.value = next;
+      if (next) {
+        setTimeout(() => {
+          var _a;
+          return (_a = searchRef.value) == null ? void 0 : _a.focus();
+        }, 0);
+      }
+    };
+    const changeFilter = (e) => {
+      const target = e.target;
+      filter.value = target.value;
+    };
+    const onSearchKeydown = (e) => {
+      if (e.key === "Escape") filter.value = "";
+    };
+    const languages = computed(() => {
+      var _a;
+      if (!showPicker.value) return [];
+      const all = (_a = getAllLanguages()) != null ? _a : [];
+      const selected = all.find(
+        (languageInfo) => languageInfo.name.toLowerCase() === language.value.toLowerCase()
+      );
+      const filtered = all.filter((languageInfo) => {
+        const currentValue = filter.value.toLowerCase();
+        return (languageInfo.name.toLowerCase().includes(currentValue) || languageInfo.alias.some(
+          (alias) => alias.toLowerCase().includes(currentValue)
+        )) && languageInfo !== selected;
+      });
+      if (filtered.length === 0) return [];
+      if (!selected) return filtered;
+      return [selected, ...filtered];
+    });
+    const clickHandler = (e) => {
+      const target = e.target;
+      if (triggerRef.value && triggerRef.value.contains(target)) return;
+      const picker = pickerRef.value;
+      const trigger = triggerRef.value;
+      if (!trigger || !picker) return;
+      if (trigger.dataset.expanded !== "true") return;
+      if (!picker.contains(target)) showPicker.value = false;
+    };
+    onMounted(() => {
+      window.addEventListener("click", clickHandler);
+    });
+    onUnmounted(() => {
+      window.removeEventListener("click", clickHandler);
+    });
+    return () => {
+      return /* @__PURE__ */ h(Fragment$1, null, /* @__PURE__ */ h(
+        "button",
+        {
+          type: "button",
+          ref: triggerRef,
+          class: "language-button",
+          onClick: onTogglePicker,
+          "data-expanded": String(showPicker.value)
+        },
+        language.value || "Text",
+        /* @__PURE__ */ h("div", { class: "expand-icon" }, /* @__PURE__ */ h(Icon, { icon: config.expandIcon }))
+      ), /* @__PURE__ */ h("div", { ref: pickerRef, class: "language-picker" }, showPicker.value ? /* @__PURE__ */ h("div", { class: "list-wrapper" }, /* @__PURE__ */ h("div", { class: "search-box" }, /* @__PURE__ */ h("div", { class: "search-icon" }, /* @__PURE__ */ h(Icon, { icon: config.searchIcon })), /* @__PURE__ */ h(
+        "input",
+        {
+          ref: searchRef,
+          class: "search-input",
+          placeholder: config.searchPlaceholder,
+          value: filter.value,
+          onInput: changeFilter,
+          onKeydown: onSearchKeydown
+        }
+      ), /* @__PURE__ */ h(
+        "div",
+        {
+          class: clsx(
+            "clear-icon",
+            filter.value.length === 0 && "hidden"
+          ),
+          onMousedown: (e) => {
+            e.preventDefault();
+            filter.value = "";
+          }
+        },
+        /* @__PURE__ */ h(Icon, { icon: config.clearSearchIcon })
+      )), /* @__PURE__ */ h(
+        "ul",
+        {
+          class: "language-list",
+          role: "listbox",
+          onKeydown: (e) => {
+            if (e.key === "Enter") {
+              const active = document.activeElement;
+              if (active instanceof HTMLElement && active.dataset.language)
+                setLanguage(active.dataset.language);
+            }
+          }
+        },
+        !languages.value.length ? /* @__PURE__ */ h("li", { class: "language-list-item no-result" }, config.noResultText) : languages.value.map((languageInfo) => /* @__PURE__ */ h(
+          "li",
+          {
+            role: "listitem",
+            tabindex: "0",
+            class: "language-list-item",
+            "aria-selected": languageInfo.name.toLowerCase() === language.value.toLowerCase(),
+            "data-language": languageInfo.name,
+            onClick: () => {
+              setLanguage(languageInfo.name);
+              showPicker.value = false;
+            }
+          },
+          config.renderLanguage(
+            languageInfo.name,
+            languageInfo.name.toLowerCase() === language.value.toLowerCase()
+          )
+        ))
+      )) : null));
+    };
+  }
+});
+
+keepAlive(h, Fragment$1);
+const PreviewPanel = defineComponent({
+  props: {
+    text: {
+      type: Object,
+      required: true
+    },
+    language: {
+      type: Object,
+      required: true
+    },
+    config: {
+      type: Object,
+      required: true
+    },
+    previewOnlyMode: {
+      type: Object,
+      required: true
+    },
+    preview: {
+      type: Object,
+      required: true
+    }
+  },
+  setup(props) {
+    const { previewOnlyMode, config, preview } = props;
+    const previewRef = ref();
+    watchEffect(() => {
+      const previewContainer = previewRef.value;
+      if (!previewContainer) return;
+      while (previewContainer.firstChild) {
+        previewContainer.removeChild(previewContainer.firstChild);
+      }
+      const previewContent = preview.value;
+      if (typeof previewContent === "string" || previewContent instanceof Element) {
+        previewContainer.innerHTML = DOMPurify.sanitize(previewContent);
+      }
+    });
+    return () => {
+      if (!preview.value) return null;
+      return /* @__PURE__ */ h("div", { class: "preview-panel" }, !previewOnlyMode.value && /* @__PURE__ */ h(Fragment$1, null, /* @__PURE__ */ h("div", { class: "preview-divider" }), /* @__PURE__ */ h("div", { class: "preview-label" }, config.previewLabel)), /* @__PURE__ */ h("div", { ref: previewRef, class: "preview" }));
+    };
+  }
+});
+
+keepAlive(h, Fragment$1);
+const CodeBlock = defineComponent({
+  props: {
+    text: {
+      type: Object,
+      required: true
+    },
+    selected: {
+      type: Object,
+      required: true
+    },
+    getReadOnly: {
+      type: Function,
+      required: true
+    },
+    codemirror: {
+      type: Object,
+      required: true
+    },
+    language: {
+      type: Object,
+      required: true
+    },
+    getAllLanguages: {
+      type: Function,
+      required: true
+    },
+    setLanguage: {
+      type: Function,
+      required: true
+    },
+    config: {
+      type: Object,
+      required: true
+    }
+  },
+  setup(props) {
+    var _a;
+    const previewOnlyByDefault = (_a = props.config.previewOnlyByDefault) != null ? _a : props.getReadOnly();
+    const previewOnlyMode = ref(previewOnlyByDefault);
+    const codemirrorHostRef = ref();
+    const preview = ref(null);
+    onMounted(() => {
+      var _a2;
+      while ((_a2 = codemirrorHostRef.value) == null ? void 0 : _a2.firstChild) {
+        codemirrorHostRef.value.removeChild(codemirrorHostRef.value.firstChild);
+      }
+      if (codemirrorHostRef.value) {
+        codemirrorHostRef.value.appendChild(props.codemirror.dom);
+      }
+    });
+    watch(
+      () => [props.text.value, props.language.value],
+      () => {
+        const result = props.config.renderPreview(
+          props.language.value,
+          props.text.value,
+          (value) => preview.value = value
+        );
+        if (result) {
+          preview.value = result;
+        }
+        const isAsyncPreview = result === void 0;
+        if (isAsyncPreview && !preview.value) {
+          preview.value = DOMPurify.sanitize(props.config.previewLoading);
+        }
+        if (result === null) {
+          preview.value = null;
+        }
+      },
+      { immediate: true }
+    );
+    const empty = () => {
+    };
+    return () => {
+      var _a2;
+      return /* @__PURE__ */ h(Fragment$1, null, /* @__PURE__ */ h("div", { class: "tools" }, /* @__PURE__ */ h(
+        LanguagePicker,
+        {
+          language: props.language,
+          config: props.config,
+          setLanguage: props.setLanguage,
+          getAllLanguages: props.getAllLanguages,
+          getReadOnly: props.getReadOnly
+        }
+      ), /* @__PURE__ */ h("div", { class: "tools-button-group" }, /* @__PURE__ */ h(
+        CopyButton,
+        {
+          copyIcon: props.config.copyIcon,
+          copyText: props.config.copyText,
+          onCopy: (_a2 = props.config.onCopy) != null ? _a2 : empty,
+          text: props.text.value
+        }
+      ), preview.value ? /* @__PURE__ */ h(
+        "button",
+        {
+          class: "preview-toggle-button",
+          onClick: () => previewOnlyMode.value = !previewOnlyMode.value
+        },
+        /* @__PURE__ */ h(
+          Icon,
+          {
+            icon: props.config.previewToggleButton(
+              previewOnlyMode.value
+            )
+          }
+        )
+      ) : null)), /* @__PURE__ */ h(
+        "div",
+        {
+          ref: codemirrorHostRef,
+          class: clsx(
+            "codemirror-host",
+            preview.value && previewOnlyMode.value && "hidden"
+          )
+        }
+      ), /* @__PURE__ */ h(
+        PreviewPanel,
+        {
+          text: props.text,
+          language: props.language,
+          config: props.config,
+          previewOnlyMode,
+          preview
+        }
+      ));
+    };
+  }
+});
+
+class CodeMirrorBlock {
+  constructor(node, view, getPos, loader, config) {
+    this.node = node;
+    this.view = view;
+    this.getPos = getPos;
+    this.loader = loader;
+    this.config = config;
+    this.selected = ref(false);
+    this.language = ref("");
+    this.text = ref("");
+    this.updating = false;
+    this.languageName = "";
+    this.forwardUpdate = (update) => {
+      var _a;
+      if (this.updating || !this.cm.hasFocus) return;
+      let offset = ((_a = this.getPos()) != null ? _a : 0) + 1;
+      const { main } = update.state.selection;
+      const selFrom = offset + main.from;
+      const selTo = offset + main.to;
+      const pmSel = this.view.state.selection;
+      if (update.docChanged || pmSel.from !== selFrom || pmSel.to !== selTo) {
+        const tr = this.view.state.tr;
+        update.changes.iterChanges((fromA, toA, fromB, toB, text) => {
+          if (text.length)
+            tr.replaceWith(
+              offset + fromA,
+              offset + toA,
+              this.view.state.schema.text(text.toString())
+            );
+          else tr.delete(offset + fromA, offset + toA);
+          offset += toB - fromB - (toA - fromA);
+        });
+        tr.setSelection(TextSelection.create(tr.doc, selFrom, selTo));
+        this.view.dispatch(tr);
+      }
+    };
+    this.createApp = () => {
+      return createApp(CodeBlock, {
+        text: this.text,
+        selected: this.selected,
+        codemirror: this.cm,
+        language: this.language,
+        getAllLanguages: this.getAllLanguages,
+        getReadOnly: () => !this.view.editable,
+        setLanguage: this.setLanguage,
+        config: this.config
+      });
+    };
+    this.codeMirrorKeymap = () => {
+      const view = this.view;
+      return [
+        { key: "ArrowUp", run: () => this.maybeEscape("line", -1) },
+        { key: "ArrowLeft", run: () => this.maybeEscape("char", -1) },
+        { key: "ArrowDown", run: () => this.maybeEscape("line", 1) },
+        { key: "ArrowRight", run: () => this.maybeEscape("char", 1) },
+        {
+          key: "Mod-Enter",
+          run: () => {
+            if (!exitCode(view.state, view.dispatch)) return false;
+            view.focus();
+            return true;
+          }
+        },
+        { key: "Mod-z", run: () => undo(view.state, view.dispatch) },
+        { key: "Shift-Mod-z", run: () => redo(view.state, view.dispatch) },
+        { key: "Mod-y", run: () => redo(view.state, view.dispatch) },
+        {
+          key: "Backspace",
+          run: () => {
+            var _a;
+            const ranges = this.cm.state.selection.ranges;
+            if (ranges.length > 1) return false;
+            const selection = ranges[0];
+            if (selection && (!selection.empty || selection.anchor > 0))
+              return false;
+            if (this.cm.state.doc.lines >= 2) return false;
+            const state = this.view.state;
+            const pos = (_a = this.getPos()) != null ? _a : 0;
+            const tr = state.tr.replaceWith(
+              pos,
+              pos + this.node.nodeSize,
+              state.schema.nodes.paragraph.createChecked({}, this.node.content)
+            );
+            tr.setSelection(TextSelection.near(tr.doc.resolve(pos)));
+            this.view.dispatch(tr);
+            this.view.focus();
+            return true;
+          }
+        }
+      ];
+    };
+    this.maybeEscape = (unit, dir) => {
+      var _a;
+      const { state } = this.cm;
+      let main = state.selection.main;
+      if (!main.empty) return false;
+      if (unit === "line") main = state.doc.lineAt(main.head);
+      if (dir < 0 ? main.from > 0 : main.to < state.doc.length) return false;
+      const targetPos = ((_a = this.getPos()) != null ? _a : 0) + (dir < 0 ? 0 : this.node.nodeSize);
+      const selection = TextSelection.near(
+        this.view.state.doc.resolve(targetPos),
+        dir
+      );
+      const tr = this.view.state.tr.setSelection(selection).scrollIntoView();
+      this.view.dispatch(tr);
+      this.view.focus();
+      return true;
+    };
+    this.setLanguage = (language) => {
+      var _a;
+      this.view.dispatch(
+        this.view.state.tr.setNodeAttribute(
+          (_a = this.getPos()) != null ? _a : 0,
+          "language",
+          language
+        )
+      );
+    };
+    this.getAllLanguages = () => {
+      return this.loader.getAll();
+    };
+    this.languageConf = new Compartment();
+    this.readOnlyConf = new Compartment();
+    this.cm = new EditorView({
+      doc: this.node.textContent,
+      root: this.view.root,
+      extensions: [
+        this.readOnlyConf.of(EditorState.readOnly.of(!this.view.editable)),
+        drawSelection(),
+        keymap.of(this.codeMirrorKeymap()),
+        this.languageConf.of([]),
+        EditorState.changeFilter.of(() => this.view.editable),
+        ...config.extensions,
+        EditorView.updateListener.of(this.forwardUpdate)
+      ]
+    });
+    this.app = this.createApp();
+    this.dom = this.createDom(this.app);
+    this.disposeSelectedWatcher = watchEffect(() => {
+      const isSelected = this.selected.value;
+      if (isSelected) {
+        this.dom.classList.add("selected");
+      } else {
+        this.dom.classList.remove("selected");
+      }
+    });
+    this.updateLanguage();
+  }
+  createDom(app) {
+    const dom = document.createElement("div");
+    dom.className = "milkdown-code-block";
+    this.text.value = this.node.textContent;
+    app.mount(dom);
+    return dom;
+  }
+  updateLanguage() {
+    const languageName = this.node.attrs.language;
+    if (languageName === this.languageName) return;
+    this.language.value = languageName;
+    const language = this.loader.load(languageName != null ? languageName : "");
+    language.then((lang) => {
+      if (lang) {
+        this.cm.dispatch({
+          effects: this.languageConf.reconfigure(lang)
+        });
+        this.languageName = languageName;
+      }
+    }).catch(console.error);
+  }
+  setSelection(anchor, head) {
+    if (!this.cm.dom.isConnected) return;
+    this.cm.focus();
+    this.updating = true;
+    this.cm.dispatch({ selection: { anchor, head } });
+    this.updating = false;
+  }
+  update(node) {
+    if (node.type !== this.node.type) return false;
+    if (this.updating) return true;
+    this.node = node;
+    this.text.value = node.textContent;
+    this.updateLanguage();
+    if (this.view.editable === this.cm.state.readOnly) {
+      this.cm.dispatch({
+        effects: this.readOnlyConf.reconfigure(
+          EditorState.readOnly.of(!this.view.editable)
+        )
+      });
+    }
+    const change = computeChange(this.cm.state.doc.toString(), node.textContent);
+    if (change) {
+      this.updating = true;
+      this.cm.dispatch({
+        changes: { from: change.from, to: change.to, insert: change.text },
+        scrollIntoView: true
+      });
+      this.updating = false;
+    }
+    return true;
+  }
+  selectNode() {
+    this.selected.value = true;
+    this.cm.focus();
+  }
+  deselectNode() {
+    this.selected.value = false;
+  }
+  stopEvent() {
+    return true;
+  }
+  destroy() {
+    this.app.unmount();
+    this.cm.destroy();
+    this.disposeSelectedWatcher();
+  }
+}
+function computeChange(oldVal, newVal) {
+  if (oldVal === newVal) return null;
+  let start = 0;
+  let oldEnd = oldVal.length;
+  let newEnd = newVal.length;
+  while (start < oldEnd && oldVal.charCodeAt(start) === newVal.charCodeAt(start))
+    ++start;
+  while (oldEnd > start && newEnd > start && oldVal.charCodeAt(oldEnd - 1) === newVal.charCodeAt(newEnd - 1)) {
+    oldEnd--;
+    newEnd--;
+  }
+  return { from: start, to: oldEnd, text: newVal.slice(start, newEnd) };
+}
+
+const codeBlockView = $view(
+  codeBlockSchema.node,
+  (ctx) => {
+    const config = ctx.get(codeBlockConfig.key);
+    const languageLoader = new LanguageLoader(config.languages);
+    return (node, view, getPos) => new CodeMirrorBlock(node, view, getPos, languageLoader, config);
+  }
+);
+withMeta(codeBlockView, {
+  displayName: "NodeView<code-block>",
+  group: "CodeBlock"
+});
+
+const codeBlockComponent = [
+  codeBlockView,
+  codeBlockConfig
+];
+
+export { codeBlockComponent, codeBlockConfig, codeBlockView, defaultConfig };
+//# sourceMappingURL=index.js.map