@jvs-milkdown/components 1.0.0

package/lib/table-block/index.js

@@ -0,0 +1,3961 @@
+import { $ctx, $view } from '@jvs-milkdown/utils';
+import { selectColCommand, moveColCommand, selectRowCommand, moveRowCommand, setAlignCommand, deleteSelectedCellsCommand, addColAfterCommand, addColBeforeCommand, addRowAfterCommand, addRowBeforeCommand, tableSchema } from '@jvs-milkdown/preset-gfm';
+import { findParent } from '@jvs-milkdown/prose';
+import { h, onMounted, onUnmounted, defineComponent, ref, shallowRef, createApp } from 'vue';
+import clsx from 'clsx';
+import DOMPurify from 'dompurify';
+import { editorViewCtx, commandsCtx } from '@jvs-milkdown/core';
+import { computePosition, offset } from '@floating-ui/dom';
+import { throttle } from 'lodash-es';
+
+var __defProp$1 = Object.defineProperty;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+function withMeta(plugin, meta) {
+  Object.assign(plugin, {
+    meta: __spreadValues$1({
+      package: "@jvs-milkdown/components"
+    }, meta)
+  });
+  return plugin;
+}
+
+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;
+};
+const defaultTableBlockConfig = {
+  renderButton: (renderType) => {
+    switch (renderType) {
+      case "add_row":
+        return "+";
+      case "add_col":
+        return "+";
+      case "delete_row":
+        return "-";
+      case "delete_col":
+        return "-";
+      case "align_col_left":
+        return "left";
+      case "align_col_center":
+        return "center";
+      case "align_col_right":
+        return "right";
+      case "col_drag_handle":
+        return "=";
+      case "row_drag_handle":
+        return "=";
+    }
+  }
+};
+const tableBlockConfig = $ctx(
+  __spreadValues({}, defaultTableBlockConfig),
+  "tableBlockConfigCtx"
+);
+withMeta(tableBlockConfig, {
+  displayName: "Config<table-block>",
+  group: "TableBlock"
+});
+
+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([]);
+
+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;
+}
+
+/**
+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]; }
+}
+
+var base = {
+  8: "Backspace",
+  9: "Tab",
+  10: "Enter",
+  12: "NumLock",
+  13: "Enter",
+  16: "Shift",
+  17: "Control",
+  18: "Alt",
+  20: "CapsLock",
+  27: "Escape",
+  32: " ",
+  33: "PageUp",
+  34: "PageDown",
+  35: "End",
+  36: "Home",
+  37: "ArrowLeft",
+  38: "ArrowUp",
+  39: "ArrowRight",
+  40: "ArrowDown",
+  44: "PrintScreen",
+  45: "Insert",
+  46: "Delete",
+  59: ";",
+  61: "=",
+  91: "Meta",
+  92: "Meta",
+  106: "*",
+  107: "+",
+  108: ",",
+  109: "-",
+  110: ".",
+  111: "/",
+  144: "NumLock",
+  145: "ScrollLock",
+  160: "Shift",
+  161: "Shift",
+  162: "Control",
+  163: "Control",
+  164: "Alt",
+  165: "Alt",
+  173: "-",
+  186: ";",
+  187: "=",
+  188: ",",
+  189: "-",
+  190: ".",
+  191: "/",
+  192: "`",
+  219: "[",
+  220: "\\",
+  221: "]",
+  222: "'"
+};
+
+var shift = {
+  48: ")",
+  49: "!",
+  50: "@",
+  51: "#",
+  52: "$",
+  53: "%",
+  54: "^",
+  55: "&",
+  56: "*",
+  57: "(",
+  59: ":",
+  61: "+",
+  173: "_",
+  186: ":",
+  187: "+",
+  188: "<",
+  189: "_",
+  190: ">",
+  191: "?",
+  192: "~",
+  219: "{",
+  220: "|",
+  221: "}",
+  222: "\""
+};
+
+var mac$1 = typeof navigator != "undefined" && /Mac/.test(navigator.platform);
+var ie = typeof navigator != "undefined" && /MSIE \d|Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(navigator.userAgent);
+
+// Fill in the digit keys
+for (var i = 0; i < 10; i++) base[48 + i] = base[96 + i] = String(i);
+
+// The function keys
+for (var i = 1; i <= 24; i++) base[i + 111] = "F" + i;
+
+// And the alphabetic keys
+for (var i = 65; i <= 90; i++) {
+  base[i] = String.fromCharCode(i + 32);
+  shift[i] = String.fromCharCode(i);
+}
+
+// For each code that doesn't have a shift-equivalent, copy the base name
+for (var code in base) if (!shift.hasOwnProperty(code)) shift[code] = base[code];
+
+function keyName(event) {
+  // On macOS, keys held with Shift and Cmd don't reflect the effect of Shift in `.key`.
+  // On IE, shift effect is never included in `.key`.
+  var ignoreKey = mac$1 && event.metaKey && event.shiftKey && !event.ctrlKey && !event.altKey ||
+      ie && event.shiftKey && event.key && event.key.length == 1 ||
+      event.key == "Unidentified";
+  var name = (!ignoreKey && event.key) ||
+    (event.shiftKey ? shift : base)[event.keyCode] ||
+    event.key || "Unidentified";
+  // Edge sometimes produces wrong names (Issue #3)
+  if (name == "Esc") name = "Escape";
+  if (name == "Del") name = "Delete";
+  // https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/8860571/
+  if (name == "Left") name = "ArrowLeft";
+  if (name == "Up") name = "ArrowUp";
+  if (name == "Right") name = "ArrowRight";
+  if (name == "Down") name = "ArrowDown";
+  return name
+}
+
+const mac = typeof navigator != "undefined" && /Mac|iP(hone|[oa]d)/.test(navigator.platform);
+const windows = typeof navigator != "undefined" && /Win/.test(navigator.platform);
+function normalizeKeyName(name) {
+    let parts = name.split(/-(?!$)/), result = parts[parts.length - 1];
+    if (result == "Space")
+        result = " ";
+    let alt, ctrl, shift, meta;
+    for (let i = 0; i < parts.length - 1; i++) {
+        let mod = parts[i];
+        if (/^(cmd|meta|m)$/i.test(mod))
+            meta = true;
+        else if (/^a(lt)?$/i.test(mod))
+            alt = true;
+        else if (/^(c|ctrl|control)$/i.test(mod))
+            ctrl = true;
+        else if (/^s(hift)?$/i.test(mod))
+            shift = true;
+        else if (/^mod$/i.test(mod)) {
+            if (mac)
+                meta = true;
+            else
+                ctrl = true;
+        }
+        else
+            throw new Error("Unrecognized modifier name: " + mod);
+    }
+    if (alt)
+        result = "Alt-" + result;
+    if (ctrl)
+        result = "Ctrl-" + result;
+    if (meta)
+        result = "Meta-" + result;
+    if (shift)
+        result = "Shift-" + result;
+    return result;
+}
+function normalize(map) {
+    let copy = Object.create(null);
+    for (let prop in map)
+        copy[normalizeKeyName(prop)] = map[prop];
+    return copy;
+}
+function modifiers(name, event, shift = true) {
+    if (event.altKey)
+        name = "Alt-" + name;
+    if (event.ctrlKey)
+        name = "Ctrl-" + name;
+    if (event.metaKey)
+        name = "Meta-" + name;
+    if (shift && event.shiftKey)
+        name = "Shift-" + name;
+    return name;
+}
+/**
+Given a set of bindings (using the same format as
+[`keymap`](https://prosemirror.net/docs/ref/#keymap.keymap)), return a [keydown
+handler](https://prosemirror.net/docs/ref/#view.EditorProps.handleKeyDown) that handles them.
+*/
+function keydownHandler(bindings) {
+    let map = normalize(bindings);
+    return function (view, event) {
+        let name = keyName(event), baseName, direct = map[modifiers(name, event)];
+        if (direct && direct(view.state, view.dispatch, view))
+            return true;
+        // A character key
+        if (name.length == 1 && name != " ") {
+            if (event.shiftKey) {
+                // In case the name was already modified by shift, try looking
+                // it up without its shift modifier
+                let noShift = map[modifiers(name, event, false)];
+                if (noShift && noShift(view.state, view.dispatch, view))
+                    return true;
+            }
+            if ((event.altKey || event.metaKey || event.ctrlKey) &&
+                // Ctrl-Alt may be used for AltGr on Windows
+                !(windows && event.ctrlKey && event.altKey) &&
+                (baseName = base[event.keyCode]) && baseName != name) {
+                // Try falling back to the keyCode when there's a modifier
+                // active or the character produced isn't ASCII, and our table
+                // produces a different name from the the keyCode. See #668,
+                // #1060, #1529.
+                let fromCode = map[modifiers(baseName, event)];
+                if (fromCode && fromCode(view.state, view.dispatch, view))
+                    return true;
+            }
+        }
+        return false;
+    };
+}
+
+//#region src/tablemap.ts
+let readFromCache;
+let addToCache;
+if (typeof WeakMap != "undefined") {
+	let cache = /* @__PURE__ */ new WeakMap();
+	readFromCache = (key) => cache.get(key);
+	addToCache = (key, value) => {
+		cache.set(key, value);
+		return value;
+	};
+} else {
+	const cache = [];
+	const cacheSize = 10;
+	let cachePos = 0;
+	readFromCache = (key) => {
+		for (let i = 0; i < cache.length; i += 2) if (cache[i] == key) return cache[i + 1];
+	};
+	addToCache = (key, value) => {
+		if (cachePos == cacheSize) cachePos = 0;
+		cache[cachePos++] = key;
+		return cache[cachePos++] = value;
+	};
+}
+/**
+* A table map describes the structure of a given table. To avoid
+* recomputing them all the time, they are cached per table node. To
+* be able to do that, positions saved in the map are relative to the
+* start of the table, rather than the start of the document.
+*
+* @public
+*/
+var TableMap = class {
+	constructor(width, height, map, problems) {
+		this.width = width;
+		this.height = height;
+		this.map = map;
+		this.problems = problems;
+	}
+	findCell(pos) {
+		for (let i = 0; i < this.map.length; i++) {
+			const curPos = this.map[i];
+			if (curPos != pos) continue;
+			const left = i % this.width;
+			const top = i / this.width | 0;
+			let right = left + 1;
+			let bottom = top + 1;
+			for (let j = 1; right < this.width && this.map[i + j] == curPos; j++) right++;
+			for (let j = 1; bottom < this.height && this.map[i + this.width * j] == curPos; j++) bottom++;
+			return {
+				left,
+				top,
+				right,
+				bottom
+			};
+		}
+		throw new RangeError(`No cell with offset ${pos} found`);
+	}
+	colCount(pos) {
+		for (let i = 0; i < this.map.length; i++) if (this.map[i] == pos) return i % this.width;
+		throw new RangeError(`No cell with offset ${pos} found`);
+	}
+	nextCell(pos, axis, dir) {
+		const { left, right, top, bottom } = this.findCell(pos);
+		if (axis == "horiz") {
+			if (dir < 0 ? left == 0 : right == this.width) return null;
+			return this.map[top * this.width + (dir < 0 ? left - 1 : right)];
+		} else {
+			if (dir < 0 ? top == 0 : bottom == this.height) return null;
+			return this.map[left + this.width * (dir < 0 ? top - 1 : bottom)];
+		}
+	}
+	rectBetween(a, b) {
+		const { left: leftA, right: rightA, top: topA, bottom: bottomA } = this.findCell(a);
+		const { left: leftB, right: rightB, top: topB, bottom: bottomB } = this.findCell(b);
+		return {
+			left: Math.min(leftA, leftB),
+			top: Math.min(topA, topB),
+			right: Math.max(rightA, rightB),
+			bottom: Math.max(bottomA, bottomB)
+		};
+	}
+	cellsInRect(rect) {
+		const result = [];
+		const seen = {};
+		for (let row = rect.top; row < rect.bottom; row++) for (let col = rect.left; col < rect.right; col++) {
+			const index = row * this.width + col;
+			const pos = this.map[index];
+			if (seen[pos]) continue;
+			seen[pos] = true;
+			if (col == rect.left && col && this.map[index - 1] == pos || row == rect.top && row && this.map[index - this.width] == pos) continue;
+			result.push(pos);
+		}
+		return result;
+	}
+	positionAt(row, col, table) {
+		for (let i = 0, rowStart = 0;; i++) {
+			const rowEnd = rowStart + table.child(i).nodeSize;
+			if (i == row) {
+				let index = col + row * this.width;
+				const rowEndIndex = (row + 1) * this.width;
+				while (index < rowEndIndex && this.map[index] < rowStart) index++;
+				return index == rowEndIndex ? rowEnd - 1 : this.map[index];
+			}
+			rowStart = rowEnd;
+		}
+	}
+	static get(table) {
+		return readFromCache(table) || addToCache(table, computeMap(table));
+	}
+};
+function computeMap(table) {
+	if (table.type.spec.tableRole != "table") throw new RangeError("Not a table node: " + table.type.name);
+	const width = findWidth(table), height = table.childCount;
+	const map = [];
+	let mapPos = 0;
+	let problems = null;
+	const colWidths = [];
+	for (let i = 0, e = width * height; i < e; i++) map[i] = 0;
+	for (let row = 0, pos = 0; row < height; row++) {
+		const rowNode = table.child(row);
+		pos++;
+		for (let i = 0;; i++) {
+			while (mapPos < map.length && map[mapPos] != 0) mapPos++;
+			if (i == rowNode.childCount) break;
+			const cellNode = rowNode.child(i);
+			const { colspan, rowspan, colwidth } = cellNode.attrs;
+			for (let h = 0; h < rowspan; h++) {
+				if (h + row >= height) {
+					(problems || (problems = [])).push({
+						type: "overlong_rowspan",
+						pos,
+						n: rowspan - h
+					});
+					break;
+				}
+				const start = mapPos + h * width;
+				for (let w = 0; w < colspan; w++) {
+					if (map[start + w] == 0) map[start + w] = pos;
+					else (problems || (problems = [])).push({
+						type: "collision",
+						row,
+						pos,
+						n: colspan - w
+					});
+					const colW = colwidth && colwidth[w];
+					if (colW) {
+						const widthIndex = (start + w) % width * 2, prev = colWidths[widthIndex];
+						if (prev == null || prev != colW && colWidths[widthIndex + 1] == 1) {
+							colWidths[widthIndex] = colW;
+							colWidths[widthIndex + 1] = 1;
+						} else if (prev == colW) colWidths[widthIndex + 1]++;
+					}
+				}
+			}
+			mapPos += colspan;
+			pos += cellNode.nodeSize;
+		}
+		const expectedPos = (row + 1) * width;
+		let missing = 0;
+		while (mapPos < expectedPos) if (map[mapPos++] == 0) missing++;
+		if (missing) (problems || (problems = [])).push({
+			type: "missing",
+			row,
+			n: missing
+		});
+		pos++;
+	}
+	if (width === 0 || height === 0) (problems || (problems = [])).push({ type: "zero_sized" });
+	const tableMap = new TableMap(width, height, map, problems);
+	let badWidths = false;
+	for (let i = 0; !badWidths && i < colWidths.length; i += 2) if (colWidths[i] != null && colWidths[i + 1] < height) badWidths = true;
+	if (badWidths) findBadColWidths(tableMap, colWidths, table);
+	return tableMap;
+}
+function findWidth(table) {
+	let width = -1;
+	let hasRowSpan = false;
+	for (let row = 0; row < table.childCount; row++) {
+		const rowNode = table.child(row);
+		let rowWidth = 0;
+		if (hasRowSpan) for (let j = 0; j < row; j++) {
+			const prevRow = table.child(j);
+			for (let i = 0; i < prevRow.childCount; i++) {
+				const cell = prevRow.child(i);
+				if (j + cell.attrs.rowspan > row) rowWidth += cell.attrs.colspan;
+			}
+		}
+		for (let i = 0; i < rowNode.childCount; i++) {
+			const cell = rowNode.child(i);
+			rowWidth += cell.attrs.colspan;
+			if (cell.attrs.rowspan > 1) hasRowSpan = true;
+		}
+		if (width == -1) width = rowWidth;
+		else if (width != rowWidth) width = Math.max(width, rowWidth);
+	}
+	return width;
+}
+function findBadColWidths(map, colWidths, table) {
+	if (!map.problems) map.problems = [];
+	const seen = {};
+	for (let i = 0; i < map.map.length; i++) {
+		const pos = map.map[i];
+		if (seen[pos]) continue;
+		seen[pos] = true;
+		const node = table.nodeAt(pos);
+		if (!node) throw new RangeError(`No cell with offset ${pos} found`);
+		let updated = null;
+		const attrs = node.attrs;
+		for (let j = 0; j < attrs.colspan; j++) {
+			const colWidth = colWidths[(i + j) % map.width * 2];
+			if (colWidth != null && (!attrs.colwidth || attrs.colwidth[j] != colWidth)) (updated || (updated = freshColWidth(attrs)))[j] = colWidth;
+		}
+		if (updated) map.problems.unshift({
+			type: "colwidth mismatch",
+			pos,
+			colwidth: updated
+		});
+	}
+}
+function freshColWidth(attrs) {
+	if (attrs.colwidth) return attrs.colwidth.slice();
+	const result = [];
+	for (let i = 0; i < attrs.colspan; i++) result.push(0);
+	return result;
+}
+/**
+* @public
+*/
+function tableNodeTypes(schema) {
+	let result = schema.cached.tableNodeTypes;
+	if (!result) {
+		result = schema.cached.tableNodeTypes = {};
+		for (const name in schema.nodes) {
+			const type = schema.nodes[name], role = type.spec.tableRole;
+			if (role) result[role] = type;
+		}
+	}
+	return result;
+}
+
+//#endregion
+//#region src/util.ts
+/**
+* @public
+*/
+new PluginKey("selectingCells");
+/**
+* @public
+*/
+function cellAround($pos) {
+	for (let d = $pos.depth - 1; d > 0; d--) if ($pos.node(d).type.spec.tableRole == "row") return $pos.node(0).resolve($pos.before(d + 1));
+	return null;
+}
+/**
+* @public
+*/
+function isInTable(state) {
+	const $head = state.selection.$head;
+	for (let d = $head.depth; d > 0; d--) if ($head.node(d).type.spec.tableRole == "row") return true;
+	return false;
+}
+/**
+* @internal
+*/
+function selectionCell(state) {
+	const sel = state.selection;
+	if ("$anchorCell" in sel && sel.$anchorCell) return sel.$anchorCell.pos > sel.$headCell.pos ? sel.$anchorCell : sel.$headCell;
+	else if ("node" in sel && sel.node && sel.node.type.spec.tableRole == "cell") return sel.$anchor;
+	const $cell = cellAround(sel.$head) || cellNear(sel.$head);
+	if ($cell) return $cell;
+	throw new RangeError(`No cell found around position ${sel.head}`);
+}
+/**
+* @public
+*/
+function cellNear($pos) {
+	for (let after = $pos.nodeAfter, pos = $pos.pos; after; after = after.firstChild, pos++) {
+		const role = after.type.spec.tableRole;
+		if (role == "cell" || role == "header_cell") return $pos.doc.resolve(pos);
+	}
+	for (let before = $pos.nodeBefore, pos = $pos.pos; before; before = before.lastChild, pos--) {
+		const role = before.type.spec.tableRole;
+		if (role == "cell" || role == "header_cell") return $pos.doc.resolve(pos - before.nodeSize);
+	}
+}
+/**
+* @public
+*/
+function pointsAtCell($pos) {
+	return $pos.parent.type.spec.tableRole == "row" && !!$pos.nodeAfter;
+}
+/**
+* @internal
+*/
+function inSameTable($cellA, $cellB) {
+	return $cellA.depth == $cellB.depth && $cellA.pos >= $cellB.start(-1) && $cellA.pos <= $cellB.end(-1);
+}
+/**
+* @public
+*/
+function nextCell($pos, axis, dir) {
+	const table = $pos.node(-1);
+	const map = TableMap.get(table);
+	const tableStart = $pos.start(-1);
+	const moved = map.nextCell($pos.pos - tableStart, axis, dir);
+	return moved == null ? null : $pos.node(0).resolve(tableStart + moved);
+}
+/**
+* @public
+*/
+function removeColSpan(attrs, pos, n = 1) {
+	const result = {
+		...attrs,
+		colspan: attrs.colspan - n
+	};
+	if (result.colwidth) {
+		result.colwidth = result.colwidth.slice();
+		result.colwidth.splice(pos, n);
+		if (!result.colwidth.some((w) => w > 0)) result.colwidth = null;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/cellselection.ts
+/**
+* A [`Selection`](http://prosemirror.net/docs/ref/#state.Selection)
+* subclass that represents a cell selection spanning part of a table.
+* With the plugin enabled, these will be created when the user
+* selects across cells, and will be drawn by giving selected cells a
+* `selectedCell` CSS class.
+*
+* @public
+*/
+var CellSelection = class CellSelection extends Selection {
+	constructor($anchorCell, $headCell = $anchorCell) {
+		const table = $anchorCell.node(-1);
+		const map = TableMap.get(table);
+		const tableStart = $anchorCell.start(-1);
+		const rect = map.rectBetween($anchorCell.pos - tableStart, $headCell.pos - tableStart);
+		const doc = $anchorCell.node(0);
+		const cells = map.cellsInRect(rect).filter((p) => p != $headCell.pos - tableStart);
+		cells.unshift($headCell.pos - tableStart);
+		const ranges = cells.map((pos) => {
+			const cell = table.nodeAt(pos);
+			if (!cell) throw new RangeError(`No cell with offset ${pos} found`);
+			const from = tableStart + pos + 1;
+			return new SelectionRange(doc.resolve(from), doc.resolve(from + cell.content.size));
+		});
+		super(ranges[0].$from, ranges[0].$to, ranges);
+		this.$anchorCell = $anchorCell;
+		this.$headCell = $headCell;
+	}
+	map(doc, mapping) {
+		const $anchorCell = doc.resolve(mapping.map(this.$anchorCell.pos));
+		const $headCell = doc.resolve(mapping.map(this.$headCell.pos));
+		if (pointsAtCell($anchorCell) && pointsAtCell($headCell) && inSameTable($anchorCell, $headCell)) {
+			const tableChanged = this.$anchorCell.node(-1) != $anchorCell.node(-1);
+			if (tableChanged && this.isRowSelection()) return CellSelection.rowSelection($anchorCell, $headCell);
+			else if (tableChanged && this.isColSelection()) return CellSelection.colSelection($anchorCell, $headCell);
+			else return new CellSelection($anchorCell, $headCell);
+		}
+		return TextSelection.between($anchorCell, $headCell);
+	}
+	content() {
+		const table = this.$anchorCell.node(-1);
+		const map = TableMap.get(table);
+		const tableStart = this.$anchorCell.start(-1);
+		const rect = map.rectBetween(this.$anchorCell.pos - tableStart, this.$headCell.pos - tableStart);
+		const seen = {};
+		const rows = [];
+		for (let row = rect.top; row < rect.bottom; row++) {
+			const rowContent = [];
+			for (let index = row * map.width + rect.left, col = rect.left; col < rect.right; col++, index++) {
+				const pos = map.map[index];
+				if (seen[pos]) continue;
+				seen[pos] = true;
+				const cellRect = map.findCell(pos);
+				let cell = table.nodeAt(pos);
+				if (!cell) throw new RangeError(`No cell with offset ${pos} found`);
+				const extraLeft = rect.left - cellRect.left;
+				const extraRight = cellRect.right - rect.right;
+				if (extraLeft > 0 || extraRight > 0) {
+					let attrs = cell.attrs;
+					if (extraLeft > 0) attrs = removeColSpan(attrs, 0, extraLeft);
+					if (extraRight > 0) attrs = removeColSpan(attrs, attrs.colspan - extraRight, extraRight);
+					if (cellRect.left < rect.left) {
+						cell = cell.type.createAndFill(attrs);
+						if (!cell) throw new RangeError(`Could not create cell with attrs ${JSON.stringify(attrs)}`);
+					} else cell = cell.type.create(attrs, cell.content);
+				}
+				if (cellRect.top < rect.top || cellRect.bottom > rect.bottom) {
+					const attrs = {
+						...cell.attrs,
+						rowspan: Math.min(cellRect.bottom, rect.bottom) - Math.max(cellRect.top, rect.top)
+					};
+					if (cellRect.top < rect.top) cell = cell.type.createAndFill(attrs);
+					else cell = cell.type.create(attrs, cell.content);
+				}
+				rowContent.push(cell);
+			}
+			rows.push(table.child(row).copy(Fragment.from(rowContent)));
+		}
+		const fragment = this.isColSelection() && this.isRowSelection() ? table : rows;
+		return new Slice(Fragment.from(fragment), 1, 1);
+	}
+	replace(tr, content = Slice.empty) {
+		const mapFrom = tr.steps.length, ranges = this.ranges;
+		for (let i = 0; i < ranges.length; i++) {
+			const { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);
+			tr.replace(mapping.map($from.pos), mapping.map($to.pos), i ? Slice.empty : content);
+		}
+		const sel = Selection.findFrom(tr.doc.resolve(tr.mapping.slice(mapFrom).map(this.to)), -1);
+		if (sel) tr.setSelection(sel);
+	}
+	replaceWith(tr, node) {
+		this.replace(tr, new Slice(Fragment.from(node), 0, 0));
+	}
+	forEachCell(f) {
+		const table = this.$anchorCell.node(-1);
+		const map = TableMap.get(table);
+		const tableStart = this.$anchorCell.start(-1);
+		const cells = map.cellsInRect(map.rectBetween(this.$anchorCell.pos - tableStart, this.$headCell.pos - tableStart));
+		for (let i = 0; i < cells.length; i++) f(table.nodeAt(cells[i]), tableStart + cells[i]);
+	}
+	isColSelection() {
+		const anchorTop = this.$anchorCell.index(-1);
+		const headTop = this.$headCell.index(-1);
+		if (Math.min(anchorTop, headTop) > 0) return false;
+		const anchorBottom = anchorTop + this.$anchorCell.nodeAfter.attrs.rowspan;
+		const headBottom = headTop + this.$headCell.nodeAfter.attrs.rowspan;
+		return Math.max(anchorBottom, headBottom) == this.$headCell.node(-1).childCount;
+	}
+	static colSelection($anchorCell, $headCell = $anchorCell) {
+		const table = $anchorCell.node(-1);
+		const map = TableMap.get(table);
+		const tableStart = $anchorCell.start(-1);
+		const anchorRect = map.findCell($anchorCell.pos - tableStart);
+		const headRect = map.findCell($headCell.pos - tableStart);
+		const doc = $anchorCell.node(0);
+		if (anchorRect.top <= headRect.top) {
+			if (anchorRect.top > 0) $anchorCell = doc.resolve(tableStart + map.map[anchorRect.left]);
+			if (headRect.bottom < map.height) $headCell = doc.resolve(tableStart + map.map[map.width * (map.height - 1) + headRect.right - 1]);
+		} else {
+			if (headRect.top > 0) $headCell = doc.resolve(tableStart + map.map[headRect.left]);
+			if (anchorRect.bottom < map.height) $anchorCell = doc.resolve(tableStart + map.map[map.width * (map.height - 1) + anchorRect.right - 1]);
+		}
+		return new CellSelection($anchorCell, $headCell);
+	}
+	isRowSelection() {
+		const table = this.$anchorCell.node(-1);
+		const map = TableMap.get(table);
+		const tableStart = this.$anchorCell.start(-1);
+		const anchorLeft = map.colCount(this.$anchorCell.pos - tableStart);
+		const headLeft = map.colCount(this.$headCell.pos - tableStart);
+		if (Math.min(anchorLeft, headLeft) > 0) return false;
+		const anchorRight = anchorLeft + this.$anchorCell.nodeAfter.attrs.colspan;
+		const headRight = headLeft + this.$headCell.nodeAfter.attrs.colspan;
+		return Math.max(anchorRight, headRight) == map.width;
+	}
+	eq(other) {
+		return other instanceof CellSelection && other.$anchorCell.pos == this.$anchorCell.pos && other.$headCell.pos == this.$headCell.pos;
+	}
+	static rowSelection($anchorCell, $headCell = $anchorCell) {
+		const table = $anchorCell.node(-1);
+		const map = TableMap.get(table);
+		const tableStart = $anchorCell.start(-1);
+		const anchorRect = map.findCell($anchorCell.pos - tableStart);
+		const headRect = map.findCell($headCell.pos - tableStart);
+		const doc = $anchorCell.node(0);
+		if (anchorRect.left <= headRect.left) {
+			if (anchorRect.left > 0) $anchorCell = doc.resolve(tableStart + map.map[anchorRect.top * map.width]);
+			if (headRect.right < map.width) $headCell = doc.resolve(tableStart + map.map[map.width * (headRect.top + 1) - 1]);
+		} else {
+			if (headRect.left > 0) $headCell = doc.resolve(tableStart + map.map[headRect.top * map.width]);
+			if (anchorRect.right < map.width) $anchorCell = doc.resolve(tableStart + map.map[map.width * (anchorRect.top + 1) - 1]);
+		}
+		return new CellSelection($anchorCell, $headCell);
+	}
+	toJSON() {
+		return {
+			type: "cell",
+			anchor: this.$anchorCell.pos,
+			head: this.$headCell.pos
+		};
+	}
+	static fromJSON(doc, json) {
+		return new CellSelection(doc.resolve(json.anchor), doc.resolve(json.head));
+	}
+	static create(doc, anchorCell, headCell = anchorCell) {
+		return new CellSelection(doc.resolve(anchorCell), doc.resolve(headCell));
+	}
+	getBookmark() {
+		return new CellBookmark(this.$anchorCell.pos, this.$headCell.pos);
+	}
+};
+CellSelection.prototype.visible = false;
+Selection.jsonID("cell", CellSelection);
+/**
+* @public
+*/
+var CellBookmark = class CellBookmark {
+	constructor(anchor, head) {
+		this.anchor = anchor;
+		this.head = head;
+	}
+	map(mapping) {
+		return new CellBookmark(mapping.map(this.anchor), mapping.map(this.head));
+	}
+	resolve(doc) {
+		const $anchorCell = doc.resolve(this.anchor), $headCell = doc.resolve(this.head);
+		if ($anchorCell.parent.type.spec.tableRole == "row" && $headCell.parent.type.spec.tableRole == "row" && $anchorCell.index() < $anchorCell.parent.childCount && $headCell.index() < $headCell.parent.childCount && inSameTable($anchorCell, $headCell)) return new CellSelection($anchorCell, $headCell);
+		else return Selection.near($headCell, 1);
+	}
+};
+
+//#endregion
+//#region src/fixtables.ts
+/**
+* @public
+*/
+new PluginKey("fix-tables");
+/**
+* Find the closest table node for a given position.
+*
+* @public
+*/
+function findTable($pos) {
+	return findParentNode((node) => node.type.spec.tableRole === "table", $pos);
+}
+/**
+* Find the closest parent node that satisfies the predicate.
+*
+* @internal
+*/
+function findParentNode(predicate, $pos) {
+	for (let depth = $pos.depth; depth >= 0; depth -= 1) {
+		const node = $pos.node(depth);
+		if (predicate(node)) return {
+			node,
+			pos: depth === 0 ? 0 : $pos.before(depth),
+			start: $pos.start(depth),
+			depth
+		};
+	}
+	return null;
+}
+
+//#endregion
+//#region src/commands.ts
+/**
+* Helper to get the selected rectangle in a table, if any. Adds table
+* map, table node, and table start offset to the object for
+* convenience.
+*
+* @public
+*/
+function selectedRect(state) {
+	const sel = state.selection;
+	const $pos = selectionCell(state);
+	const table = $pos.node(-1);
+	const tableStart = $pos.start(-1);
+	const map = TableMap.get(table);
+	return {
+		...sel instanceof CellSelection ? map.rectBetween(sel.$anchorCell.pos - tableStart, sel.$headCell.pos - tableStart) : map.findCell($pos.pos - tableStart),
+		tableStart,
+		map,
+		table
+	};
+}
+function deprecated_toggleHeader(type) {
+	return function(state, dispatch) {
+		if (!isInTable(state)) return false;
+		if (dispatch) {
+			const types = tableNodeTypes(state.schema);
+			const rect = selectedRect(state), tr = state.tr;
+			const cells = rect.map.cellsInRect(type == "column" ? {
+				left: rect.left,
+				top: 0,
+				right: rect.right,
+				bottom: rect.map.height
+			} : type == "row" ? {
+				left: 0,
+				top: rect.top,
+				right: rect.map.width,
+				bottom: rect.bottom
+			} : rect);
+			const nodes = cells.map((pos) => rect.table.nodeAt(pos));
+			for (let i = 0; i < cells.length; i++) if (nodes[i].type == types.header_cell) tr.setNodeMarkup(rect.tableStart + cells[i], types.cell, nodes[i].attrs);
+			if (tr.steps.length === 0) for (let i = 0; i < cells.length; i++) tr.setNodeMarkup(rect.tableStart + cells[i], types.header_cell, nodes[i].attrs);
+			dispatch(tr);
+		}
+		return true;
+	};
+}
+function isHeaderEnabledByType(type, rect, types) {
+	const cellPositions = rect.map.cellsInRect({
+		left: 0,
+		top: 0,
+		right: type == "row" ? rect.map.width : 1,
+		bottom: type == "column" ? rect.map.height : 1
+	});
+	for (let i = 0; i < cellPositions.length; i++) {
+		const cell = rect.table.nodeAt(cellPositions[i]);
+		if (cell && cell.type !== types.header_cell) return false;
+	}
+	return true;
+}
+/**
+* Toggles between row/column header and normal cells (Only applies to first row/column).
+* For deprecated behavior pass `useDeprecatedLogic` in options with true.
+*
+* @public
+*/
+function toggleHeader(type, options) {
+	options = options || { useDeprecatedLogic: false };
+	if (options.useDeprecatedLogic) return deprecated_toggleHeader(type);
+	return function(state, dispatch) {
+		if (!isInTable(state)) return false;
+		if (dispatch) {
+			const types = tableNodeTypes(state.schema);
+			const rect = selectedRect(state), tr = state.tr;
+			const isHeaderRowEnabled = isHeaderEnabledByType("row", rect, types);
+			const isHeaderColumnEnabled = isHeaderEnabledByType("column", rect, types);
+			const selectionStartsAt = (type === "column" ? isHeaderRowEnabled : type === "row" ? isHeaderColumnEnabled : false) ? 1 : 0;
+			const cellsRect = type == "column" ? {
+				left: 0,
+				top: selectionStartsAt,
+				right: 1,
+				bottom: rect.map.height
+			} : type == "row" ? {
+				left: selectionStartsAt,
+				top: 0,
+				right: rect.map.width,
+				bottom: 1
+			} : rect;
+			const newType = type == "column" ? isHeaderColumnEnabled ? types.cell : types.header_cell : type == "row" ? isHeaderRowEnabled ? types.cell : types.header_cell : types.cell;
+			rect.map.cellsInRect(cellsRect).forEach((relativeCellPos) => {
+				const cellPos = relativeCellPos + rect.tableStart;
+				const cell = tr.doc.nodeAt(cellPos);
+				if (cell) tr.setNodeMarkup(cellPos, newType, cell.attrs);
+			});
+			dispatch(tr);
+		}
+		return true;
+	};
+}
+/**
+* Toggles whether the selected row contains header cells.
+*
+* @public
+*/
+toggleHeader("row", { useDeprecatedLogic: true });
+/**
+* Toggles whether the selected column contains header cells.
+*
+* @public
+*/
+toggleHeader("column", { useDeprecatedLogic: true });
+/**
+* Toggles whether the selected cells are header cells.
+*
+* @public
+*/
+toggleHeader("cell", { useDeprecatedLogic: true });
+/**
+* Deletes the content of the selected cells, if they are not empty.
+*
+* @public
+*/
+function deleteCellSelection(state, dispatch) {
+	const sel = state.selection;
+	if (!(sel instanceof CellSelection)) return false;
+	if (dispatch) {
+		const tr = state.tr;
+		const baseContent = tableNodeTypes(state.schema).cell.createAndFill().content;
+		sel.forEachCell((cell, pos) => {
+			if (!cell.content.eq(baseContent)) tr.replace(tr.mapping.map(pos + 1), tr.mapping.map(pos + cell.nodeSize - 1), new Slice(baseContent, 0, 0));
+		});
+		if (tr.docChanged) dispatch(tr);
+	}
+	return true;
+}
+
+//#endregion
+//#region src/input.ts
+keydownHandler({
+	ArrowLeft: arrow("horiz", -1),
+	ArrowRight: arrow("horiz", 1),
+	ArrowUp: arrow("vert", -1),
+	ArrowDown: arrow("vert", 1),
+	"Shift-ArrowLeft": shiftArrow("horiz", -1),
+	"Shift-ArrowRight": shiftArrow("horiz", 1),
+	"Shift-ArrowUp": shiftArrow("vert", -1),
+	"Shift-ArrowDown": shiftArrow("vert", 1),
+	Backspace: deleteCellSelection,
+	"Mod-Backspace": deleteCellSelection,
+	Delete: deleteCellSelection,
+	"Mod-Delete": deleteCellSelection
+});
+function maybeSetSelection(state, dispatch, selection) {
+	if (selection.eq(state.selection)) return false;
+	if (dispatch) dispatch(state.tr.setSelection(selection).scrollIntoView());
+	return true;
+}
+/**
+* @internal
+*/
+function arrow(axis, dir) {
+	return (state, dispatch, view) => {
+		if (!view) return false;
+		const sel = state.selection;
+		if (sel instanceof CellSelection) return maybeSetSelection(state, dispatch, Selection.near(sel.$headCell, dir));
+		if (axis != "horiz" && !sel.empty) return false;
+		const end = atEndOfCell(view, axis, dir);
+		if (end == null) return false;
+		if (axis == "horiz") return maybeSetSelection(state, dispatch, Selection.near(state.doc.resolve(sel.head + dir), dir));
+		else {
+			const $cell = state.doc.resolve(end);
+			const $next = nextCell($cell, axis, dir);
+			let newSel;
+			if ($next) newSel = Selection.near($next, 1);
+			else if (dir < 0) newSel = Selection.near(state.doc.resolve($cell.before(-1)), -1);
+			else newSel = Selection.near(state.doc.resolve($cell.after(-1)), 1);
+			return maybeSetSelection(state, dispatch, newSel);
+		}
+	};
+}
+function shiftArrow(axis, dir) {
+	return (state, dispatch, view) => {
+		if (!view) return false;
+		const sel = state.selection;
+		let cellSel;
+		if (sel instanceof CellSelection) cellSel = sel;
+		else {
+			const end = atEndOfCell(view, axis, dir);
+			if (end == null) return false;
+			cellSel = new CellSelection(state.doc.resolve(end));
+		}
+		const $head = nextCell(cellSel.$headCell, axis, dir);
+		if (!$head) return false;
+		return maybeSetSelection(state, dispatch, new CellSelection(cellSel.$anchorCell, $head));
+	};
+}
+function atEndOfCell(view, axis, dir) {
+	if (!(view.state.selection instanceof TextSelection)) return null;
+	const { $head } = view.state.selection;
+	for (let d = $head.depth - 1; d >= 0; d--) {
+		const parent = $head.node(d);
+		if ((dir < 0 ? $head.index(d) : $head.indexAfter(d)) != (dir < 0 ? 0 : parent.childCount)) return null;
+		if (parent.type.spec.tableRole == "cell" || parent.type.spec.tableRole == "header_cell") {
+			const cellPos = $head.before(d);
+			const dirStr = axis == "vert" ? dir > 0 ? "down" : "up" : dir > 0 ? "right" : "left";
+			return view.endOfTextblock(dirStr) ? cellPos : null;
+		}
+	}
+	return null;
+}
+
+//#endregion
+//#region src/columnresizing.ts
+/**
+* @public
+*/
+new PluginKey("tableColumnResizing");
+
+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
+  }
+};
+
+function prepareDndContext(refs) {
+  const {
+    dragPreviewRef,
+    tableWrapperRef,
+    contentWrapperRef,
+    yLineHandleRef,
+    xLineHandleRef,
+    colHandleRef,
+    rowHandleRef
+  } = refs;
+  const preview = dragPreviewRef.value;
+  if (!preview) return;
+  const wrapper = tableWrapperRef.value;
+  if (!wrapper) return;
+  const content = contentWrapperRef.value;
+  if (!content) return;
+  const contentRoot = content.querySelector("tbody");
+  if (!contentRoot) return;
+  const previewRoot = preview.querySelector("tbody");
+  if (!previewRoot) return;
+  const yHandle = yLineHandleRef.value;
+  if (!yHandle) return;
+  const xHandle = xLineHandleRef.value;
+  if (!xHandle) return;
+  const colHandle = colHandleRef.value;
+  if (!colHandle) return;
+  const rowHandle = rowHandleRef.value;
+  if (!rowHandle) return;
+  const context = {
+    preview,
+    wrapper,
+    content,
+    contentRoot,
+    previewRoot,
+    yHandle,
+    xHandle,
+    colHandle,
+    rowHandle
+  };
+  return context;
+}
+
+function clearPreview(previewRoot) {
+  while (previewRoot.firstChild) previewRoot.removeChild(previewRoot.firstChild);
+}
+function renderPreview(axis, preview, previewRoot, tableContent, index) {
+  const { width: tableWidth, height: tableHeight } = tableContent.querySelector("tbody").getBoundingClientRect();
+  if (axis === "y") {
+    const rows = tableContent.querySelectorAll("tr");
+    const row = rows[index];
+    if (!row) return;
+    previewRoot.appendChild(row.cloneNode(true));
+    const height = row.getBoundingClientRect().height;
+    Object.assign(preview.style, {
+      width: `${tableWidth}px`,
+      height: `${height}px`
+    });
+    preview.dataset.show = "true";
+    return;
+  }
+  if (axis === "x") {
+    const rows = tableContent.querySelectorAll("tr");
+    let width;
+    Array.from(rows).forEach((row) => {
+      const col = row.children[index];
+      if (!col) return;
+      if (width === void 0) width = col.getBoundingClientRect().width;
+      const tr = col.parentElement.cloneNode(false);
+      const clone = col.cloneNode(true);
+      tr.appendChild(clone);
+      previewRoot.appendChild(tr);
+    });
+    Object.assign(preview.style, {
+      width: `${width}px`,
+      height: `${tableHeight}px`
+    });
+    preview.dataset.show = "true";
+    return;
+  }
+}
+
+function createDragRowHandler(refs, ctx) {
+  return (event) => {
+    handleDrag(refs, event, ctx, (context) => {
+      updateDragInfo("y", event, context, refs);
+      const { preview, content, previewRoot } = context;
+      clearPreview(previewRoot);
+      const { hoverIndex } = refs;
+      const [rowIndex] = hoverIndex.value;
+      renderPreview("y", preview, previewRoot, content, rowIndex);
+    });
+  };
+}
+function createDragColHandler(refs, ctx) {
+  return (event) => {
+    handleDrag(refs, event, ctx, (context) => {
+      updateDragInfo("x", event, context, refs);
+      const { preview, content, previewRoot } = context;
+      const { hoverIndex } = refs;
+      const [_, colIndex] = hoverIndex.value;
+      clearPreview(previewRoot);
+      renderPreview("x", preview, previewRoot, content, colIndex);
+    });
+  };
+}
+function updateDragInfo(axis, event, context, refs) {
+  const { xHandle, yHandle, colHandle, rowHandle, preview } = context;
+  xHandle.dataset.displayType = axis === "y" ? "indicator" : "none";
+  yHandle.dataset.displayType = axis === "x" ? "indicator" : "none";
+  if (axis === "y") {
+    colHandle.dataset.show = "false";
+    hideButtonGroup(rowHandle);
+  } else {
+    rowHandle.dataset.show = "false";
+    hideButtonGroup(colHandle);
+  }
+  const { hoverIndex, dragInfo } = refs;
+  const [rowIndex, colIndex] = hoverIndex.value;
+  dragInfo.value = {
+    startCoords: [event.clientX, event.clientY],
+    startIndex: axis === "y" ? rowIndex : colIndex,
+    endIndex: axis === "y" ? rowIndex : colIndex,
+    type: axis === "y" ? "row" : "col"
+  };
+  preview.dataset.direction = axis === "y" ? "vertical" : "horizontal";
+}
+function handleDrag(refs, event, ctx, fn) {
+  const view = ctx == null ? void 0 : ctx.get(editorViewCtx);
+  if (!(view == null ? void 0 : view.editable)) return;
+  event.stopPropagation();
+  if (event.dataTransfer) event.dataTransfer.effectAllowed = "move";
+  const context = prepareDndContext(refs);
+  if (!context) return;
+  requestAnimationFrame(() => {
+    fn(context);
+  });
+}
+function hideButtonGroup(handle) {
+  var _a;
+  (_a = handle.querySelector(".button-group")) == null ? void 0 : _a.setAttribute("data-show", "false");
+}
+
+function findNodeIndex(parent, child) {
+  for (let i = 0; i < parent.childCount; i++) {
+    if (parent.child(i) === child) return i;
+  }
+  return -1;
+}
+function findPointerIndex(event, view) {
+  var _a, _b, _c;
+  if (!view) return;
+  try {
+    const posAtCoords = view.posAtCoords({
+      left: event.clientX,
+      top: event.clientY
+    });
+    if (!posAtCoords) return;
+    const pos = posAtCoords == null ? void 0 : posAtCoords.inside;
+    if (pos == null || pos < 0) return;
+    const $pos = view.state.doc.resolve(pos);
+    const node = view.state.doc.nodeAt(pos);
+    if (!node) return;
+    const cellType = ["table_cell", "table_header"];
+    const rowType = ["table_row", "table_header_row"];
+    const cell = cellType.includes(node.type.name) ? node : (_a = findParent((node2) => cellType.includes(node2.type.name))($pos)) == null ? void 0 : _a.node;
+    const row = (_b = findParent((node2) => rowType.includes(node2.type.name))(
+      $pos
+    )) == null ? void 0 : _b.node;
+    const table = (_c = findParent((node2) => node2.type.name === "table")($pos)) == null ? void 0 : _c.node;
+    if (!cell || !row || !table) return;
+    const columnIndex = findNodeIndex(row, cell);
+    const rowIndex = findNodeIndex(table, row);
+    return [rowIndex, columnIndex];
+  } catch (e) {
+    return void 0;
+  }
+}
+function getRelatedDOM(contentWrapperRef, [rowIndex, columnIndex]) {
+  const content = contentWrapperRef.value;
+  if (!content) return;
+  const rows = content.querySelectorAll("tr");
+  const row = rows[rowIndex];
+  if (!row) return;
+  const firstRow = rows[0];
+  if (!firstRow) return;
+  const headerCol = firstRow.children[columnIndex];
+  if (!headerCol) return;
+  const col = row.children[columnIndex];
+  if (!col) return;
+  return {
+    row,
+    col,
+    headerCol
+  };
+}
+function recoveryStateBetweenUpdate(refs, view, node) {
+  if (!node) return;
+  if (!view) return;
+  const { selection } = view.state;
+  if (!(selection instanceof CellSelection)) return;
+  const { $from } = selection;
+  const table = findTable($from);
+  if (!table || table.node !== node) return;
+  if (selection.isColSelection()) {
+    const { $head } = selection;
+    const colIndex = $head.index($head.depth - 1);
+    computeColHandlePositionByIndex({
+      refs,
+      index: [0, colIndex],
+      before: (handleDOM) => {
+        var _a;
+        (_a = handleDOM.querySelector(".button-group")) == null ? void 0 : _a.setAttribute("data-show", "true");
+      }
+    });
+    return;
+  }
+  if (selection.isRowSelection()) {
+    const { $head } = selection;
+    const rowNode = findParent(
+      (node2) => node2.type.name === "table_row" || node2.type.name === "table_header_row"
+    )($head);
+    if (!rowNode) return;
+    const rowIndex = findNodeIndex(table.node, rowNode.node);
+    computeRowHandlePositionByIndex({
+      refs,
+      index: [rowIndex, 0],
+      before: (handleDOM) => {
+        var _a;
+        if (rowIndex > 0)
+          (_a = handleDOM.querySelector(".button-group")) == null ? void 0 : _a.setAttribute("data-show", "true");
+      }
+    });
+  }
+}
+function computeColHandlePositionByIndex({
+  refs,
+  index,
+  before,
+  after
+}) {
+  const { contentWrapperRef, colHandleRef, hoverIndex } = refs;
+  const colHandle = colHandleRef.value;
+  if (!colHandle) return;
+  hoverIndex.value = index;
+  const dom = getRelatedDOM(contentWrapperRef, index);
+  if (!dom) return;
+  const { headerCol: col } = dom;
+  colHandle.dataset.show = "true";
+  if (before) before(colHandle);
+  computePosition(col, colHandle, { placement: "top" }).then(({ x, y }) => {
+    Object.assign(colHandle.style, {
+      left: `${x}px`,
+      top: `${y}px`
+    });
+    if (after) after(colHandle);
+  }).catch(console.error);
+}
+function computeRowHandlePositionByIndex({
+  refs,
+  index,
+  before,
+  after
+}) {
+  const { contentWrapperRef, rowHandleRef, hoverIndex } = refs;
+  const rowHandle = rowHandleRef.value;
+  if (!rowHandle) return;
+  hoverIndex.value = index;
+  const dom = getRelatedDOM(contentWrapperRef, index);
+  if (!dom) return;
+  const { row } = dom;
+  rowHandle.dataset.show = "true";
+  if (before) before(rowHandle);
+  computePosition(row, rowHandle, { placement: "left" }).then(({ x, y }) => {
+    Object.assign(rowHandle.style, {
+      left: `${x}px`,
+      top: `${y}px`
+    });
+    if (after) after(rowHandle);
+  }).catch(console.error);
+}
+
+function findDragOverElement(elements, pointer, axis) {
+  const startProp = axis === "x" ? "left" : "top";
+  const endProp = axis === "x" ? "right" : "bottom";
+  const lastIndex = elements.length - 1;
+  const index = elements.findIndex((el, index2) => {
+    const rect = el.getBoundingClientRect();
+    const boundaryStart = rect[startProp];
+    const boundaryEnd = rect[endProp];
+    if (boundaryStart <= pointer && pointer <= boundaryEnd) return true;
+    if (index2 === lastIndex && pointer > boundaryEnd) return true;
+    if (index2 === 0 && pointer < boundaryStart) return true;
+    return false;
+  });
+  const element = elements[index];
+  return element ? [element, index] : void 0;
+}
+function getDragOverColumn(table, pointerX) {
+  const firstRow = table.querySelector("tr");
+  if (!firstRow) return;
+  const cells = Array.from(firstRow.children);
+  return findDragOverElement(cells, pointerX, "x");
+}
+function getDragOverRow(table, pointerY) {
+  const rows = Array.from(table.querySelectorAll("tr"));
+  return findDragOverElement(rows, pointerY, "y");
+}
+
+function createDragOverHandler(refs) {
+  return throttle((e) => {
+    const context = prepareDndContext(refs);
+    if (!context) return;
+    const { preview, content, contentRoot, xHandle, yHandle } = context;
+    const { dragInfo, hoverIndex } = refs;
+    if (preview.dataset.show === "false") return;
+    const dom = getRelatedDOM(refs.contentWrapperRef, hoverIndex.value);
+    if (!dom) return;
+    const firstRow = contentRoot.querySelector("tr");
+    if (!firstRow) return;
+    const info = dragInfo.value;
+    if (!info) return;
+    if (!contentRoot.offsetParent) return;
+    const wrapperOffsetTop = contentRoot.offsetParent.offsetTop;
+    const wrapperOffsetLeft = contentRoot.offsetParent.offsetLeft;
+    if (info.type === "col") {
+      const width = dom.col.getBoundingClientRect().width;
+      const { left, width: fullWidth } = contentRoot.getBoundingClientRect();
+      const leftGap = wrapperOffsetLeft - left;
+      const previewLeft = e.clientX + leftGap - width / 2;
+      const [startX] = info.startCoords;
+      const direction = startX < e.clientX ? "right" : "left";
+      preview.style.top = `${wrapperOffsetTop}px`;
+      const previewLeftOffset = previewLeft < left + leftGap - 20 ? left + leftGap - 20 : previewLeft > left + fullWidth + leftGap - width + 20 ? left + fullWidth + leftGap - width + 20 : previewLeft;
+      preview.style.left = `${previewLeftOffset}px`;
+      const dragOverColumn = getDragOverColumn(contentRoot, e.clientX);
+      if (dragOverColumn) {
+        const [col, index] = dragOverColumn;
+        const yHandleWidth = yHandle.getBoundingClientRect().width;
+        const contentBoundary = content.getBoundingClientRect();
+        info.endIndex = index;
+        computePosition(col, yHandle, {
+          placement: direction === "left" ? "left" : "right",
+          middleware: [offset(direction === "left" ? -1 * yHandleWidth : 0)]
+        }).then(({ x }) => {
+          yHandle.dataset.show = "true";
+          Object.assign(yHandle.style, {
+            height: `${contentBoundary.height}px`,
+            left: `${x}px`,
+            top: `${wrapperOffsetTop}px`
+          });
+        }).catch(console.error);
+      }
+    } else if (info.type === "row") {
+      const height = dom.row.getBoundingClientRect().height;
+      const { top, height: fullHeight } = contentRoot.getBoundingClientRect();
+      const topGap = wrapperOffsetTop - top;
+      const previewTop = e.clientY + topGap - height / 2;
+      const [_, startY] = info.startCoords;
+      const direction = startY < e.clientY ? "down" : "up";
+      const previewTopOffset = previewTop < top + topGap - 20 ? top + topGap - 20 : previewTop > top + fullHeight + topGap - height + 20 ? top + fullHeight + topGap - height + 20 : previewTop;
+      preview.style.top = `${previewTopOffset}px`;
+      preview.style.left = `${wrapperOffsetLeft}px`;
+      const dragOverRow = getDragOverRow(contentRoot, e.clientY);
+      if (dragOverRow) {
+        const [row, index] = dragOverRow;
+        const xHandleHeight = xHandle.getBoundingClientRect().height;
+        const contentBoundary = content.getBoundingClientRect();
+        info.endIndex = index;
+        computePosition(row, xHandle, {
+          placement: direction === "up" ? "top" : "bottom",
+          middleware: [offset(direction === "up" ? -1 * xHandleHeight : 0)]
+        }).then(({ y }) => {
+          xHandle.dataset.show = "true";
+          Object.assign(xHandle.style, {
+            width: `${contentBoundary.width}px`,
+            top: `${y}px`
+          });
+        }).catch(console.error);
+      }
+    }
+  }, 20);
+}
+
+function useDragHandlers(refs, ctx, getPos) {
+  const { dragPreviewRef, yLineHandleRef, xLineHandleRef, dragInfo } = refs;
+  const dragRow = createDragRowHandler(refs, ctx);
+  const dragCol = createDragColHandler(refs, ctx);
+  const onDragEnd = () => {
+    const preview = dragPreviewRef.value;
+    if (!preview) return;
+    if (preview.dataset.show === "false") return;
+    const previewRoot = preview == null ? void 0 : preview.querySelector("tbody");
+    while (previewRoot == null ? void 0 : previewRoot.firstChild)
+      previewRoot == null ? void 0 : previewRoot.removeChild(previewRoot.firstChild);
+    if (preview) preview.dataset.show = "false";
+  };
+  const onDrop = () => {
+    var _a;
+    const preview = dragPreviewRef.value;
+    if (!preview) return;
+    const yHandle = yLineHandleRef.value;
+    if (!yHandle) return;
+    const xHandle = xLineHandleRef.value;
+    if (!xHandle) return;
+    const info = dragInfo.value;
+    if (!info) return;
+    if (!ctx) return;
+    if (preview.dataset.show === "false") return;
+    const colHandle = refs.colHandleRef.value;
+    if (!colHandle) return;
+    const rowHandle = refs.rowHandleRef.value;
+    if (!rowHandle) return;
+    yHandle.dataset.show = "false";
+    xHandle.dataset.show = "false";
+    if (info.startIndex === info.endIndex) return;
+    const commands = ctx.get(commandsCtx);
+    const payload = {
+      from: info.startIndex,
+      to: info.endIndex,
+      pos: ((_a = getPos == null ? void 0 : getPos()) != null ? _a : 0) + 1
+    };
+    if (info.type === "col") {
+      commands.call(selectColCommand.key, {
+        pos: payload.pos,
+        index: info.startIndex
+      });
+      commands.call(moveColCommand.key, payload);
+      const index = [0, info.endIndex];
+      computeColHandlePositionByIndex({
+        refs,
+        index
+      });
+    } else {
+      commands.call(selectRowCommand.key, {
+        pos: payload.pos,
+        index: info.startIndex
+      });
+      commands.call(moveRowCommand.key, payload);
+      const index = [info.endIndex, 0];
+      computeRowHandlePositionByIndex({
+        refs,
+        index
+      });
+    }
+    requestAnimationFrame(() => {
+      ctx.get(editorViewCtx).focus();
+    });
+  };
+  const onDragOver = createDragOverHandler(refs);
+  onMounted(() => {
+    window.addEventListener("dragover", onDragOver);
+    window.addEventListener("dragend", onDragEnd);
+    window.addEventListener("drop", onDrop);
+  });
+  onUnmounted(() => {
+    window.removeEventListener("dragover", onDragOver);
+    window.removeEventListener("dragend", onDragEnd);
+    window.removeEventListener("drop", onDrop);
+  });
+  return {
+    dragRow,
+    dragCol
+  };
+}
+
+function useOperation(refs, ctx, getPos) {
+  const {
+    xLineHandleRef,
+    contentWrapperRef,
+    colHandleRef,
+    rowHandleRef,
+    hoverIndex,
+    lineHoverIndex
+  } = refs;
+  const onAddRow = () => {
+    var _a, _b, _c;
+    if (!ctx) return;
+    const xHandle = xLineHandleRef.value;
+    if (!xHandle) return;
+    const [rowIndex] = lineHoverIndex.value;
+    if (rowIndex < 0) return;
+    if (!ctx.get(editorViewCtx).editable) return;
+    const rows = Array.from(
+      (_b = (_a = contentWrapperRef.value) == null ? void 0 : _a.querySelectorAll("tr")) != null ? _b : []
+    );
+    const commands = ctx.get(commandsCtx);
+    const pos = ((_c = getPos == null ? void 0 : getPos()) != null ? _c : 0) + 1;
+    if (rows.length === rowIndex) {
+      commands.call(selectRowCommand.key, { pos, index: rowIndex - 1 });
+      commands.call(addRowAfterCommand.key);
+    } else {
+      commands.call(selectRowCommand.key, { pos, index: rowIndex });
+      commands.call(addRowBeforeCommand.key);
+    }
+    commands.call(selectRowCommand.key, { pos, index: rowIndex });
+    xHandle.dataset.show = "false";
+  };
+  const onAddCol = () => {
+    var _a, _b, _c, _d;
+    if (!ctx) return;
+    const xHandle = xLineHandleRef.value;
+    if (!xHandle) return;
+    const [_, colIndex] = lineHoverIndex.value;
+    if (colIndex < 0) return;
+    if (!ctx.get(editorViewCtx).editable) return;
+    const cols = Array.from(
+      (_c = (_b = (_a = contentWrapperRef.value) == null ? void 0 : _a.querySelector("tr")) == null ? void 0 : _b.children) != null ? _c : []
+    );
+    const commands = ctx.get(commandsCtx);
+    const pos = ((_d = getPos == null ? void 0 : getPos()) != null ? _d : 0) + 1;
+    if (cols.length === colIndex) {
+      commands.call(selectColCommand.key, { pos, index: colIndex - 1 });
+      commands.call(addColAfterCommand.key);
+    } else {
+      commands.call(selectColCommand.key, { pos, index: colIndex });
+      commands.call(addColBeforeCommand.key);
+    }
+    commands.call(selectColCommand.key, { pos, index: colIndex });
+  };
+  const selectCol = () => {
+    var _a, _b;
+    if (!ctx) return;
+    const [_, colIndex] = hoverIndex.value;
+    const commands = ctx.get(commandsCtx);
+    const pos = ((_a = getPos == null ? void 0 : getPos()) != null ? _a : 0) + 1;
+    commands.call(selectColCommand.key, { pos, index: colIndex });
+    const buttonGroup = (_b = colHandleRef.value) == null ? void 0 : _b.querySelector(".button-group");
+    if (buttonGroup)
+      buttonGroup.dataset.show = buttonGroup.dataset.show === "true" ? "false" : "true";
+  };
+  const selectRow = () => {
+    var _a, _b;
+    if (!ctx) return;
+    const [rowIndex, _] = hoverIndex.value;
+    const commands = ctx.get(commandsCtx);
+    const pos = ((_a = getPos == null ? void 0 : getPos()) != null ? _a : 0) + 1;
+    commands.call(selectRowCommand.key, { pos, index: rowIndex });
+    const buttonGroup = (_b = rowHandleRef.value) == null ? void 0 : _b.querySelector(".button-group");
+    if (buttonGroup && rowIndex > 0)
+      buttonGroup.dataset.show = buttonGroup.dataset.show === "true" ? "false" : "true";
+  };
+  const deleteSelected = (e) => {
+    if (!ctx) return;
+    if (!ctx.get(editorViewCtx).editable) return;
+    e.preventDefault();
+    e.stopPropagation();
+    const commands = ctx.get(commandsCtx);
+    commands.call(deleteSelectedCellsCommand.key);
+    requestAnimationFrame(() => {
+      ctx.get(editorViewCtx).focus();
+    });
+  };
+  const onAlign = (direction) => (e) => {
+    if (!ctx) return;
+    if (!ctx.get(editorViewCtx).editable) return;
+    e.preventDefault();
+    e.stopPropagation();
+    const commands = ctx.get(commandsCtx);
+    commands.call(setAlignCommand.key, direction);
+    requestAnimationFrame(() => {
+      ctx.get(editorViewCtx).focus();
+    });
+  };
+  return {
+    onAddRow,
+    onAddCol,
+    selectCol,
+    selectRow,
+    deleteSelected,
+    onAlign
+  };
+}
+
+function createPointerMoveHandler(refs, view) {
+  return throttle((e) => {
+    if (!(view == null ? void 0 : view.editable)) return;
+    const {
+      contentWrapperRef,
+      yLineHandleRef,
+      xLineHandleRef,
+      colHandleRef,
+      rowHandleRef,
+      hoverIndex,
+      lineHoverIndex
+    } = refs;
+    const yHandle = yLineHandleRef.value;
+    if (!yHandle) return;
+    const xHandle = xLineHandleRef.value;
+    if (!xHandle) return;
+    const content = contentWrapperRef.value;
+    if (!content) return;
+    const rowHandle = rowHandleRef.value;
+    if (!rowHandle) return;
+    const colHandle = colHandleRef.value;
+    if (!colHandle) return;
+    const index = findPointerIndex(e, view);
+    if (!index) return;
+    const dom = getRelatedDOM(contentWrapperRef, index);
+    if (!dom) return;
+    const [rowIndex, colIndex] = index;
+    const boundary = dom.col.getBoundingClientRect();
+    const closeToBoundaryLeft = Math.abs(e.clientX - boundary.left) < 8;
+    const closeToBoundaryRight = Math.abs(boundary.right - e.clientX) < 8;
+    const closeToBoundaryTop = Math.abs(e.clientY - boundary.top) < 8;
+    const closeToBoundaryBottom = Math.abs(boundary.bottom - e.clientY) < 8;
+    const closeToBoundary = closeToBoundaryLeft || closeToBoundaryRight || closeToBoundaryTop || closeToBoundaryBottom;
+    const rowButtonGroup = rowHandle.querySelector(".button-group");
+    const colButtonGroup = colHandle.querySelector(".button-group");
+    if (rowButtonGroup) rowButtonGroup.dataset.show = "false";
+    if (colButtonGroup) colButtonGroup.dataset.show = "false";
+    if (closeToBoundary) {
+      const contentBoundary = content.getBoundingClientRect();
+      rowHandle.dataset.show = "false";
+      colHandle.dataset.show = "false";
+      xHandle.dataset.displayType = "tool";
+      yHandle.dataset.displayType = "tool";
+      const yHandleWidth = yHandle.getBoundingClientRect().width;
+      const xHandleHeight = xHandle.getBoundingClientRect().height;
+      if (closeToBoundaryLeft || closeToBoundaryRight) {
+        lineHoverIndex.value[1] = closeToBoundaryLeft ? colIndex : colIndex + 1;
+        computePosition(dom.col, yHandle, {
+          placement: closeToBoundaryLeft ? "left" : "right",
+          middleware: [offset(closeToBoundaryLeft ? -1 * yHandleWidth : 0)]
+        }).then(({ x }) => {
+          yHandle.dataset.show = "true";
+          Object.assign(yHandle.style, {
+            height: `${contentBoundary.height}px`,
+            left: `${x}px`
+          });
+        }).catch(console.error);
+      } else {
+        yHandle.dataset.show = "false";
+      }
+      if (index[0] !== 0 && (closeToBoundaryTop || closeToBoundaryBottom)) {
+        lineHoverIndex.value[0] = closeToBoundaryTop ? rowIndex : rowIndex + 1;
+        computePosition(dom.row, xHandle, {
+          placement: closeToBoundaryTop ? "top" : "bottom",
+          middleware: [offset(closeToBoundaryTop ? -1 * xHandleHeight : 0)]
+        }).then(({ y }) => {
+          xHandle.dataset.show = "true";
+          Object.assign(xHandle.style, {
+            width: `${contentBoundary.width}px`,
+            top: `${y}px`
+          });
+        }).catch(console.error);
+      } else {
+        xHandle.dataset.show = "false";
+      }
+      return;
+    }
+    lineHoverIndex.value = [-1, -1];
+    yHandle.dataset.show = "false";
+    xHandle.dataset.show = "false";
+    rowHandle.dataset.show = "true";
+    colHandle.dataset.show = "true";
+    computeRowHandlePositionByIndex({
+      refs,
+      index
+    });
+    computeColHandlePositionByIndex({
+      refs,
+      index
+    });
+    hoverIndex.value = index;
+  }, 20);
+}
+function createPointerLeaveHandler(refs) {
+  return () => {
+    const { rowHandleRef, colHandleRef, yLineHandleRef, xLineHandleRef } = refs;
+    setTimeout(() => {
+      const rowHandle = rowHandleRef.value;
+      if (!rowHandle) return;
+      const colHandle = colHandleRef.value;
+      if (!colHandle) return;
+      const yHandle = yLineHandleRef.value;
+      if (!yHandle) return;
+      const xHandle = xLineHandleRef.value;
+      if (!xHandle) return;
+      rowHandle.dataset.show = "false";
+      colHandle.dataset.show = "false";
+      yHandle.dataset.show = "false";
+      xHandle.dataset.show = "false";
+    }, 200);
+  };
+}
+function usePointerHandlers(refs, view) {
+  const pointerMove = createPointerMoveHandler(refs, view);
+  const pointerLeave = createPointerLeaveHandler(refs);
+  return {
+    pointerMove,
+    pointerLeave
+  };
+}
+
+keepAlive(h);
+const TableBlock = defineComponent({
+  props: {
+    view: {
+      type: Object,
+      required: true
+    },
+    ctx: {
+      type: Object,
+      required: true
+    },
+    getPos: {
+      type: Function,
+      required: true
+    },
+    config: {
+      type: Object,
+      required: true
+    },
+    onMount: {
+      type: Function,
+      required: true
+    },
+    node: {
+      type: Object,
+      required: true
+    }
+  },
+  setup({ view, node, ctx, getPos, config, onMount }) {
+    const contentWrapperRef = ref();
+    const contentWrapperFunctionRef = (div) => {
+      if (div == null) return;
+      if (div instanceof HTMLElement) {
+        contentWrapperRef.value = div;
+        onMount(div);
+      } else {
+        contentWrapperRef.value = void 0;
+      }
+    };
+    const colHandleRef = ref();
+    const rowHandleRef = ref();
+    const xLineHandleRef = ref();
+    const yLineHandleRef = ref();
+    const tableWrapperRef = ref();
+    const dragPreviewRef = ref();
+    const hoverIndex = ref([0, 0]);
+    const lineHoverIndex = ref([-1, -1]);
+    const dragInfo = ref();
+    const refs = {
+      dragPreviewRef,
+      tableWrapperRef,
+      contentWrapperRef,
+      yLineHandleRef,
+      xLineHandleRef,
+      colHandleRef,
+      rowHandleRef,
+      hoverIndex,
+      lineHoverIndex,
+      dragInfo
+    };
+    const { pointerLeave, pointerMove } = usePointerHandlers(refs, view);
+    const { dragRow, dragCol } = useDragHandlers(refs, ctx, getPos);
+    const {
+      onAddRow,
+      onAddCol,
+      selectCol,
+      selectRow,
+      deleteSelected,
+      onAlign
+    } = useOperation(refs, ctx, getPos);
+    onMounted(() => {
+      requestAnimationFrame(() => {
+        if (view.editable) recoveryStateBetweenUpdate(refs, view, node.value);
+      });
+    });
+    return () => {
+      return /* @__PURE__ */ h(
+        "div",
+        {
+          onDragstart: (e) => e.preventDefault(),
+          onDragover: (e) => e.preventDefault(),
+          onDragleave: (e) => e.preventDefault(),
+          onPointermove: pointerMove,
+          onPointerleave: pointerLeave
+        },
+        /* @__PURE__ */ h(
+          "div",
+          {
+            "data-show": "false",
+            contenteditable: "false",
+            draggable: "true",
+            "data-role": "col-drag-handle",
+            class: "handle cell-handle",
+            onDragstart: dragCol,
+            onClick: selectCol,
+            onPointerdown: (e) => e.stopPropagation(),
+            onPointermove: (e) => e.stopPropagation(),
+            ref: colHandleRef
+          },
+          /* @__PURE__ */ h(Icon, { icon: config.renderButton("col_drag_handle") }),
+          /* @__PURE__ */ h(
+            "div",
+            {
+              "data-show": "false",
+              class: "button-group",
+              onPointermove: (e) => e.stopPropagation()
+            },
+            /* @__PURE__ */ h("button", { type: "button", onPointerdown: onAlign("left") }, /* @__PURE__ */ h(Icon, { icon: config.renderButton("align_col_left") })),
+            /* @__PURE__ */ h("button", { type: "button", onPointerdown: onAlign("center") }, /* @__PURE__ */ h(Icon, { icon: config.renderButton("align_col_center") })),
+            /* @__PURE__ */ h("button", { type: "button", onPointerdown: onAlign("right") }, /* @__PURE__ */ h(Icon, { icon: config.renderButton("align_col_right") })),
+            /* @__PURE__ */ h("button", { type: "button", onPointerdown: deleteSelected }, /* @__PURE__ */ h(Icon, { icon: config.renderButton("delete_col") }))
+          )
+        ),
+        /* @__PURE__ */ h(
+          "div",
+          {
+            "data-show": "false",
+            contenteditable: "false",
+            draggable: "true",
+            "data-role": "row-drag-handle",
+            class: "handle cell-handle",
+            onDragstart: dragRow,
+            onClick: selectRow,
+            onPointerdown: (e) => e.stopPropagation(),
+            onPointermove: (e) => e.stopPropagation(),
+            ref: rowHandleRef
+          },
+          /* @__PURE__ */ h(Icon, { icon: config.renderButton("row_drag_handle") }),
+          /* @__PURE__ */ h(
+            "div",
+            {
+              "data-show": "false",
+              class: "button-group",
+              onPointermove: (e) => e.stopPropagation()
+            },
+            /* @__PURE__ */ h("button", { type: "button", onPointerdown: deleteSelected }, /* @__PURE__ */ h(Icon, { icon: config.renderButton("delete_row") }))
+          )
+        ),
+        /* @__PURE__ */ h("div", { class: "table-wrapper", ref: tableWrapperRef }, /* @__PURE__ */ h(
+          "div",
+          {
+            "data-show": "false",
+            class: "drag-preview",
+            "data-direction": "vertical",
+            ref: dragPreviewRef
+          },
+          /* @__PURE__ */ h("table", null, /* @__PURE__ */ h("tbody", null))
+        ), /* @__PURE__ */ h(
+          "div",
+          {
+            "data-show": "false",
+            contenteditable: "false",
+            "data-display-type": "tool",
+            "data-role": "x-line-drag-handle",
+            class: "handle line-handle",
+            ref: xLineHandleRef
+          },
+          /* @__PURE__ */ h("button", { type: "button", onClick: onAddRow, class: "add-button" }, /* @__PURE__ */ h(Icon, { icon: config.renderButton("add_row") }))
+        ), /* @__PURE__ */ h(
+          "div",
+          {
+            "data-show": "false",
+            contenteditable: "false",
+            "data-display-type": "tool",
+            "data-role": "y-line-drag-handle",
+            class: "handle line-handle",
+            ref: yLineHandleRef
+          },
+          /* @__PURE__ */ h("button", { type: "button", onClick: onAddCol, class: "add-button" }, /* @__PURE__ */ h(Icon, { icon: config.renderButton("add_col") }))
+        ), /* @__PURE__ */ h("table", { ref: contentWrapperFunctionRef, class: "children" }))
+      );
+    };
+  }
+});
+
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _TableNodeView_instances, handleClick_fn;
+class TableNodeView {
+  constructor(ctx, node, view, getPos) {
+    this.ctx = ctx;
+    this.node = node;
+    this.view = view;
+    this.getPos = getPos;
+    __privateAdd(this, _TableNodeView_instances);
+    const dom = document.createElement("div");
+    dom.className = "milkdown-table-block";
+    const contentDOM = document.createElement("tbody");
+    this.contentDOM = contentDOM;
+    contentDOM.setAttribute("data-content-dom", "true");
+    contentDOM.classList.add("content-dom");
+    this.nodeRef = shallowRef(node);
+    const app = createApp(TableBlock, {
+      view,
+      ctx,
+      getPos,
+      config: ctx.get(tableBlockConfig.key),
+      onMount: (div) => {
+        div.appendChild(contentDOM);
+      },
+      node: this.nodeRef
+    });
+    app.mount(dom);
+    this.app = app;
+    this.dom = dom;
+  }
+  update(node) {
+    if (node.type !== this.node.type) return false;
+    if (node.sameMarkup(this.node) && node.content.eq(this.node.content))
+      return false;
+    this.node = node;
+    this.nodeRef.value = node;
+    return true;
+  }
+  stopEvent(e) {
+    if (e.type === "drop" || e.type.startsWith("drag")) return true;
+    if (e.type === "mousedown" || e.type === "pointerdown") {
+      if (e.target instanceof Element && e.target.closest("button")) return true;
+      const target = e.target;
+      if (target instanceof HTMLElement && (target.closest("th") || target.closest("td"))) {
+        const event = e;
+        return __privateMethod(this, _TableNodeView_instances, handleClick_fn).call(this, event);
+      }
+    }
+    return false;
+  }
+  ignoreMutation(mutation) {
+    if (!this.dom || !this.contentDOM) return true;
+    if (mutation.type === "selection") return false;
+    if (this.contentDOM === mutation.target && mutation.type === "attributes")
+      return true;
+    if (this.contentDOM.contains(mutation.target)) return false;
+    return true;
+  }
+  destroy() {
+    this.app.unmount();
+    this.dom.remove();
+    this.contentDOM.remove();
+  }
+}
+_TableNodeView_instances = new WeakSet();
+handleClick_fn = function(event) {
+  const view = this.view;
+  if (!view.editable) return false;
+  const { state, dispatch } = view;
+  const pos = view.posAtCoords({ left: event.clientX, top: event.clientY });
+  if (!pos) return false;
+  const $pos = state.doc.resolve(pos.inside);
+  const node = findParent(
+    (node2) => node2.type.name === "table_cell" || node2.type.name === "table_header"
+  )($pos);
+  if (!node) return false;
+  if (state.selection instanceof TextSelection) {
+    const currentNode = findParent(
+      (node2) => node2.type.name === "table_cell" || node2.type.name === "table_header"
+    )(state.selection.$from);
+    if ((currentNode == null ? void 0 : currentNode.node) === node.node) return false;
+  }
+  const { from } = node;
+  const selection = NodeSelection.create(state.doc, from + 1);
+  if (state.selection.eq(selection)) return false;
+  if (state.selection instanceof CellSelection) {
+    setTimeout(() => {
+      dispatch(state.tr.setSelection(selection).scrollIntoView());
+    }, 20);
+  } else {
+    requestAnimationFrame(() => {
+      dispatch(state.tr.setSelection(selection).scrollIntoView());
+    });
+  }
+  return true;
+};
+const tableBlockView = $view(
+  tableSchema.node,
+  (ctx) => {
+    return (initialNode, view, getPos) => {
+      return new TableNodeView(ctx, initialNode, view, getPos);
+    };
+  }
+);
+withMeta(tableBlockView, {
+  displayName: "NodeView<table-block>",
+  group: "TableBlock"
+});
+
+const tableBlock = [tableBlockConfig, tableBlockView];
+
+export { TableNodeView, tableBlock, tableBlockConfig, tableBlockView };
+//# sourceMappingURL=index.js.map