@tiptap/extension-table 2.0.0-beta.205 → 2.0.0-beta.207

package/dist/tiptap-extension-table.cjs

@@ -3,4390 +3,8 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var core = require('@tiptap/core');
+var prosemirrorTables = require('@tiptap/prosemirror-tables');
 var prosemirrorState = require('prosemirror-state');
-var prosemirrorModel = require('prosemirror-model');
-var prosemirrorView = require('prosemirror-view');
-
-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: "'",
-  229: "q"
-};
-
-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: "\"",
-  229: "Q"
-};
-
-var chrome = typeof navigator != "undefined" && /Chrome\/(\d+)/.exec(navigator.userAgent);
-var safari = typeof navigator != "undefined" && /Apple Computer/.test(navigator.vendor);
-var gecko = typeof navigator != "undefined" && /Gecko\/\d+/.test(navigator.userAgent);
-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);
-var brokenModifierNames = chrome && (mac$1 || +chrome[1] < 57) || gecko && mac$1;
-
-// 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) {
-  // Don't trust event.key in Chrome when there are modifiers until
-  // they fix https://bugs.chromium.org/p/chromium/issues/detail?id=633838
-  var ignoreKey = brokenModifierNames && (event.ctrlKey || event.altKey || event.metaKey) ||
-    (safari || ie) && event.shiftKey && event.key && event.key.length == 1;
-  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) : false;
-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) {
-    if (event.altKey)
-        name = "Alt-" + name;
-    if (event.ctrlKey)
-        name = "Ctrl-" + name;
-    if (event.metaKey)
-        name = "Meta-" + name;
-    if (shift !== false && 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), isChar = name.length == 1 && name != " ", baseName;
-        let direct = map[modifiers(name, event, !isChar)];
-        if (direct && direct(view.state, view.dispatch, view))
-            return true;
-        if (isChar && (event.shiftKey || event.altKey || event.metaKey || name.charCodeAt(0) > 127) &&
-            (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
-            let fromCode = map[modifiers(baseName, event, true)];
-            if (fromCode && fromCode(view.state, view.dispatch, view))
-                return true;
-        }
-        else if (isChar && event.shiftKey) {
-            // Otherwise, if shift is active, also try the binding with the
-            // Shift- prefix enabled. See #997
-            let withShift = map[modifiers(name, event, true)];
-            if (withShift && withShift(view.state, view.dispatch, view))
-                return true;
-        }
-        return false;
-    };
-}
-
-// Recovery values encode a range index and an offset. They are
-// represented as numbers, because tons of them will be created when
-// mapping, for example, a large number of decorations. The number's
-// lower 16 bits provide the index, the remaining bits the offset.
-//
-// Note: We intentionally don't use bit shift operators to en- and
-// decode these, since those clip to 32 bits, which we might in rare
-// cases want to overflow. A 64-bit float can represent 48-bit
-// integers precisely.
-const lower16 = 0xffff;
-const factor16 = Math.pow(2, 16);
-function makeRecover(index, offset) { return index + offset * factor16; }
-function recoverIndex(value) { return value & lower16; }
-function recoverOffset(value) { return (value - (value & lower16)) / factor16; }
-const DEL_BEFORE = 1, DEL_AFTER = 2, DEL_ACROSS = 4, DEL_SIDE = 8;
-/**
-An object representing a mapped position with extra
-information.
-*/
-class MapResult {
-    /**
-    @internal
-    */
-    constructor(
-    /**
-    The mapped version of the position.
-    */
-    pos, 
-    /**
-    @internal
-    */
-    delInfo, 
-    /**
-    @internal
-    */
-    recover) {
-        this.pos = pos;
-        this.delInfo = delInfo;
-        this.recover = recover;
-    }
-    /**
-    Tells you whether the position was deleted, that is, whether the
-    step removed the token on the side queried (via the `assoc`)
-    argument from the document.
-    */
-    get deleted() { return (this.delInfo & DEL_SIDE) > 0; }
-    /**
-    Tells you whether the token before the mapped position was deleted.
-    */
-    get deletedBefore() { return (this.delInfo & (DEL_BEFORE | DEL_ACROSS)) > 0; }
-    /**
-    True when the token after the mapped position was deleted.
-    */
-    get deletedAfter() { return (this.delInfo & (DEL_AFTER | DEL_ACROSS)) > 0; }
-    /**
-    Tells whether any of the steps mapped through deletes across the
-    position (including both the token before and after the
-    position).
-    */
-    get deletedAcross() { return (this.delInfo & DEL_ACROSS) > 0; }
-}
-/**
-A map describing the deletions and insertions made by a step, which
-can be used to find the correspondence between positions in the
-pre-step version of a document and the same position in the
-post-step version.
-*/
-class StepMap {
-    /**
-    Create a position map. The modifications to the document are
-    represented as an array of numbers, in which each group of three
-    represents a modified chunk as `[start, oldSize, newSize]`.
-    */
-    constructor(
-    /**
-    @internal
-    */
-    ranges, 
-    /**
-    @internal
-    */
-    inverted = false) {
-        this.ranges = ranges;
-        this.inverted = inverted;
-        if (!ranges.length && StepMap.empty)
-            return StepMap.empty;
-    }
-    /**
-    @internal
-    */
-    recover(value) {
-        let diff = 0, index = recoverIndex(value);
-        if (!this.inverted)
-            for (let i = 0; i < index; i++)
-                diff += this.ranges[i * 3 + 2] - this.ranges[i * 3 + 1];
-        return this.ranges[index * 3] + diff + recoverOffset(value);
-    }
-    mapResult(pos, assoc = 1) { return this._map(pos, assoc, false); }
-    map(pos, assoc = 1) { return this._map(pos, assoc, true); }
-    /**
-    @internal
-    */
-    _map(pos, assoc, simple) {
-        let diff = 0, oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
-        for (let i = 0; i < this.ranges.length; i += 3) {
-            let start = this.ranges[i] - (this.inverted ? diff : 0);
-            if (start > pos)
-                break;
-            let oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex], end = start + oldSize;
-            if (pos <= end) {
-                let side = !oldSize ? assoc : pos == start ? -1 : pos == end ? 1 : assoc;
-                let result = start + diff + (side < 0 ? 0 : newSize);
-                if (simple)
-                    return result;
-                let recover = pos == (assoc < 0 ? start : end) ? null : makeRecover(i / 3, pos - start);
-                let del = pos == start ? DEL_AFTER : pos == end ? DEL_BEFORE : DEL_ACROSS;
-                if (assoc < 0 ? pos != start : pos != end)
-                    del |= DEL_SIDE;
-                return new MapResult(result, del, recover);
-            }
-            diff += newSize - oldSize;
-        }
-        return simple ? pos + diff : new MapResult(pos + diff, 0, null);
-    }
-    /**
-    @internal
-    */
-    touches(pos, recover) {
-        let diff = 0, index = recoverIndex(recover);
-        let oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
-        for (let i = 0; i < this.ranges.length; i += 3) {
-            let start = this.ranges[i] - (this.inverted ? diff : 0);
-            if (start > pos)
-                break;
-            let oldSize = this.ranges[i + oldIndex], end = start + oldSize;
-            if (pos <= end && i == index * 3)
-                return true;
-            diff += this.ranges[i + newIndex] - oldSize;
-        }
-        return false;
-    }
-    /**
-    Calls the given function on each of the changed ranges included in
-    this map.
-    */
-    forEach(f) {
-        let oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
-        for (let i = 0, diff = 0; i < this.ranges.length; i += 3) {
-            let start = this.ranges[i], oldStart = start - (this.inverted ? diff : 0), newStart = start + (this.inverted ? 0 : diff);
-            let oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex];
-            f(oldStart, oldStart + oldSize, newStart, newStart + newSize);
-            diff += newSize - oldSize;
-        }
-    }
-    /**
-    Create an inverted version of this map. The result can be used to
-    map positions in the post-step document to the pre-step document.
-    */
-    invert() {
-        return new StepMap(this.ranges, !this.inverted);
-    }
-    /**
-    @internal
-    */
-    toString() {
-        return (this.inverted ? "-" : "") + JSON.stringify(this.ranges);
-    }
-    /**
-    Create a map that moves all positions by offset `n` (which may be
-    negative). This can be useful when applying steps meant for a
-    sub-document to a larger document, or vice-versa.
-    */
-    static offset(n) {
-        return n == 0 ? StepMap.empty : new StepMap(n < 0 ? [0, -n, 0] : [0, 0, n]);
-    }
-}
-/**
-A StepMap that contains no changed ranges.
-*/
-StepMap.empty = new StepMap([]);
-/**
-A mapping represents a pipeline of zero or more [step
-maps](https://prosemirror.net/docs/ref/#transform.StepMap). It has special provisions for losslessly
-handling mapping positions through a series of steps in which some
-steps are inverted versions of earlier steps. (This comes up when
-‘[rebasing](/docs/guide/#transform.rebasing)’ steps for
-collaboration or history management.)
-*/
-class Mapping {
-    /**
-    Create a new mapping with the given position maps.
-    */
-    constructor(
-    /**
-    The step maps in this mapping.
-    */
-    maps = [], 
-    /**
-    @internal
-    */
-    mirror, 
-    /**
-    The starting position in the `maps` array, used when `map` or
-    `mapResult` is called.
-    */
-    from = 0, 
-    /**
-    The end position in the `maps` array.
-    */
-    to = maps.length) {
-        this.maps = maps;
-        this.mirror = mirror;
-        this.from = from;
-        this.to = to;
-    }
-    /**
-    Create a mapping that maps only through a part of this one.
-    */
-    slice(from = 0, to = this.maps.length) {
-        return new Mapping(this.maps, this.mirror, from, to);
-    }
-    /**
-    @internal
-    */
-    copy() {
-        return new Mapping(this.maps.slice(), this.mirror && this.mirror.slice(), this.from, this.to);
-    }
-    /**
-    Add a step map to the end of this mapping. If `mirrors` is
-    given, it should be the index of the step map that is the mirror
-    image of this one.
-    */
-    appendMap(map, mirrors) {
-        this.to = this.maps.push(map);
-        if (mirrors != null)
-            this.setMirror(this.maps.length - 1, mirrors);
-    }
-    /**
-    Add all the step maps in a given mapping to this one (preserving
-    mirroring information).
-    */
-    appendMapping(mapping) {
-        for (let i = 0, startSize = this.maps.length; i < mapping.maps.length; i++) {
-            let mirr = mapping.getMirror(i);
-            this.appendMap(mapping.maps[i], mirr != null && mirr < i ? startSize + mirr : undefined);
-        }
-    }
-    /**
-    Finds the offset of the step map that mirrors the map at the
-    given offset, in this mapping (as per the second argument to
-    `appendMap`).
-    */
-    getMirror(n) {
-        if (this.mirror)
-            for (let i = 0; i < this.mirror.length; i++)
-                if (this.mirror[i] == n)
-                    return this.mirror[i + (i % 2 ? -1 : 1)];
-    }
-    /**
-    @internal
-    */
-    setMirror(n, m) {
-        if (!this.mirror)
-            this.mirror = [];
-        this.mirror.push(n, m);
-    }
-    /**
-    Append the inverse of the given mapping to this one.
-    */
-    appendMappingInverted(mapping) {
-        for (let i = mapping.maps.length - 1, totalSize = this.maps.length + mapping.maps.length; i >= 0; i--) {
-            let mirr = mapping.getMirror(i);
-            this.appendMap(mapping.maps[i].invert(), mirr != null && mirr > i ? totalSize - mirr - 1 : undefined);
-        }
-    }
-    /**
-    Create an inverted version of this mapping.
-    */
-    invert() {
-        let inverse = new Mapping;
-        inverse.appendMappingInverted(this);
-        return inverse;
-    }
-    /**
-    Map a position through this mapping.
-    */
-    map(pos, assoc = 1) {
-        if (this.mirror)
-            return this._map(pos, assoc, true);
-        for (let i = this.from; i < this.to; i++)
-            pos = this.maps[i].map(pos, assoc);
-        return pos;
-    }
-    /**
-    Map a position through this mapping, returning a mapping
-    result.
-    */
-    mapResult(pos, assoc = 1) { return this._map(pos, assoc, false); }
-    /**
-    @internal
-    */
-    _map(pos, assoc, simple) {
-        let delInfo = 0;
-        for (let i = this.from; i < this.to; i++) {
-            let map = this.maps[i], result = map.mapResult(pos, assoc);
-            if (result.recover != null) {
-                let corr = this.getMirror(i);
-                if (corr != null && corr > i && corr < this.to) {
-                    i = corr;
-                    pos = this.maps[corr].recover(result.recover);
-                    continue;
-                }
-            }
-            delInfo |= result.delInfo;
-            pos = result.pos;
-        }
-        return simple ? pos : new MapResult(pos, delInfo, null);
-    }
-}
-
-const stepsByID = Object.create(null);
-/**
-A step object represents an atomic change. It generally applies
-only to the document it was created for, since the positions
-stored in it will only make sense for that document.
-
-New steps are defined by creating classes that extend `Step`,
-overriding the `apply`, `invert`, `map`, `getMap` and `fromJSON`
-methods, and registering your class with a unique
-JSON-serialization identifier using
-[`Step.jsonID`](https://prosemirror.net/docs/ref/#transform.Step^jsonID).
-*/
-class Step {
-    /**
-    Get the step map that represents the changes made by this step,
-    and which can be used to transform between positions in the old
-    and the new document.
-    */
-    getMap() { return StepMap.empty; }
-    /**
-    Try to merge this step with another one, to be applied directly
-    after it. Returns the merged step when possible, null if the
-    steps can't be merged.
-    */
-    merge(other) { return null; }
-    /**
-    Deserialize a step from its JSON representation. Will call
-    through to the step class' own implementation of this method.
-    */
-    static fromJSON(schema, json) {
-        if (!json || !json.stepType)
-            throw new RangeError("Invalid input for Step.fromJSON");
-        let type = stepsByID[json.stepType];
-        if (!type)
-            throw new RangeError(`No step type ${json.stepType} defined`);
-        return type.fromJSON(schema, json);
-    }
-    /**
-    To be able to serialize steps to JSON, each step needs a string
-    ID to attach to its JSON representation. Use this method to
-    register an ID for your step classes. Try to pick something
-    that's unlikely to clash with steps from other modules.
-    */
-    static jsonID(id, stepClass) {
-        if (id in stepsByID)
-            throw new RangeError("Duplicate use of step JSON ID " + id);
-        stepsByID[id] = stepClass;
-        stepClass.prototype.jsonID = id;
-        return stepClass;
-    }
-}
-/**
-The result of [applying](https://prosemirror.net/docs/ref/#transform.Step.apply) a step. Contains either a
-new document or a failure value.
-*/
-class StepResult {
-    /**
-    @internal
-    */
-    constructor(
-    /**
-    The transformed document, if successful.
-    */
-    doc, 
-    /**
-    The failure message, if unsuccessful.
-    */
-    failed) {
-        this.doc = doc;
-        this.failed = failed;
-    }
-    /**
-    Create a successful step result.
-    */
-    static ok(doc) { return new StepResult(doc, null); }
-    /**
-    Create a failed step result.
-    */
-    static fail(message) { return new StepResult(null, message); }
-    /**
-    Call [`Node.replace`](https://prosemirror.net/docs/ref/#model.Node.replace) with the given
-    arguments. Create a successful result if it succeeds, and a
-    failed one if it throws a `ReplaceError`.
-    */
-    static fromReplace(doc, from, to, slice) {
-        try {
-            return StepResult.ok(doc.replace(from, to, slice));
-        }
-        catch (e) {
-            if (e instanceof prosemirrorModel.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 prosemirrorModel.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 prosemirrorModel.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 prosemirrorModel.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 prosemirrorModel.Slice(prosemirrorModel.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 prosemirrorModel.Slice(prosemirrorModel.Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
-    }
-    invert(doc) {
-        let node = doc.nodeAt(this.pos);
-        if (!node || !this.mark.isInSet(node.marks))
-            return this;
-        return new AddNodeMarkStep(this.pos, this.mark);
-    }
-    map(mapping) {
-        let pos = mapping.mapResult(this.pos, 1);
-        return pos.deletedAfter ? null : new RemoveNodeMarkStep(pos.pos, this.mark);
-    }
-    toJSON() {
-        return { stepType: "removeNodeMark", pos: this.pos, mark: this.mark.toJSON() };
-    }
-    /**
-    @internal
-    */
-    static fromJSON(schema, json) {
-        if (typeof json.pos != "number")
-            throw new RangeError("Invalid input for RemoveNodeMarkStep.fromJSON");
-        return new RemoveNodeMarkStep(json.pos, schema.markFromJSON(json.mark));
-    }
-}
-Step.jsonID("removeNodeMark", RemoveNodeMarkStep);
-
-/**
-Replace a part of the document with a slice of new content.
-*/
-class ReplaceStep extends Step {
-    /**
-    The given `slice` should fit the 'gap' between `from` and
-    `to`—the depths must line up, and the surrounding nodes must be
-    able to be joined with the open sides of the slice. When
-    `structure` is true, the step will fail if the content between
-    from and to is not just a sequence of closing and then opening
-    tokens (this is to guard against rebased replace steps
-    overwriting something they weren't supposed to).
-    */
-    constructor(
-    /**
-    The start position of the replaced range.
-    */
-    from, 
-    /**
-    The end position of the replaced range.
-    */
-    to, 
-    /**
-    The slice to insert.
-    */
-    slice, 
-    /**
-    @internal
-    */
-    structure = false) {
-        super();
-        this.from = from;
-        this.to = to;
-        this.slice = slice;
-        this.structure = structure;
-    }
-    apply(doc) {
-        if (this.structure && contentBetween(doc, this.from, this.to))
-            return StepResult.fail("Structure replace would overwrite content");
-        return StepResult.fromReplace(doc, this.from, this.to, this.slice);
-    }
-    getMap() {
-        return new StepMap([this.from, this.to - this.from, this.slice.size]);
-    }
-    invert(doc) {
-        return new ReplaceStep(this.from, this.from + this.slice.size, doc.slice(this.from, this.to));
-    }
-    map(mapping) {
-        let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-        if (from.deletedAcross && to.deletedAcross)
-            return null;
-        return new ReplaceStep(from.pos, Math.max(from.pos, to.pos), this.slice);
-    }
-    merge(other) {
-        if (!(other instanceof ReplaceStep) || other.structure || this.structure)
-            return null;
-        if (this.from + this.slice.size == other.from && !this.slice.openEnd && !other.slice.openStart) {
-            let slice = this.slice.size + other.slice.size == 0 ? prosemirrorModel.Slice.empty
-                : new prosemirrorModel.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 ? prosemirrorModel.Slice.empty
-                : new prosemirrorModel.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, prosemirrorModel.Slice.fromJSON(schema, json.slice), !!json.structure);
-    }
-}
-Step.jsonID("replace", ReplaceStep);
-/**
-Replace a part of the document with a slice of content, but
-preserve a range of the replaced content by moving it into the
-slice.
-*/
-class ReplaceAroundStep extends Step {
-    /**
-    Create a replace-around step with the given range and gap.
-    `insert` should be the point in the slice into which the content
-    of the gap should be moved. `structure` has the same meaning as
-    it has in the [`ReplaceStep`](https://prosemirror.net/docs/ref/#transform.ReplaceStep) class.
-    */
-    constructor(
-    /**
-    The start position of the replaced range.
-    */
-    from, 
-    /**
-    The end position of the replaced range.
-    */
-    to, 
-    /**
-    The start of preserved range.
-    */
-    gapFrom, 
-    /**
-    The end of preserved range.
-    */
-    gapTo, 
-    /**
-    The slice to insert.
-    */
-    slice, 
-    /**
-    The position in the slice where the preserved range should be
-    inserted.
-    */
-    insert, 
-    /**
-    @internal
-    */
-    structure = false) {
-        super();
-        this.from = from;
-        this.to = to;
-        this.gapFrom = gapFrom;
-        this.gapTo = gapTo;
-        this.slice = slice;
-        this.insert = insert;
-        this.structure = structure;
-    }
-    apply(doc) {
-        if (this.structure && (contentBetween(doc, this.from, this.gapFrom) ||
-            contentBetween(doc, this.gapTo, this.to)))
-            return StepResult.fail("Structure gap-replace would overwrite content");
-        let gap = doc.slice(this.gapFrom, this.gapTo);
-        if (gap.openStart || gap.openEnd)
-            return StepResult.fail("Gap is not a flat range");
-        let inserted = this.slice.insertAt(this.insert, gap.content);
-        if (!inserted)
-            return StepResult.fail("Content does not fit in gap");
-        return StepResult.fromReplace(doc, this.from, this.to, inserted);
-    }
-    getMap() {
-        return new StepMap([this.from, this.gapFrom - this.from, this.insert,
-            this.gapTo, this.to - this.gapTo, this.slice.size - this.insert]);
-    }
-    invert(doc) {
-        let gap = this.gapTo - this.gapFrom;
-        return new ReplaceAroundStep(this.from, this.from + this.slice.size + gap, this.from + this.insert, this.from + this.insert + gap, doc.slice(this.from, this.to).removeBetween(this.gapFrom - this.from, this.gapTo - this.from), this.gapFrom - this.from, this.structure);
-    }
-    map(mapping) {
-        let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-        let gapFrom = mapping.map(this.gapFrom, -1), gapTo = mapping.map(this.gapTo, 1);
-        if ((from.deletedAcross && to.deletedAcross) || gapFrom < from.pos || gapTo > to.pos)
-            return null;
-        return new ReplaceAroundStep(from.pos, to.pos, gapFrom, gapTo, this.slice, this.insert, this.structure);
-    }
-    toJSON() {
-        let json = { stepType: "replaceAround", from: this.from, to: this.to,
-            gapFrom: this.gapFrom, gapTo: this.gapTo, insert: this.insert };
-        if (this.slice.size)
-            json.slice = this.slice.toJSON();
-        if (this.structure)
-            json.structure = true;
-        return json;
-    }
-    /**
-    @internal
-    */
-    static fromJSON(schema, json) {
-        if (typeof json.from != "number" || typeof json.to != "number" ||
-            typeof json.gapFrom != "number" || typeof json.gapTo != "number" || typeof json.insert != "number")
-            throw new RangeError("Invalid input for ReplaceAroundStep.fromJSON");
-        return new ReplaceAroundStep(json.from, json.to, json.gapFrom, json.gapTo, prosemirrorModel.Slice.fromJSON(schema, json.slice), json.insert, !!json.structure);
-    }
-}
-Step.jsonID("replaceAround", ReplaceAroundStep);
-function contentBetween(doc, from, to) {
-    let $from = doc.resolve(from), dist = to - from, depth = $from.depth;
-    while (dist > 0 && depth > 0 && $from.indexAfter(depth) == $from.node(depth).childCount) {
-        depth--;
-        dist--;
-    }
-    if (dist > 0) {
-        let next = $from.node(depth).maybeChild($from.indexAfter(depth));
-        while (dist > 0) {
-            if (!next || next.isLeaf)
-                return true;
-            next = next.firstChild;
-            dist--;
-        }
-    }
-    return false;
-}
-
-function addMark(tr, from, to, mark) {
-    let removed = [], added = [];
-    let removing, adding;
-    tr.doc.nodesBetween(from, to, (node, pos, parent) => {
-        if (!node.isInline)
-            return;
-        let marks = node.marks;
-        if (!mark.isInSet(marks) && parent.type.allowsMarkType(mark.type)) {
-            let start = Math.max(pos, from), end = Math.min(pos + node.nodeSize, to);
-            let newSet = mark.addToSet(marks);
-            for (let i = 0; i < marks.length; i++) {
-                if (!marks[i].isInSet(newSet)) {
-                    if (removing && removing.to == start && removing.mark.eq(marks[i]))
-                        removing.to = end;
-                    else
-                        removed.push(removing = new RemoveMarkStep(start, end, marks[i]));
-                }
-            }
-            if (adding && adding.to == start)
-                adding.to = end;
-            else
-                added.push(adding = new AddMarkStep(start, end, mark));
-        }
-    });
-    removed.forEach(s => tr.step(s));
-    added.forEach(s => tr.step(s));
-}
-function removeMark(tr, from, to, mark) {
-    let matched = [], step = 0;
-    tr.doc.nodesBetween(from, to, (node, pos) => {
-        if (!node.isInline)
-            return;
-        step++;
-        let toRemove = null;
-        if (mark instanceof prosemirrorModel.MarkType) {
-            let set = node.marks, found;
-            while (found = mark.isInSet(set)) {
-                (toRemove || (toRemove = [])).push(found);
-                set = found.removeFromSet(set);
-            }
-        }
-        else if (mark) {
-            if (mark.isInSet(node.marks))
-                toRemove = [mark];
-        }
-        else {
-            toRemove = node.marks;
-        }
-        if (toRemove && toRemove.length) {
-            let end = Math.min(pos + node.nodeSize, to);
-            for (let i = 0; i < toRemove.length; i++) {
-                let style = toRemove[i], found;
-                for (let j = 0; j < matched.length; j++) {
-                    let m = matched[j];
-                    if (m.step == step - 1 && style.eq(matched[j].style))
-                        found = m;
-                }
-                if (found) {
-                    found.to = end;
-                    found.step = step;
-                }
-                else {
-                    matched.push({ style, from: Math.max(pos, from), to: end, step });
-                }
-            }
-        }
-    });
-    matched.forEach(m => tr.step(new RemoveMarkStep(m.from, m.to, m.style)));
-}
-function clearIncompatible(tr, pos, parentType, match = parentType.contentMatch) {
-    let node = tr.doc.nodeAt(pos);
-    let delSteps = [], cur = pos + 1;
-    for (let i = 0; i < node.childCount; i++) {
-        let child = node.child(i), end = cur + child.nodeSize;
-        let allowed = match.matchType(child.type);
-        if (!allowed) {
-            delSteps.push(new ReplaceStep(cur, end, prosemirrorModel.Slice.empty));
-        }
-        else {
-            match = allowed;
-            for (let j = 0; j < child.marks.length; j++)
-                if (!parentType.allowsMarkType(child.marks[j].type))
-                    tr.step(new RemoveMarkStep(cur, end, child.marks[j]));
-        }
-        cur = end;
-    }
-    if (!match.validEnd) {
-        let fill = match.fillBefore(prosemirrorModel.Fragment.empty, true);
-        tr.replace(cur, cur, new prosemirrorModel.Slice(fill, 0, 0));
-    }
-    for (let i = delSteps.length - 1; i >= 0; i--)
-        tr.step(delSteps[i]);
-}
-function lift(tr, range, target) {
-    let { $from, $to, depth } = range;
-    let gapStart = $from.before(depth + 1), gapEnd = $to.after(depth + 1);
-    let start = gapStart, end = gapEnd;
-    let before = prosemirrorModel.Fragment.empty, openStart = 0;
-    for (let d = depth, splitting = false; d > target; d--)
-        if (splitting || $from.index(d) > 0) {
-            splitting = true;
-            before = prosemirrorModel.Fragment.from($from.node(d).copy(before));
-            openStart++;
-        }
-        else {
-            start--;
-        }
-    let after = prosemirrorModel.Fragment.empty, openEnd = 0;
-    for (let d = depth, splitting = false; d > target; d--)
-        if (splitting || $to.after(d + 1) < $to.end(d)) {
-            splitting = true;
-            after = prosemirrorModel.Fragment.from($to.node(d).copy(after));
-            openEnd++;
-        }
-        else {
-            end++;
-        }
-    tr.step(new ReplaceAroundStep(start, end, gapStart, gapEnd, new prosemirrorModel.Slice(before.append(after), openStart, openEnd), before.size - openStart, true));
-}
-function wrap(tr, range, wrappers) {
-    let content = prosemirrorModel.Fragment.empty;
-    for (let i = wrappers.length - 1; i >= 0; i--) {
-        if (content.size) {
-            let match = wrappers[i].type.contentMatch.matchFragment(content);
-            if (!match || !match.validEnd)
-                throw new RangeError("Wrapper type given to Transform.wrap does not form valid content of its parent wrapper");
-        }
-        content = prosemirrorModel.Fragment.from(wrappers[i].type.create(wrappers[i].attrs, content));
-    }
-    let start = range.start, end = range.end;
-    tr.step(new ReplaceAroundStep(start, end, start, end, new prosemirrorModel.Slice(content, 0, 0), wrappers.length, true));
-}
-function setBlockType(tr, from, to, type, attrs) {
-    if (!type.isTextblock)
-        throw new RangeError("Type given to setBlockType should be a textblock");
-    let mapFrom = tr.steps.length;
-    tr.doc.nodesBetween(from, to, (node, pos) => {
-        if (node.isTextblock && !node.hasMarkup(type, attrs) && canChangeType(tr.doc, tr.mapping.slice(mapFrom).map(pos), type)) {
-            // Ensure all markup that isn't allowed in the new node type is cleared
-            tr.clearIncompatible(tr.mapping.slice(mapFrom).map(pos, 1), type);
-            let mapping = tr.mapping.slice(mapFrom);
-            let startM = mapping.map(pos, 1), endM = mapping.map(pos + node.nodeSize, 1);
-            tr.step(new ReplaceAroundStep(startM, endM, startM + 1, endM - 1, new prosemirrorModel.Slice(prosemirrorModel.Fragment.from(type.create(attrs, null, node.marks)), 0, 0), 1, true));
-            return false;
-        }
-    });
-}
-function canChangeType(doc, pos, type) {
-    let $pos = doc.resolve(pos), index = $pos.index();
-    return $pos.parent.canReplaceWith(index, index + 1, type);
-}
-/**
-Change the type, attributes, and/or marks of the node at `pos`.
-When `type` isn't given, the existing node type is preserved,
-*/
-function setNodeMarkup(tr, pos, type, attrs, marks) {
-    let node = tr.doc.nodeAt(pos);
-    if (!node)
-        throw new RangeError("No node at given position");
-    if (!type)
-        type = node.type;
-    let newNode = type.create(attrs, null, marks || node.marks);
-    if (node.isLeaf)
-        return tr.replaceWith(pos, pos + node.nodeSize, newNode);
-    if (!type.validContent(node.content))
-        throw new RangeError("Invalid content for node type " + type.name);
-    tr.step(new ReplaceAroundStep(pos, pos + node.nodeSize, pos + 1, pos + node.nodeSize - 1, new prosemirrorModel.Slice(prosemirrorModel.Fragment.from(newNode), 0, 0), 1, true));
-}
-function split(tr, pos, depth = 1, typesAfter) {
-    let $pos = tr.doc.resolve(pos), before = prosemirrorModel.Fragment.empty, after = prosemirrorModel.Fragment.empty;
-    for (let d = $pos.depth, e = $pos.depth - depth, i = depth - 1; d > e; d--, i--) {
-        before = prosemirrorModel.Fragment.from($pos.node(d).copy(before));
-        let typeAfter = typesAfter && typesAfter[i];
-        after = prosemirrorModel.Fragment.from(typeAfter ? typeAfter.type.create(typeAfter.attrs, after) : $pos.node(d).copy(after));
-    }
-    tr.step(new ReplaceStep(pos, pos, new prosemirrorModel.Slice(before.append(after), depth, depth), true));
-}
-function join(tr, pos, depth) {
-    let step = new ReplaceStep(pos - depth, pos + depth, prosemirrorModel.Slice.empty, true);
-    tr.step(step);
-}
-/**
-Try to find a point where a node of the given type can be inserted
-near `pos`, by searching up the node hierarchy when `pos` itself
-isn't a valid place but is at the start or end of a node. Return
-null if no position was found.
-*/
-function insertPoint(doc, pos, nodeType) {
-    let $pos = doc.resolve(pos);
-    if ($pos.parent.canReplaceWith($pos.index(), $pos.index(), nodeType))
-        return pos;
-    if ($pos.parentOffset == 0)
-        for (let d = $pos.depth - 1; d >= 0; d--) {
-            let index = $pos.index(d);
-            if ($pos.node(d).canReplaceWith(index, index, nodeType))
-                return $pos.before(d + 1);
-            if (index > 0)
-                return null;
-        }
-    if ($pos.parentOffset == $pos.parent.content.size)
-        for (let d = $pos.depth - 1; d >= 0; d--) {
-            let index = $pos.indexAfter(d);
-            if ($pos.node(d).canReplaceWith(index, index, nodeType))
-                return $pos.after(d + 1);
-            if (index < $pos.node(d).childCount)
-                return null;
-        }
-    return null;
-}
-
-/**
-‘Fit’ a slice into a given position in the document, producing a
-[step](https://prosemirror.net/docs/ref/#transform.Step) that inserts it. Will return null if
-there's no meaningful way to insert the slice here, or inserting it
-would be a no-op (an empty slice over an empty range).
-*/
-function replaceStep(doc, from, to = from, slice = prosemirrorModel.Slice.empty) {
-    if (from == to && !slice.size)
-        return null;
-    let $from = doc.resolve(from), $to = doc.resolve(to);
-    // Optimization -- avoid work if it's obvious that it's not needed.
-    if (fitsTrivially($from, $to, slice))
-        return new ReplaceStep(from, to, slice);
-    return new Fitter($from, $to, slice).fit();
-}
-function fitsTrivially($from, $to, slice) {
-    return !slice.openStart && !slice.openEnd && $from.start() == $to.start() &&
-        $from.parent.canReplace($from.index(), $to.index(), slice.content);
-}
-// Algorithm for 'placing' the elements of a slice into a gap:
-//
-// We consider the content of each node that is open to the left to be
-// independently placeable. I.e. in <p("foo"), p("bar")>, when the
-// paragraph on the left is open, "foo" can be placed (somewhere on
-// the left side of the replacement gap) independently from p("bar").
-//
-// This class tracks the state of the placement progress in the
-// following properties:
-//
-//  - `frontier` holds a stack of `{type, match}` objects that
-//    represent the open side of the replacement. It starts at
-//    `$from`, then moves forward as content is placed, and is finally
-//    reconciled with `$to`.
-//
-//  - `unplaced` is a slice that represents the content that hasn't
-//    been placed yet.
-//
-//  - `placed` is a fragment of placed content. Its open-start value
-//    is implicit in `$from`, and its open-end value in `frontier`.
-class Fitter {
-    constructor($from, $to, unplaced) {
-        this.$from = $from;
-        this.$to = $to;
-        this.unplaced = unplaced;
-        this.frontier = [];
-        this.placed = prosemirrorModel.Fragment.empty;
-        for (let i = 0; i <= $from.depth; i++) {
-            let node = $from.node(i);
-            this.frontier.push({
-                type: node.type,
-                match: node.contentMatchAt($from.indexAfter(i))
-            });
-        }
-        for (let i = $from.depth; i > 0; i--)
-            this.placed = prosemirrorModel.Fragment.from($from.node(i).copy(this.placed));
-    }
-    get depth() { return this.frontier.length - 1; }
-    fit() {
-        // As long as there's unplaced content, try to place some of it.
-        // If that fails, either increase the open score of the unplaced
-        // slice, or drop nodes from it, and then try again.
-        while (this.unplaced.size) {
-            let fit = this.findFittable();
-            if (fit)
-                this.placeNodes(fit);
-            else
-                this.openMore() || this.dropNode();
-        }
-        // When there's inline content directly after the frontier _and_
-        // directly after `this.$to`, we must generate a `ReplaceAround`
-        // step that pulls that content into the node after the frontier.
-        // That means the fitting must be done to the end of the textblock
-        // node after `this.$to`, not `this.$to` itself.
-        let moveInline = this.mustMoveInline(), placedSize = this.placed.size - this.depth - this.$from.depth;
-        let $from = this.$from, $to = this.close(moveInline < 0 ? this.$to : $from.doc.resolve(moveInline));
-        if (!$to)
-            return null;
-        // If closing to `$to` succeeded, create a step
-        let content = this.placed, openStart = $from.depth, openEnd = $to.depth;
-        while (openStart && openEnd && content.childCount == 1) { // Normalize by dropping open parent nodes
-            content = content.firstChild.content;
-            openStart--;
-            openEnd--;
-        }
-        let slice = new prosemirrorModel.Slice(content, openStart, openEnd);
-        if (moveInline > -1)
-            return new ReplaceAroundStep($from.pos, moveInline, this.$to.pos, this.$to.end(), slice, placedSize);
-        if (slice.size || $from.pos != this.$to.pos) // Don't generate no-op steps
-            return new ReplaceStep($from.pos, $to.pos, slice);
-        return null;
-    }
-    // Find a position on the start spine of `this.unplaced` that has
-    // content that can be moved somewhere on the frontier. Returns two
-    // depths, one for the slice and one for the frontier.
-    findFittable() {
-        // Only try wrapping nodes (pass 2) after finding a place without
-        // wrapping failed.
-        for (let pass = 1; pass <= 2; pass++) {
-            for (let sliceDepth = this.unplaced.openStart; sliceDepth >= 0; sliceDepth--) {
-                let fragment, parent = null;
-                if (sliceDepth) {
-                    parent = contentAt(this.unplaced.content, sliceDepth - 1).firstChild;
-                    fragment = parent.content;
-                }
-                else {
-                    fragment = this.unplaced.content;
-                }
-                let first = fragment.firstChild;
-                for (let frontierDepth = this.depth; frontierDepth >= 0; frontierDepth--) {
-                    let { type, match } = this.frontier[frontierDepth], wrap, inject = null;
-                    // In pass 1, if the next node matches, or there is no next
-                    // node but the parents look compatible, we've found a
-                    // place.
-                    if (pass == 1 && (first ? match.matchType(first.type) || (inject = match.fillBefore(prosemirrorModel.Fragment.from(first), false))
-                        : parent && type.compatibleContent(parent.type)))
-                        return { sliceDepth, frontierDepth, parent, inject };
-                    // In pass 2, look for a set of wrapping nodes that make
-                    // `first` fit here.
-                    else if (pass == 2 && first && (wrap = match.findWrapping(first.type)))
-                        return { sliceDepth, frontierDepth, parent, wrap };
-                    // Don't continue looking further up if the parent node
-                    // would fit here.
-                    if (parent && match.matchType(parent.type))
-                        break;
-                }
-            }
-        }
-    }
-    openMore() {
-        let { content, openStart, openEnd } = this.unplaced;
-        let inner = contentAt(content, openStart);
-        if (!inner.childCount || inner.firstChild.isLeaf)
-            return false;
-        this.unplaced = new prosemirrorModel.Slice(content, openStart + 1, Math.max(openEnd, inner.size + openStart >= content.size - openEnd ? openStart + 1 : 0));
-        return true;
-    }
-    dropNode() {
-        let { content, openStart, openEnd } = this.unplaced;
-        let inner = contentAt(content, openStart);
-        if (inner.childCount <= 1 && openStart > 0) {
-            let openAtEnd = content.size - openStart <= openStart + inner.size;
-            this.unplaced = new prosemirrorModel.Slice(dropFromFragment(content, openStart - 1, 1), openStart - 1, openAtEnd ? openStart - 1 : openEnd);
-        }
-        else {
-            this.unplaced = new prosemirrorModel.Slice(dropFromFragment(content, openStart, 1), openStart, openEnd);
-        }
-    }
-    // Move content from the unplaced slice at `sliceDepth` to the
-    // frontier node at `frontierDepth`. Close that frontier node when
-    // applicable.
-    placeNodes({ sliceDepth, frontierDepth, parent, inject, wrap }) {
-        while (this.depth > frontierDepth)
-            this.closeFrontierNode();
-        if (wrap)
-            for (let i = 0; i < wrap.length; i++)
-                this.openFrontierNode(wrap[i]);
-        let slice = this.unplaced, fragment = parent ? parent.content : slice.content;
-        let openStart = slice.openStart - sliceDepth;
-        let taken = 0, add = [];
-        let { match, type } = this.frontier[frontierDepth];
-        if (inject) {
-            for (let i = 0; i < inject.childCount; i++)
-                add.push(inject.child(i));
-            match = match.matchFragment(inject);
-        }
-        // Computes the amount of (end) open nodes at the end of the
-        // fragment. When 0, the parent is open, but no more. When
-        // negative, nothing is open.
-        let openEndCount = (fragment.size + sliceDepth) - (slice.content.size - slice.openEnd);
-        // Scan over the fragment, fitting as many child nodes as
-        // possible.
-        while (taken < fragment.childCount) {
-            let next = fragment.child(taken), matches = match.matchType(next.type);
-            if (!matches)
-                break;
-            taken++;
-            if (taken > 1 || openStart == 0 || next.content.size) { // Drop empty open nodes
-                match = matches;
-                add.push(closeNodeStart(next.mark(type.allowedMarks(next.marks)), taken == 1 ? openStart : 0, taken == fragment.childCount ? openEndCount : -1));
-            }
-        }
-        let toEnd = taken == fragment.childCount;
-        if (!toEnd)
-            openEndCount = -1;
-        this.placed = addToFragment(this.placed, frontierDepth, prosemirrorModel.Fragment.from(add));
-        this.frontier[frontierDepth].match = match;
-        // If the parent types match, and the entire node was moved, and
-        // it's not open, close this frontier node right away.
-        if (toEnd && openEndCount < 0 && parent && parent.type == this.frontier[this.depth].type && this.frontier.length > 1)
-            this.closeFrontierNode();
-        // Add new frontier nodes for any open nodes at the end.
-        for (let i = 0, cur = fragment; i < openEndCount; i++) {
-            let node = cur.lastChild;
-            this.frontier.push({ type: node.type, match: node.contentMatchAt(node.childCount) });
-            cur = node.content;
-        }
-        // Update `this.unplaced`. Drop the entire node from which we
-        // placed it we got to its end, otherwise just drop the placed
-        // nodes.
-        this.unplaced = !toEnd ? new prosemirrorModel.Slice(dropFromFragment(slice.content, sliceDepth, taken), slice.openStart, slice.openEnd)
-            : sliceDepth == 0 ? prosemirrorModel.Slice.empty
-                : new prosemirrorModel.Slice(dropFromFragment(slice.content, sliceDepth - 1, 1), sliceDepth - 1, openEndCount < 0 ? slice.openEnd : sliceDepth - 1);
-    }
-    mustMoveInline() {
-        if (!this.$to.parent.isTextblock)
-            return -1;
-        let top = this.frontier[this.depth], level;
-        if (!top.type.isTextblock || !contentAfterFits(this.$to, this.$to.depth, top.type, top.match, false) ||
-            (this.$to.depth == this.depth && (level = this.findCloseLevel(this.$to)) && level.depth == this.depth))
-            return -1;
-        let { depth } = this.$to, after = this.$to.after(depth);
-        while (depth > 1 && after == this.$to.end(--depth))
-            ++after;
-        return after;
-    }
-    findCloseLevel($to) {
-        scan: for (let i = Math.min(this.depth, $to.depth); i >= 0; i--) {
-            let { match, type } = this.frontier[i];
-            let dropInner = i < $to.depth && $to.end(i + 1) == $to.pos + ($to.depth - (i + 1));
-            let fit = contentAfterFits($to, i, type, match, dropInner);
-            if (!fit)
-                continue;
-            for (let d = i - 1; d >= 0; d--) {
-                let { match, type } = this.frontier[d];
-                let matches = contentAfterFits($to, d, type, match, true);
-                if (!matches || matches.childCount)
-                    continue scan;
-            }
-            return { depth: i, fit, move: dropInner ? $to.doc.resolve($to.after(i + 1)) : $to };
-        }
-    }
-    close($to) {
-        let close = this.findCloseLevel($to);
-        if (!close)
-            return null;
-        while (this.depth > close.depth)
-            this.closeFrontierNode();
-        if (close.fit.childCount)
-            this.placed = addToFragment(this.placed, close.depth, close.fit);
-        $to = close.move;
-        for (let d = close.depth + 1; d <= $to.depth; d++) {
-            let node = $to.node(d), add = node.type.contentMatch.fillBefore(node.content, true, $to.index(d));
-            this.openFrontierNode(node.type, node.attrs, add);
-        }
-        return $to;
-    }
-    openFrontierNode(type, attrs = null, content) {
-        let top = this.frontier[this.depth];
-        top.match = top.match.matchType(type);
-        this.placed = addToFragment(this.placed, this.depth, prosemirrorModel.Fragment.from(type.create(attrs, content)));
-        this.frontier.push({ type, match: type.contentMatch });
-    }
-    closeFrontierNode() {
-        let open = this.frontier.pop();
-        let add = open.match.fillBefore(prosemirrorModel.Fragment.empty, true);
-        if (add.childCount)
-            this.placed = addToFragment(this.placed, this.frontier.length, add);
-    }
-}
-function dropFromFragment(fragment, depth, count) {
-    if (depth == 0)
-        return fragment.cutByIndex(count, fragment.childCount);
-    return fragment.replaceChild(0, fragment.firstChild.copy(dropFromFragment(fragment.firstChild.content, depth - 1, count)));
-}
-function addToFragment(fragment, depth, content) {
-    if (depth == 0)
-        return fragment.append(content);
-    return fragment.replaceChild(fragment.childCount - 1, fragment.lastChild.copy(addToFragment(fragment.lastChild.content, depth - 1, content)));
-}
-function contentAt(fragment, depth) {
-    for (let i = 0; i < depth; i++)
-        fragment = fragment.firstChild.content;
-    return fragment;
-}
-function closeNodeStart(node, openStart, openEnd) {
-    if (openStart <= 0)
-        return node;
-    let frag = node.content;
-    if (openStart > 1)
-        frag = frag.replaceChild(0, closeNodeStart(frag.firstChild, openStart - 1, frag.childCount == 1 ? openEnd - 1 : 0));
-    if (openStart > 0) {
-        frag = node.type.contentMatch.fillBefore(frag).append(frag);
-        if (openEnd <= 0)
-            frag = frag.append(node.type.contentMatch.matchFragment(frag).fillBefore(prosemirrorModel.Fragment.empty, true));
-    }
-    return node.copy(frag);
-}
-function contentAfterFits($to, depth, type, match, open) {
-    let node = $to.node(depth), index = open ? $to.indexAfter(depth) : $to.index(depth);
-    if (index == node.childCount && !type.compatibleContent(node.type))
-        return null;
-    let fit = match.fillBefore(node.content, true, index);
-    return fit && !invalidMarks(type, node.content, index) ? fit : null;
-}
-function invalidMarks(type, fragment, start) {
-    for (let i = start; i < fragment.childCount; i++)
-        if (!type.allowsMarks(fragment.child(i).marks))
-            return true;
-    return false;
-}
-function definesContent(type) {
-    return type.spec.defining || type.spec.definingForContent;
-}
-function replaceRange(tr, from, to, slice) {
-    if (!slice.size)
-        return tr.deleteRange(from, to);
-    let $from = tr.doc.resolve(from), $to = tr.doc.resolve(to);
-    if (fitsTrivially($from, $to, slice))
-        return tr.step(new ReplaceStep(from, to, slice));
-    let targetDepths = coveredDepths($from, tr.doc.resolve(to));
-    // Can't replace the whole document, so remove 0 if it's present
-    if (targetDepths[targetDepths.length - 1] == 0)
-        targetDepths.pop();
-    // Negative numbers represent not expansion over the whole node at
-    // that depth, but replacing from $from.before(-D) to $to.pos.
-    let preferredTarget = -($from.depth + 1);
-    targetDepths.unshift(preferredTarget);
-    // This loop picks a preferred target depth, if one of the covering
-    // depths is not outside of a defining node, and adds negative
-    // depths for any depth that has $from at its start and does not
-    // cross a defining node.
-    for (let d = $from.depth, pos = $from.pos - 1; d > 0; d--, pos--) {
-        let spec = $from.node(d).type.spec;
-        if (spec.defining || spec.definingAsContext || spec.isolating)
-            break;
-        if (targetDepths.indexOf(d) > -1)
-            preferredTarget = d;
-        else if ($from.before(d) == pos)
-            targetDepths.splice(1, 0, -d);
-    }
-    // Try to fit each possible depth of the slice into each possible
-    // target depth, starting with the preferred depths.
-    let preferredTargetIndex = targetDepths.indexOf(preferredTarget);
-    let leftNodes = [], preferredDepth = slice.openStart;
-    for (let content = slice.content, i = 0;; i++) {
-        let node = content.firstChild;
-        leftNodes.push(node);
-        if (i == slice.openStart)
-            break;
-        content = node.content;
-    }
-    // Back up preferredDepth to cover defining textblocks directly
-    // above it, possibly skipping a non-defining textblock.
-    for (let d = preferredDepth - 1; d >= 0; d--) {
-        let type = leftNodes[d].type, def = definesContent(type);
-        if (def && $from.node(preferredTargetIndex).type != type)
-            preferredDepth = d;
-        else if (def || !type.isTextblock)
-            break;
-    }
-    for (let j = slice.openStart; j >= 0; j--) {
-        let openDepth = (j + preferredDepth + 1) % (slice.openStart + 1);
-        let insert = leftNodes[openDepth];
-        if (!insert)
-            continue;
-        for (let i = 0; i < targetDepths.length; i++) {
-            // Loop over possible expansion levels, starting with the
-            // preferred one
-            let targetDepth = targetDepths[(i + preferredTargetIndex) % targetDepths.length], expand = true;
-            if (targetDepth < 0) {
-                expand = false;
-                targetDepth = -targetDepth;
-            }
-            let parent = $from.node(targetDepth - 1), index = $from.index(targetDepth - 1);
-            if (parent.canReplaceWith(index, index, insert.type, insert.marks))
-                return tr.replace($from.before(targetDepth), expand ? $to.after(targetDepth) : to, new prosemirrorModel.Slice(closeFragment(slice.content, 0, slice.openStart, openDepth), openDepth, slice.openEnd));
-        }
-    }
-    let startSteps = tr.steps.length;
-    for (let i = targetDepths.length - 1; i >= 0; i--) {
-        tr.replace(from, to, slice);
-        if (tr.steps.length > startSteps)
-            break;
-        let depth = targetDepths[i];
-        if (depth < 0)
-            continue;
-        from = $from.before(depth);
-        to = $to.after(depth);
-    }
-}
-function closeFragment(fragment, depth, oldOpen, newOpen, parent) {
-    if (depth < oldOpen) {
-        let first = fragment.firstChild;
-        fragment = fragment.replaceChild(0, first.copy(closeFragment(first.content, depth + 1, oldOpen, newOpen, first)));
-    }
-    if (depth > newOpen) {
-        let match = parent.contentMatchAt(0);
-        let start = match.fillBefore(fragment).append(fragment);
-        fragment = start.append(match.matchFragment(start).fillBefore(prosemirrorModel.Fragment.empty, true));
-    }
-    return fragment;
-}
-function replaceRangeWith(tr, from, to, node) {
-    if (!node.isInline && from == to && tr.doc.resolve(from).parent.content.size) {
-        let point = insertPoint(tr.doc, from, node.type);
-        if (point != null)
-            from = to = point;
-    }
-    tr.replaceRange(from, to, new prosemirrorModel.Slice(prosemirrorModel.Fragment.from(node), 0, 0));
-}
-function deleteRange(tr, from, to) {
-    let $from = tr.doc.resolve(from), $to = tr.doc.resolve(to);
-    let covered = coveredDepths($from, $to);
-    for (let i = 0; i < covered.length; i++) {
-        let depth = covered[i], last = i == covered.length - 1;
-        if ((last && depth == 0) || $from.node(depth).type.contentMatch.validEnd)
-            return tr.delete($from.start(depth), $to.end(depth));
-        if (depth > 0 && (last || $from.node(depth - 1).canReplace($from.index(depth - 1), $to.indexAfter(depth - 1))))
-            return tr.delete($from.before(depth), $to.after(depth));
-    }
-    for (let d = 1; d <= $from.depth && d <= $to.depth; d++) {
-        if (from - $from.start(d) == $from.depth - d && to > $from.end(d) && $to.end(d) - to != $to.depth - d)
-            return tr.delete($from.before(d), to);
-    }
-    tr.delete(from, to);
-}
-// Returns an array of all depths for which $from - $to spans the
-// whole content of the nodes at that depth.
-function coveredDepths($from, $to) {
-    let result = [], minDepth = Math.min($from.depth, $to.depth);
-    for (let d = minDepth; d >= 0; d--) {
-        let start = $from.start(d);
-        if (start < $from.pos - ($from.depth - d) ||
-            $to.end(d) > $to.pos + ($to.depth - d) ||
-            $from.node(d).type.spec.isolating ||
-            $to.node(d).type.spec.isolating)
-            break;
-        if (start == $to.start(d) ||
-            (d == $from.depth && d == $to.depth && $from.parent.inlineContent && $to.parent.inlineContent &&
-                d && $to.start(d - 1) == start - 1))
-            result.push(d);
-    }
-    return result;
-}
-
-/**
-Update an attribute in a specific node.
-*/
-class AttrStep extends Step {
-    /**
-    Construct an attribute step.
-    */
-    constructor(
-    /**
-    The position of the target node.
-    */
-    pos, 
-    /**
-    The attribute to set.
-    */
-    attr, 
-    // The attribute's new value.
-    value) {
-        super();
-        this.pos = pos;
-        this.attr = attr;
-        this.value = value;
-    }
-    apply(doc) {
-        let node = doc.nodeAt(this.pos);
-        if (!node)
-            return StepResult.fail("No node at attribute step's position");
-        let attrs = Object.create(null);
-        for (let name in node.attrs)
-            attrs[name] = node.attrs[name];
-        attrs[this.attr] = this.value;
-        let updated = node.type.create(attrs, null, node.marks);
-        return StepResult.fromReplace(doc, this.pos, this.pos + 1, new prosemirrorModel.Slice(prosemirrorModel.Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
-    }
-    getMap() {
-        return StepMap.empty;
-    }
-    invert(doc) {
-        return new AttrStep(this.pos, this.attr, doc.nodeAt(this.pos).attrs[this.attr]);
-    }
-    map(mapping) {
-        let pos = mapping.mapResult(this.pos, 1);
-        return pos.deletedAfter ? null : new AttrStep(pos.pos, this.attr, this.value);
-    }
-    toJSON() {
-        return { stepType: "attr", pos: this.pos, attr: this.attr, value: this.value };
-    }
-    static fromJSON(schema, json) {
-        if (typeof json.pos != "number" || typeof json.attr != "string")
-            throw new RangeError("Invalid input for AttrStep.fromJSON");
-        return new AttrStep(json.pos, json.attr, json.value);
-    }
-}
-Step.jsonID("attr", AttrStep);
-
-/**
-@internal
-*/
-let TransformError = class extends Error {
-};
-TransformError = function TransformError(message) {
-    let err = Error.call(this, message);
-    err.__proto__ = TransformError.prototype;
-    return err;
-};
-TransformError.prototype = Object.create(Error.prototype);
-TransformError.prototype.constructor = TransformError;
-TransformError.prototype.name = "TransformError";
-/**
-Abstraction to build up and track an array of
-[steps](https://prosemirror.net/docs/ref/#transform.Step) representing a document transformation.
-
-Most transforming methods return the `Transform` object itself, so
-that they can be chained.
-*/
-class Transform {
-    /**
-    Create a transform that starts with the given document.
-    */
-    constructor(
-    /**
-    The current document (the result of applying the steps in the
-    transform).
-    */
-    doc) {
-        this.doc = doc;
-        /**
-        The steps in this transform.
-        */
-        this.steps = [];
-        /**
-        The documents before each of the steps.
-        */
-        this.docs = [];
-        /**
-        A mapping with the maps for each of the steps in this transform.
-        */
-        this.mapping = new Mapping;
-    }
-    /**
-    The starting document.
-    */
-    get before() { return this.docs.length ? this.docs[0] : this.doc; }
-    /**
-    Apply a new step in this transform, saving the result. Throws an
-    error when the step fails.
-    */
-    step(step) {
-        let result = this.maybeStep(step);
-        if (result.failed)
-            throw new TransformError(result.failed);
-        return this;
-    }
-    /**
-    Try to apply a step in this transformation, ignoring it if it
-    fails. Returns the step result.
-    */
-    maybeStep(step) {
-        let result = step.apply(this.doc);
-        if (!result.failed)
-            this.addStep(step, result.doc);
-        return result;
-    }
-    /**
-    True when the document has been changed (when there are any
-    steps).
-    */
-    get docChanged() {
-        return this.steps.length > 0;
-    }
-    /**
-    @internal
-    */
-    addStep(step, doc) {
-        this.docs.push(this.doc);
-        this.steps.push(step);
-        this.mapping.appendMap(step.getMap());
-        this.doc = doc;
-    }
-    /**
-    Replace the part of the document between `from` and `to` with the
-    given `slice`.
-    */
-    replace(from, to = from, slice = prosemirrorModel.Slice.empty) {
-        let step = replaceStep(this.doc, from, to, slice);
-        if (step)
-            this.step(step);
-        return this;
-    }
-    /**
-    Replace the given range with the given content, which may be a
-    fragment, node, or array of nodes.
-    */
-    replaceWith(from, to, content) {
-        return this.replace(from, to, new prosemirrorModel.Slice(prosemirrorModel.Fragment.from(content), 0, 0));
-    }
-    /**
-    Delete the content between the given positions.
-    */
-    delete(from, to) {
-        return this.replace(from, to, prosemirrorModel.Slice.empty);
-    }
-    /**
-    Insert the given content at the given position.
-    */
-    insert(pos, content) {
-        return this.replaceWith(pos, pos, content);
-    }
-    /**
-    Replace a range of the document with a given slice, using
-    `from`, `to`, and the slice's
-    [`openStart`](https://prosemirror.net/docs/ref/#model.Slice.openStart) property as hints, rather
-    than fixed start and end points. This method may grow the
-    replaced area or close open nodes in the slice in order to get a
-    fit that is more in line with WYSIWYG expectations, by dropping
-    fully covered parent nodes of the replaced region when they are
-    marked [non-defining as
-    context](https://prosemirror.net/docs/ref/#model.NodeSpec.definingAsContext), or including an
-    open parent node from the slice that _is_ marked as [defining
-    its content](https://prosemirror.net/docs/ref/#model.NodeSpec.definingForContent).
-    
-    This is the method, for example, to handle paste. The similar
-    [`replace`](https://prosemirror.net/docs/ref/#transform.Transform.replace) method is a more
-    primitive tool which will _not_ move the start and end of its given
-    range, and is useful in situations where you need more precise
-    control over what happens.
-    */
-    replaceRange(from, to, slice) {
-        replaceRange(this, from, to, slice);
-        return this;
-    }
-    /**
-    Replace the given range with a node, but use `from` and `to` as
-    hints, rather than precise positions. When from and to are the same
-    and are at the start or end of a parent node in which the given
-    node doesn't fit, this method may _move_ them out towards a parent
-    that does allow the given node to be placed. When the given range
-    completely covers a parent node, this method may completely replace
-    that parent node.
-    */
-    replaceRangeWith(from, to, node) {
-        replaceRangeWith(this, from, to, node);
-        return this;
-    }
-    /**
-    Delete the given range, expanding it to cover fully covered
-    parent nodes until a valid replace is found.
-    */
-    deleteRange(from, to) {
-        deleteRange(this, from, to);
-        return this;
-    }
-    /**
-    Split the content in the given range off from its parent, if there
-    is sibling content before or after it, and move it up the tree to
-    the depth specified by `target`. You'll probably want to use
-    [`liftTarget`](https://prosemirror.net/docs/ref/#transform.liftTarget) to compute `target`, to make
-    sure the lift is valid.
-    */
-    lift(range, target) {
-        lift(this, range, target);
-        return this;
-    }
-    /**
-    Join the blocks around the given position. If depth is 2, their
-    last and first siblings are also joined, and so on.
-    */
-    join(pos, depth = 1) {
-        join(this, pos, depth);
-        return this;
-    }
-    /**
-    Wrap the given [range](https://prosemirror.net/docs/ref/#model.NodeRange) in the given set of wrappers.
-    The wrappers are assumed to be valid in this position, and should
-    probably be computed with [`findWrapping`](https://prosemirror.net/docs/ref/#transform.findWrapping).
-    */
-    wrap(range, wrappers) {
-        wrap(this, range, wrappers);
-        return this;
-    }
-    /**
-    Set the type of all textblocks (partly) between `from` and `to` to
-    the given node type with the given attributes.
-    */
-    setBlockType(from, to = from, type, attrs = null) {
-        setBlockType(this, from, to, type, attrs);
-        return this;
-    }
-    /**
-    Change the type, attributes, and/or marks of the node at `pos`.
-    When `type` isn't given, the existing node type is preserved,
-    */
-    setNodeMarkup(pos, type, attrs = null, marks = []) {
-        setNodeMarkup(this, pos, type, attrs, marks);
-        return this;
-    }
-    /**
-    Set a single attribute on a given node to a new value.
-    */
-    setNodeAttribute(pos, attr, value) {
-        this.step(new AttrStep(pos, attr, value));
-        return this;
-    }
-    /**
-    Add a mark to the node at position `pos`.
-    */
-    addNodeMark(pos, mark) {
-        this.step(new AddNodeMarkStep(pos, mark));
-        return this;
-    }
-    /**
-    Remove a mark (or a mark of the given type) from the node at
-    position `pos`.
-    */
-    removeNodeMark(pos, mark) {
-        if (!(mark instanceof prosemirrorModel.Mark)) {
-            let node = this.doc.nodeAt(pos);
-            if (!node)
-                throw new RangeError("No node at position " + pos);
-            mark = mark.isInSet(node.marks);
-            if (!mark)
-                return this;
-        }
-        this.step(new RemoveNodeMarkStep(pos, mark));
-        return this;
-    }
-    /**
-    Split the node at the given position, and optionally, if `depth` is
-    greater than one, any number of nodes above that. By default, the
-    parts split off will inherit the node type of the original node.
-    This can be changed by passing an array of types and attributes to
-    use after the split.
-    */
-    split(pos, depth = 1, typesAfter) {
-        split(this, pos, depth, typesAfter);
-        return this;
-    }
-    /**
-    Add the given mark to the inline content between `from` and `to`.
-    */
-    addMark(from, to, mark) {
-        addMark(this, from, to, mark);
-        return this;
-    }
-    /**
-    Remove marks from inline nodes between `from` and `to`. When
-    `mark` is a single mark, remove precisely that mark. When it is
-    a mark type, remove all marks of that type. When it is null,
-    remove all marks of any type.
-    */
-    removeMark(from, to, mark) {
-        removeMark(this, from, to, mark);
-        return this;
-    }
-    /**
-    Removes all marks and nodes from the content of the node at
-    `pos` that don't match the given new parent node type. Accepts
-    an optional starting [content match](https://prosemirror.net/docs/ref/#model.ContentMatch) as
-    third argument.
-    */
-    clearIncompatible(pos, parentType, match) {
-        clearIncompatible(this, pos, parentType, match);
-        return this;
-    }
-}
-
-// Because working with row and column-spanning cells is not quite
-// trivial, this code builds up a descriptive structure for a given
-// table node. The structures are cached with the (persistent) table
-// nodes as key, so that they only have to be recomputed when the
-// content of the table changes.
-//
-// This does mean that they have to store table-relative, not
-// document-relative positions. So code that uses them will typically
-// compute the start position of the table and offset positions passed
-// to or gotten from this structure by that amount.
-let readFromCache, addToCache; // Prefer using a weak map to cache table maps. Fall back on a
-// fixed-size cache if that's not supported.
-
-if (typeof WeakMap != 'undefined') {
-  // eslint-disable-next-line
-  let cache = new WeakMap();
-
-  readFromCache = key => cache.get(key);
-
-  addToCache = (key, value) => {
-    cache.set(key, value);
-    return value;
-  };
-} else {
-  let cache = [],
-      cacheSize = 10,
-      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;
-  };
-}
-
-class Rect {
-  constructor(left, top, right, bottom) {
-    this.left = left;
-    this.top = top;
-    this.right = right;
-    this.bottom = bottom;
-  }
-
-} // ::- A table map describes the structore 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.
-
-class TableMap {
-  constructor(width, height, map, problems) {
-    // :: number The width of the table
-    this.width = width; // :: number The table's height
-
-    this.height = height; // :: [number] A width * height array with the start position of
-    // the cell covering that part of the table in each slot
-
-    this.map = map; // An optional array of problems (cell overlap or non-rectangular
-    // shape) for the table, used by the table normalizer.
-
-    this.problems = problems;
-  } // :: (number) → Rect
-  // Find the dimensions of the cell at the given position.
-
-
-  findCell(pos) {
-    for (let i = 0; i < this.map.length; i++) {
-      let curPos = this.map[i];
-      if (curPos != pos) continue;
-      let left = i % this.width,
-          top = i / this.width | 0;
-      let right = left + 1,
-          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 new Rect(left, top, right, bottom);
-    }
-
-    throw new RangeError('No cell with offset ' + pos + ' found');
-  } // :: (number) → number
-  // Find the left side of the cell at the given position.
-
-
-  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');
-  } // :: (number, string, number) → ?number
-  // Find the next cell in the given direction, starting from the cell
-  // at `pos`, if any.
-
-
-  nextCell(pos, axis, dir) {
-    let {
-      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)];
-    }
-  } // :: (number, number) → Rect
-  // Get the rectangle spanning the two given cells.
-
-
-  rectBetween(a, b) {
-    let {
-      left: leftA,
-      right: rightA,
-      top: topA,
-      bottom: bottomA
-    } = this.findCell(a);
-    let {
-      left: leftB,
-      right: rightB,
-      top: topB,
-      bottom: bottomB
-    } = this.findCell(b);
-    return new Rect(Math.min(leftA, leftB), Math.min(topA, topB), Math.max(rightA, rightB), Math.max(bottomA, bottomB));
-  } // :: (Rect) → [number]
-  // Return the position of all cells that have the top left corner in
-  // the given rectangle.
-
-
-  cellsInRect(rect) {
-    let result = [],
-        seen = {};
-
-    for (let row = rect.top; row < rect.bottom; row++) {
-      for (let col = rect.left; col < rect.right; col++) {
-        let index = row * this.width + col,
-            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)) result.push(pos);
-      }
-    }
-
-    return result;
-  } // :: (number, number, Node) → number
-  // Return the position at which the cell at the given row and column
-  // starts, or would start, if a cell started there.
-
-
-  positionAt(row, col, table) {
-    for (let i = 0, rowStart = 0;; i++) {
-      let rowEnd = rowStart + table.child(i).nodeSize;
-
-      if (i == row) {
-        let index = col + row * this.width,
-            rowEndIndex = (row + 1) * this.width; // Skip past cells from previous rows (via rowspan)
-
-        while (index < rowEndIndex && this.map[index] < rowStart) index++;
-
-        return index == rowEndIndex ? rowEnd - 1 : this.map[index];
-      }
-
-      rowStart = rowEnd;
-    }
-  } // :: (Node) → TableMap
-  // Find the table map for the given table node.
-
-
-  static get(table) {
-    return readFromCache(table) || addToCache(table, computeMap(table));
-  }
-
-} // Compute a table map.
-
-function computeMap(table) {
-  if (table.type.spec.tableRole != 'table') throw new RangeError('Not a table node: ' + table.type.name);
-  let width = findWidth(table),
-      height = table.childCount;
-  let map = [],
-      mapPos = 0,
-      problems = null,
-      colWidths = [];
-
-  for (let i = 0, e = width * height; i < e; i++) map[i] = 0;
-
-  for (let row = 0, pos = 0; row < height; row++) {
-    let rowNode = table.child(row);
-    pos++;
-
-    for (let i = 0;; i++) {
-      while (mapPos < map.length && map[mapPos] != 0) mapPos++;
-
-      if (i == rowNode.childCount) break;
-      let cellNode = rowNode.child(i),
-          {
-        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;
-        }
-
-        let 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
-          });
-          let colW = colwidth && colwidth[w];
-
-          if (colW) {
-            let 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;
-    }
-
-    let expectedPos = (row + 1) * width,
-        missing = 0;
-
-    while (mapPos < expectedPos) if (map[mapPos++] == 0) missing++;
-
-    if (missing) (problems || (problems = [])).push({
-      type: 'missing',
-      row,
-      n: missing
-    });
-    pos++;
-  }
-
-  let tableMap = new TableMap(width, height, map, problems),
-      badWidths = false; // For columns that have defined widths, but whose widths disagree
-  // between rows, fix up the cells whose width doesn't match the
-  // computed one.
-
-  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,
-      hasRowSpan = false;
-
-  for (let row = 0; row < table.childCount; row++) {
-    let rowNode = table.child(row),
-        rowWidth = 0;
-    if (hasRowSpan) for (let j = 0; j < row; j++) {
-      let prevRow = table.child(j);
-
-      for (let i = 0; i < prevRow.childCount; i++) {
-        let cell = prevRow.child(i);
-        if (j + cell.attrs.rowspan > row) rowWidth += cell.attrs.colspan;
-      }
-    }
-
-    for (let i = 0; i < rowNode.childCount; i++) {
-      let 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 = [];
-
-  for (let i = 0, seen = {}; i < map.map.length; i++) {
-    let pos = map.map[i];
-    if (seen[pos]) continue;
-    seen[pos] = true;
-    let node = table.nodeAt(pos),
-        updated = null;
-
-    for (let j = 0; j < node.attrs.colspan; j++) {
-      let col = (i + j) % map.width,
-          colWidth = colWidths[col * 2];
-      if (colWidth != null && (!node.attrs.colwidth || node.attrs.colwidth[j] != colWidth)) (updated || (updated = freshColWidth(node.attrs)))[j] = colWidth;
-    }
-
-    if (updated) map.problems.unshift({
-      type: 'colwidth mismatch',
-      pos,
-      colwidth: updated
-    });
-  }
-}
-
-function freshColWidth(attrs) {
-  if (attrs.colwidth) return attrs.colwidth.slice();
-  let result = [];
-
-  for (let i = 0; i < attrs.colspan; i++) result.push(0);
-
-  return result;
-}
-function tableNodeTypes(schema) {
-  let result = schema.cached.tableNodeTypes;
-
-  if (!result) {
-    result = schema.cached.tableNodeTypes = {};
-
-    for (let name in schema.nodes) {
-      let type = schema.nodes[name],
-          role = type.spec.tableRole;
-      if (role) result[role] = type;
-    }
-  }
-
-  return result;
-}
-
-// Various helper function for working with tables
-const key$1 = new prosemirrorState.PluginKey('selectingCells');
-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;
-}
-function cellWrapping($pos) {
-  for (let d = $pos.depth; d > 0; d--) {
-    // Sometimes the cell can be in the same depth.
-    const role = $pos.node(d).type.spec.tableRole;
-    if (role === 'cell' || role === 'header_cell') return $pos.node(d);
-  }
-
-  return null;
-}
-function isInTable(state) {
-  let $head = state.selection.$head;
-
-  for (let d = $head.depth; d > 0; d--) if ($head.node(d).type.spec.tableRole == 'row') return true;
-
-  return false;
-}
-function selectionCell(state) {
-  let sel = state.selection;
-
-  if (sel.$anchorCell) {
-    return sel.$anchorCell.pos > sel.$headCell.pos ? sel.$anchorCell : sel.$headCell;
-  } else if (sel.node && sel.node.type.spec.tableRole == 'cell') {
-    return sel.$anchor;
-  }
-
-  return cellAround(sel.$head) || cellNear(sel.$head);
-}
-
-function cellNear($pos) {
-  for (let after = $pos.nodeAfter, pos = $pos.pos; after; after = after.firstChild, pos++) {
-    let 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--) {
-    let role = before.type.spec.tableRole;
-    if (role == 'cell' || role == 'header_cell') return $pos.doc.resolve(pos - before.nodeSize);
-  }
-}
-
-function pointsAtCell($pos) {
-  return $pos.parent.type.spec.tableRole == 'row' && $pos.nodeAfter;
-}
-function moveCellForward($pos) {
-  return $pos.node(0).resolve($pos.pos + $pos.nodeAfter.nodeSize);
-}
-function inSameTable($a, $b) {
-  return $a.depth == $b.depth && $a.pos >= $b.start(-1) && $a.pos <= $b.end(-1);
-}
-function nextCell($pos, axis, dir) {
-  let start = $pos.start(-1),
-      map = TableMap.get($pos.node(-1));
-  let moved = map.nextCell($pos.pos - start, axis, dir);
-  return moved == null ? null : $pos.node(0).resolve(start + moved);
-}
-function setAttr(attrs, name, value) {
-  let result = {};
-
-  for (let prop in attrs) result[prop] = attrs[prop];
-
-  result[name] = value;
-  return result;
-}
-function removeColSpan(attrs, pos, n = 1) {
-  let result = setAttr(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;
-}
-function addColSpan(attrs, pos, n = 1) {
-  let result = setAttr(attrs, 'colspan', attrs.colspan + n);
-
-  if (result.colwidth) {
-    result.colwidth = result.colwidth.slice();
-
-    for (let i = 0; i < n; i++) result.colwidth.splice(pos, 0, 0);
-  }
-
-  return result;
-}
-function columnIsHeader(map, table, col) {
-  let headerCell = tableNodeTypes(table.type.schema).header_cell;
-
-  for (let row = 0; row < map.height; row++) if (table.nodeAt(map.map[col + row * map.width]).type != headerCell) return false;
-
-  return true;
-}
-
-// This file defines a ProseMirror selection subclass that models
-// 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.
-
-class CellSelection extends prosemirrorState.Selection {
-  // :: (ResolvedPos, ?ResolvedPos)
-  // A table selection is identified by its anchor and head cells. The
-  // positions given to this constructor should point _before_ two
-  // cells in the same table. They may be the same, to select a single
-  // cell.
-  constructor($anchorCell, $headCell = $anchorCell) {
-    let table = $anchorCell.node(-1),
-        map = TableMap.get(table),
-        start = $anchorCell.start(-1);
-    let rect = map.rectBetween($anchorCell.pos - start, $headCell.pos - start);
-    let doc = $anchorCell.node(0);
-    let cells = map.cellsInRect(rect).filter(p => p != $headCell.pos - start); // Make the head cell the first range, so that it counts as the
-    // primary part of the selection
-
-    cells.unshift($headCell.pos - start);
-    let ranges = cells.map(pos => {
-      let cell = table.nodeAt(pos),
-          from = pos + start + 1;
-      return new prosemirrorState.SelectionRange(doc.resolve(from), doc.resolve(from + cell.content.size));
-    });
-    super(ranges[0].$from, ranges[0].$to, ranges); // :: ResolvedPos
-    // A resolved position pointing _in front of_ the anchor cell (the one
-    // that doesn't move when extending the selection).
-
-    this.$anchorCell = $anchorCell; // :: ResolvedPos
-    // A resolved position pointing in front of the head cell (the one
-    // moves when extending the selection).
-
-    this.$headCell = $headCell;
-  }
-
-  map(doc, mapping) {
-    let $anchorCell = doc.resolve(mapping.map(this.$anchorCell.pos));
-    let $headCell = doc.resolve(mapping.map(this.$headCell.pos));
-
-    if (pointsAtCell($anchorCell) && pointsAtCell($headCell) && inSameTable($anchorCell, $headCell)) {
-      let 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 prosemirrorState.TextSelection.between($anchorCell, $headCell);
-  } // :: () → Slice
-  // Returns a rectangular slice of table rows containing the selected
-  // cells.
-
-
-  content() {
-    let table = this.$anchorCell.node(-1),
-        map = TableMap.get(table),
-        start = this.$anchorCell.start(-1);
-    let rect = map.rectBetween(this.$anchorCell.pos - start, this.$headCell.pos - start);
-    let seen = {},
-        rows = [];
-
-    for (let row = rect.top; row < rect.bottom; row++) {
-      let rowContent = [];
-
-      for (let index = row * map.width + rect.left, col = rect.left; col < rect.right; col++, index++) {
-        let pos = map.map[index];
-
-        if (!seen[pos]) {
-          seen[pos] = true;
-          let cellRect = map.findCell(pos),
-              cell = table.nodeAt(pos);
-          let extraLeft = rect.left - cellRect.left,
-              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);else cell = cell.type.create(attrs, cell.content);
-          }
-
-          if (cellRect.top < rect.top || cellRect.bottom > rect.bottom) {
-            let attrs = setAttr(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(prosemirrorModel.Fragment.from(rowContent)));
-    }
-
-    const fragment = this.isColSelection() && this.isRowSelection() ? table : rows;
-    return new prosemirrorModel.Slice(prosemirrorModel.Fragment.from(fragment), 1, 1);
-  }
-
-  replace(tr, content = prosemirrorModel.Slice.empty) {
-    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.replace(mapping.map($from.pos), mapping.map($to.pos), i ? prosemirrorModel.Slice.empty : content);
-    }
-
-    let sel = prosemirrorState.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 prosemirrorModel.Slice(prosemirrorModel.Fragment.from(node), 0, 0));
-  }
-
-  forEachCell(f) {
-    let table = this.$anchorCell.node(-1),
-        map = TableMap.get(table),
-        start = this.$anchorCell.start(-1);
-    let cells = map.cellsInRect(map.rectBetween(this.$anchorCell.pos - start, this.$headCell.pos - start));
-
-    for (let i = 0; i < cells.length; i++) f(table.nodeAt(cells[i]), start + cells[i]);
-  } // :: () → bool
-  // True if this selection goes all the way from the top to the
-  // bottom of the table.
-
-
-  isColSelection() {
-    let anchorTop = this.$anchorCell.index(-1),
-        headTop = this.$headCell.index(-1);
-    if (Math.min(anchorTop, headTop) > 0) return false;
-    let anchorBot = anchorTop + this.$anchorCell.nodeAfter.attrs.rowspan,
-        headBot = headTop + this.$headCell.nodeAfter.attrs.rowspan;
-    return Math.max(anchorBot, headBot) == this.$headCell.node(-1).childCount;
-  } // :: (ResolvedPos, ?ResolvedPos) → CellSelection
-  // Returns the smallest column selection that covers the given anchor
-  // and head cell.
-
-
-  static colSelection($anchorCell, $headCell = $anchorCell) {
-    let map = TableMap.get($anchorCell.node(-1)),
-        start = $anchorCell.start(-1);
-    let anchorRect = map.findCell($anchorCell.pos - start),
-        headRect = map.findCell($headCell.pos - start);
-    let doc = $anchorCell.node(0);
-
-    if (anchorRect.top <= headRect.top) {
-      if (anchorRect.top > 0) $anchorCell = doc.resolve(start + map.map[anchorRect.left]);
-      if (headRect.bottom < map.height) $headCell = doc.resolve(start + map.map[map.width * (map.height - 1) + headRect.right - 1]);
-    } else {
-      if (headRect.top > 0) $headCell = doc.resolve(start + map.map[headRect.left]);
-      if (anchorRect.bottom < map.height) $anchorCell = doc.resolve(start + map.map[map.width * (map.height - 1) + anchorRect.right - 1]);
-    }
-
-    return new CellSelection($anchorCell, $headCell);
-  } // :: () → bool
-  // True if this selection goes all the way from the left to the
-  // right of the table.
-
-
-  isRowSelection() {
-    let map = TableMap.get(this.$anchorCell.node(-1)),
-        start = this.$anchorCell.start(-1);
-    let anchorLeft = map.colCount(this.$anchorCell.pos - start),
-        headLeft = map.colCount(this.$headCell.pos - start);
-    if (Math.min(anchorLeft, headLeft) > 0) return false;
-    let anchorRight = anchorLeft + this.$anchorCell.nodeAfter.attrs.colspan,
-        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;
-  } // :: (ResolvedPos, ?ResolvedPos) → CellSelection
-  // Returns the smallest row selection that covers the given anchor
-  // and head cell.
-
-
-  static rowSelection($anchorCell, $headCell = $anchorCell) {
-    let map = TableMap.get($anchorCell.node(-1)),
-        start = $anchorCell.start(-1);
-    let anchorRect = map.findCell($anchorCell.pos - start),
-        headRect = map.findCell($headCell.pos - start);
-    let doc = $anchorCell.node(0);
-
-    if (anchorRect.left <= headRect.left) {
-      if (anchorRect.left > 0) $anchorCell = doc.resolve(start + map.map[anchorRect.top * map.width]);
-      if (headRect.right < map.width) $headCell = doc.resolve(start + map.map[map.width * (headRect.top + 1) - 1]);
-    } else {
-      if (headRect.left > 0) $headCell = doc.resolve(start + map.map[headRect.top * map.width]);
-      if (anchorRect.right < map.width) $anchorCell = doc.resolve(start + 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));
-  } // :: (Node, number, ?number) → CellSelection
-
-
-  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;
-prosemirrorState.Selection.jsonID('cell', CellSelection);
-
-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) {
-    let $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 prosemirrorState.Selection.near($headCell, 1);
-  }
-
-}
-
-function drawCellSelection(state) {
-  if (!(state.selection instanceof CellSelection)) return null;
-  let cells = [];
-  state.selection.forEachCell((node, pos) => {
-    cells.push(prosemirrorView.Decoration.node(pos, pos + node.nodeSize, {
-      class: 'selectedCell'
-    }));
-  });
-  return prosemirrorView.DecorationSet.create(state.doc, cells);
-}
-
-function isCellBoundarySelection({
-  $from,
-  $to
-}) {
-  if ($from.pos == $to.pos || $from.pos < $from.pos - 6) return false; // Cheap elimination
-
-  let afterFrom = $from.pos,
-      beforeTo = $to.pos,
-      depth = $from.depth;
-
-  for (; depth >= 0; depth--, afterFrom++) if ($from.after(depth + 1) < $from.end(depth)) break;
-
-  for (let d = $to.depth; d >= 0; d--, beforeTo--) if ($to.before(d + 1) > $to.start(d)) break;
-
-  return afterFrom == beforeTo && /row|table/.test($from.node(depth).type.spec.tableRole);
-}
-
-function isTextSelectionAcrossCells({
-  $from,
-  $to
-}) {
-  let fromCellBoundaryNode;
-  let toCellBoundaryNode;
-
-  for (let i = $from.depth; i > 0; i--) {
-    let node = $from.node(i);
-
-    if (node.type.spec.tableRole === 'cell' || node.type.spec.tableRole === 'header_cell') {
-      fromCellBoundaryNode = node;
-      break;
-    }
-  }
-
-  for (let i = $to.depth; i > 0; i--) {
-    let node = $to.node(i);
-
-    if (node.type.spec.tableRole === 'cell' || node.type.spec.tableRole === 'header_cell') {
-      toCellBoundaryNode = node;
-      break;
-    }
-  }
-
-  return fromCellBoundaryNode !== toCellBoundaryNode && $to.parentOffset === 0;
-}
-
-function normalizeSelection(state, tr, allowTableNodeSelection) {
-  let sel = (tr || state).selection,
-      doc = (tr || state).doc,
-      normalize,
-      role;
-
-  if (sel instanceof prosemirrorState.NodeSelection && (role = sel.node.type.spec.tableRole)) {
-    if (role == 'cell' || role == 'header_cell') {
-      normalize = CellSelection.create(doc, sel.from);
-    } else if (role == 'row') {
-      let $cell = doc.resolve(sel.from + 1);
-      normalize = CellSelection.rowSelection($cell, $cell);
-    } else if (!allowTableNodeSelection) {
-      let map = TableMap.get(sel.node),
-          start = sel.from + 1;
-      let lastCell = start + map.map[map.width * map.height - 1];
-      normalize = CellSelection.create(doc, start + 1, lastCell);
-    }
-  } else if (sel instanceof prosemirrorState.TextSelection && isCellBoundarySelection(sel)) {
-    normalize = prosemirrorState.TextSelection.create(doc, sel.from);
-  } else if (sel instanceof prosemirrorState.TextSelection && isTextSelectionAcrossCells(sel)) {
-    normalize = prosemirrorState.TextSelection.create(doc, sel.$from.start(), sel.$from.end());
-  }
-
-  if (normalize) (tr || (tr = state.tr)).setSelection(normalize);
-  return tr;
-}
-
-// Utilities used for copy/paste handling.
-// : (Slice) → ?{width: number, height: number, rows: [Fragment]}
-// Get a rectangular area of cells from a slice, or null if the outer
-// nodes of the slice aren't table cells or rows.
-
-function pastedCells(slice) {
-  if (!slice.size) return null;
-  let {
-    content,
-    openStart,
-    openEnd
-  } = slice;
-
-  while (content.childCount == 1 && (openStart > 0 && openEnd > 0 || content.firstChild.type.spec.tableRole == 'table')) {
-    openStart--;
-    openEnd--;
-    content = content.firstChild.content;
-  }
-
-  let first = content.firstChild,
-      role = first.type.spec.tableRole;
-  let schema = first.type.schema,
-      rows = [];
-
-  if (role == 'row') {
-    for (let i = 0; i < content.childCount; i++) {
-      let cells = content.child(i).content;
-      let left = i ? 0 : Math.max(0, openStart - 1);
-      let right = i < content.childCount - 1 ? 0 : Math.max(0, openEnd - 1);
-      if (left || right) cells = fitSlice(tableNodeTypes(schema).row, new prosemirrorModel.Slice(cells, left, right)).content;
-      rows.push(cells);
-    }
-  } else if (role == 'cell' || role == 'header_cell') {
-    rows.push(openStart || openEnd ? fitSlice(tableNodeTypes(schema).row, new prosemirrorModel.Slice(content, openStart, openEnd)).content : content);
-  } else {
-    return null;
-  }
-
-  return ensureRectangular(schema, rows);
-} // : (Schema, [Fragment]) → {width: number, height: number, rows: [Fragment]}
-// Compute the width and height of a set of cells, and make sure each
-// row has the same number of cells.
-
-function ensureRectangular(schema, rows) {
-  let widths = [];
-
-  for (let i = 0; i < rows.length; i++) {
-    let row = rows[i];
-
-    for (let j = row.childCount - 1; j >= 0; j--) {
-      let {
-        rowspan,
-        colspan
-      } = row.child(j).attrs;
-
-      for (let r = i; r < i + rowspan; r++) widths[r] = (widths[r] || 0) + colspan;
-    }
-  }
-
-  let width = 0;
-
-  for (let r = 0; r < widths.length; r++) width = Math.max(width, widths[r]);
-
-  for (let r = 0; r < widths.length; r++) {
-    if (r >= rows.length) rows.push(prosemirrorModel.Fragment.empty);
-
-    if (widths[r] < width) {
-      let empty = tableNodeTypes(schema).cell.createAndFill(),
-          cells = [];
-
-      for (let i = widths[r]; i < width; i++) cells.push(empty);
-
-      rows[r] = rows[r].append(prosemirrorModel.Fragment.from(cells));
-    }
-  }
-
-  return {
-    height: rows.length,
-    width,
-    rows
-  };
-}
-
-function fitSlice(nodeType, slice) {
-  let node = nodeType.createAndFill();
-  let tr = new Transform(node).replace(0, node.content.size, slice);
-  return tr.doc;
-} // : ({width: number, height: number, rows: [Fragment]}, number, number) → {width: number, height: number, rows: [Fragment]}
-// Clip or extend (repeat) the given set of cells to cover the given
-// width and height. Will clip rowspan/colspan cells at the edges when
-// they stick out.
-
-function clipCells({
-  width,
-  height,
-  rows
-}, newWidth, newHeight) {
-  if (width != newWidth) {
-    let added = [],
-        newRows = [];
-
-    for (let row = 0; row < rows.length; row++) {
-      let frag = rows[row],
-          cells = [];
-
-      for (let col = added[row] || 0, i = 0; col < newWidth; i++) {
-        let cell = frag.child(i % frag.childCount);
-        if (col + cell.attrs.colspan > newWidth) cell = cell.type.create(removeColSpan(cell.attrs, cell.attrs.colspan, col + cell.attrs.colspan - newWidth), cell.content);
-        cells.push(cell);
-        col += cell.attrs.colspan;
-
-        for (let j = 1; j < cell.attrs.rowspan; j++) added[row + j] = (added[row + j] || 0) + cell.attrs.colspan;
-      }
-
-      newRows.push(prosemirrorModel.Fragment.from(cells));
-    }
-
-    rows = newRows;
-    width = newWidth;
-  }
-
-  if (height != newHeight) {
-    let newRows = [];
-
-    for (let row = 0, i = 0; row < newHeight; row++, i++) {
-      let cells = [],
-          source = rows[i % height];
-
-      for (let j = 0; j < source.childCount; j++) {
-        let cell = source.child(j);
-        if (row + cell.attrs.rowspan > newHeight) cell = cell.type.create(setAttr(cell.attrs, 'rowspan', Math.max(1, newHeight - cell.attrs.rowspan)), cell.content);
-        cells.push(cell);
-      }
-
-      newRows.push(prosemirrorModel.Fragment.from(cells));
-    }
-
-    rows = newRows;
-    height = newHeight;
-  }
-
-  return {
-    width,
-    height,
-    rows
-  };
-} // Make sure a table has at least the given width and height. Return
-// true if something was changed.
-
-function growTable(tr, map, table, start, width, height, mapFrom) {
-  let schema = tr.doc.type.schema,
-      types = tableNodeTypes(schema),
-      empty,
-      emptyHead;
-
-  if (width > map.width) {
-    for (let row = 0, rowEnd = 0; row < map.height; row++) {
-      let rowNode = table.child(row);
-      rowEnd += rowNode.nodeSize;
-      let cells = [],
-          add;
-      if (rowNode.lastChild == null || rowNode.lastChild.type == types.cell) add = empty || (empty = types.cell.createAndFill());else add = emptyHead || (emptyHead = types.header_cell.createAndFill());
-
-      for (let i = map.width; i < width; i++) cells.push(add);
-
-      tr.insert(tr.mapping.slice(mapFrom).map(rowEnd - 1 + start), cells);
-    }
-  }
-
-  if (height > map.height) {
-    let cells = [];
-
-    for (let i = 0, start = (map.height - 1) * map.width; i < Math.max(map.width, width); i++) {
-      let header = i >= map.width ? false : table.nodeAt(map.map[start + i]).type == types.header_cell;
-      cells.push(header ? emptyHead || (emptyHead = types.header_cell.createAndFill()) : empty || (empty = types.cell.createAndFill()));
-    }
-
-    let emptyRow = types.row.create(null, prosemirrorModel.Fragment.from(cells)),
-        rows = [];
-
-    for (let i = map.height; i < height; i++) rows.push(emptyRow);
-
-    tr.insert(tr.mapping.slice(mapFrom).map(start + table.nodeSize - 2), rows);
-  }
-
-  return !!(empty || emptyHead);
-} // Make sure the given line (left, top) to (right, top) doesn't cross
-// any rowspan cells by splitting cells that cross it. Return true if
-// something changed.
-
-
-function isolateHorizontal(tr, map, table, start, left, right, top, mapFrom) {
-  if (top == 0 || top == map.height) return false;
-  let found = false;
-
-  for (let col = left; col < right; col++) {
-    let index = top * map.width + col,
-        pos = map.map[index];
-
-    if (map.map[index - map.width] == pos) {
-      found = true;
-      let cell = table.nodeAt(pos);
-      let {
-        top: cellTop,
-        left: cellLeft
-      } = map.findCell(pos);
-      tr.setNodeMarkup(tr.mapping.slice(mapFrom).map(pos + start), null, setAttr(cell.attrs, 'rowspan', top - cellTop));
-      tr.insert(tr.mapping.slice(mapFrom).map(map.positionAt(top, cellLeft, table)), cell.type.createAndFill(setAttr(cell.attrs, 'rowspan', cellTop + cell.attrs.rowspan - top)));
-      col += cell.attrs.colspan - 1;
-    }
-  }
-
-  return found;
-} // Make sure the given line (left, top) to (left, bottom) doesn't
-// cross any colspan cells by splitting cells that cross it. Return
-// true if something changed.
-
-
-function isolateVertical(tr, map, table, start, top, bottom, left, mapFrom) {
-  if (left == 0 || left == map.width) return false;
-  let found = false;
-
-  for (let row = top; row < bottom; row++) {
-    let index = row * map.width + left,
-        pos = map.map[index];
-
-    if (map.map[index - 1] == pos) {
-      found = true;
-      let cell = table.nodeAt(pos),
-          cellLeft = map.colCount(pos);
-      let updatePos = tr.mapping.slice(mapFrom).map(pos + start);
-      tr.setNodeMarkup(updatePos, null, removeColSpan(cell.attrs, left - cellLeft, cell.attrs.colspan - (left - cellLeft)));
-      tr.insert(updatePos + cell.nodeSize, cell.type.createAndFill(removeColSpan(cell.attrs, 0, left - cellLeft)));
-      row += cell.attrs.rowspan - 1;
-    }
-  }
-
-  return found;
-} // Insert the given set of cells (as returned by `pastedCells`) into a
-// table, at the position pointed at by rect.
-
-
-function insertCells(state, dispatch, tableStart, rect, cells) {
-  let table = tableStart ? state.doc.nodeAt(tableStart - 1) : state.doc,
-      map = TableMap.get(table);
-  let {
-    top,
-    left
-  } = rect;
-  let right = left + cells.width,
-      bottom = top + cells.height;
-  let tr = state.tr,
-      mapFrom = 0;
-
-  function recomp() {
-    table = tableStart ? tr.doc.nodeAt(tableStart - 1) : tr.doc;
-    map = TableMap.get(table);
-    mapFrom = tr.mapping.maps.length;
-  } // Prepare the table to be large enough and not have any cells
-  // crossing the boundaries of the rectangle that we want to
-  // insert into. If anything about it changes, recompute the table
-  // map so that subsequent operations can see the current shape.
-
-
-  if (growTable(tr, map, table, tableStart, right, bottom, mapFrom)) recomp();
-  if (isolateHorizontal(tr, map, table, tableStart, left, right, top, mapFrom)) recomp();
-  if (isolateHorizontal(tr, map, table, tableStart, left, right, bottom, mapFrom)) recomp();
-  if (isolateVertical(tr, map, table, tableStart, top, bottom, left, mapFrom)) recomp();
-  if (isolateVertical(tr, map, table, tableStart, top, bottom, right, mapFrom)) recomp();
-
-  for (let row = top; row < bottom; row++) {
-    let from = map.positionAt(row, left, table),
-        to = map.positionAt(row, right, table);
-    tr.replace(tr.mapping.slice(mapFrom).map(from + tableStart), tr.mapping.slice(mapFrom).map(to + tableStart), new prosemirrorModel.Slice(cells.rows[row - top], 0, 0));
-  }
-
-  recomp();
-  tr.setSelection(new CellSelection(tr.doc.resolve(tableStart + map.positionAt(top, left, table)), tr.doc.resolve(tableStart + map.positionAt(bottom - 1, right - 1, table))));
-  dispatch(tr);
-}
-
-// This file defines a number of helpers for wiring up user input to
-const handleKeyDown = 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;
-}
-
-function arrow(axis, dir) {
-  return (state, dispatch, view) => {
-    let sel = state.selection;
-
-    if (sel instanceof CellSelection) {
-      return maybeSetSelection(state, dispatch, prosemirrorState.Selection.near(sel.$headCell, dir));
-    }
-
-    if (axis != 'horiz' && !sel.empty) return false;
-    let end = atEndOfCell(view, axis, dir);
-    if (end == null) return false;
-
-    if (axis == 'horiz') {
-      return maybeSetSelection(state, dispatch, prosemirrorState.Selection.near(state.doc.resolve(sel.head + dir), dir));
-    } else {
-      let $cell = state.doc.resolve(end),
-          $next = nextCell($cell, axis, dir),
-          newSel;
-      if ($next) newSel = prosemirrorState.Selection.near($next, 1);else if (dir < 0) newSel = prosemirrorState.Selection.near(state.doc.resolve($cell.before(-1)), -1);else newSel = prosemirrorState.Selection.near(state.doc.resolve($cell.after(-1)), 1);
-      return maybeSetSelection(state, dispatch, newSel);
-    }
-  };
-}
-
-function shiftArrow(axis, dir) {
-  return (state, dispatch, view) => {
-    let sel = state.selection;
-
-    if (!(sel instanceof CellSelection)) {
-      let end = atEndOfCell(view, axis, dir);
-      if (end == null) return false;
-      sel = new CellSelection(state.doc.resolve(end));
-    }
-
-    let $head = nextCell(sel.$headCell, axis, dir);
-    if (!$head) return false;
-    return maybeSetSelection(state, dispatch, new CellSelection(sel.$anchorCell, $head));
-  };
-}
-
-function deleteCellSelection(state, dispatch) {
-  let sel = state.selection;
-  if (!(sel instanceof CellSelection)) return false;
-
-  if (dispatch) {
-    let tr = state.tr,
-        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 prosemirrorModel.Slice(baseContent, 0, 0));
-    });
-    if (tr.docChanged) dispatch(tr);
-  }
-
-  return true;
-}
-
-function handleTripleClick(view, pos) {
-  let doc = view.state.doc,
-      $cell = cellAround(doc.resolve(pos));
-  if (!$cell) return false;
-  view.dispatch(view.state.tr.setSelection(new CellSelection($cell)));
-  return true;
-}
-function handlePaste(view, _, slice) {
-  if (!isInTable(view.state)) return false;
-  let cells = pastedCells(slice),
-      sel = view.state.selection;
-
-  if (sel instanceof CellSelection) {
-    if (!cells) cells = {
-      width: 1,
-      height: 1,
-      rows: [prosemirrorModel.Fragment.from(fitSlice(tableNodeTypes(view.state.schema).cell, slice))]
-    };
-    let table = sel.$anchorCell.node(-1),
-        start = sel.$anchorCell.start(-1);
-    let rect = TableMap.get(table).rectBetween(sel.$anchorCell.pos - start, sel.$headCell.pos - start);
-    cells = clipCells(cells, rect.right - rect.left, rect.bottom - rect.top);
-    insertCells(view.state, view.dispatch, start, rect, cells);
-    return true;
-  } else if (cells) {
-    let $cell = selectionCell(view.state),
-        start = $cell.start(-1);
-    insertCells(view.state, view.dispatch, start, TableMap.get($cell.node(-1)).findCell($cell.pos - start), cells);
-    return true;
-  } else {
-    return false;
-  }
-}
-function handleMouseDown$1(view, startEvent) {
-  if (startEvent.ctrlKey || startEvent.metaKey) return;
-  let startDOMCell = domInCell(view, startEvent.target),
-      $anchor;
-
-  if (startEvent.shiftKey && view.state.selection instanceof CellSelection) {
-    // Adding to an existing cell selection
-    setCellSelection(view.state.selection.$anchorCell, startEvent);
-    startEvent.preventDefault();
-  } else if (startEvent.shiftKey && startDOMCell && ($anchor = cellAround(view.state.selection.$anchor)) != null && cellUnderMouse(view, startEvent).pos != $anchor.pos) {
-    // Adding to a selection that starts in another cell (causing a
-    // cell selection to be created).
-    setCellSelection($anchor, startEvent);
-    startEvent.preventDefault();
-  } else if (!startDOMCell) {
-    // Not in a cell, let the default behavior happen.
-    return;
-  } // Create and dispatch a cell selection between the given anchor and
-  // the position under the mouse.
-
-
-  function setCellSelection($anchor, event) {
-    let $head = cellUnderMouse(view, event);
-    let starting = key$1.getState(view.state) == null;
-
-    if (!$head || !inSameTable($anchor, $head)) {
-      if (starting) $head = $anchor;else return;
-    }
-
-    let selection = new CellSelection($anchor, $head);
-
-    if (starting || !view.state.selection.eq(selection)) {
-      let tr = view.state.tr.setSelection(selection);
-      if (starting) tr.setMeta(key$1, $anchor.pos);
-      view.dispatch(tr);
-    }
-  } // Stop listening to mouse motion events.
-
-
-  function stop() {
-    view.root.removeEventListener('mouseup', stop);
-    view.root.removeEventListener('dragstart', stop);
-    view.root.removeEventListener('mousemove', move);
-    if (key$1.getState(view.state) != null) view.dispatch(view.state.tr.setMeta(key$1, -1));
-  }
-
-  function move(event) {
-    let anchor = key$1.getState(view.state),
-        $anchor;
-
-    if (anchor != null) {
-      // Continuing an existing cross-cell selection
-      $anchor = view.state.doc.resolve(anchor);
-    } else if (domInCell(view, event.target) != startDOMCell) {
-      // Moving out of the initial cell -- start a new cell selection
-      $anchor = cellUnderMouse(view, startEvent);
-      if (!$anchor) return stop();
-    }
-
-    if ($anchor) setCellSelection($anchor, event);
-  }
-
-  view.root.addEventListener('mouseup', stop);
-  view.root.addEventListener('dragstart', stop);
-  view.root.addEventListener('mousemove', move);
-} // Check whether the cursor is at the end of a cell (so that further
-// motion would move out of the cell)
-
-function atEndOfCell(view, axis, dir) {
-  if (!(view.state.selection instanceof prosemirrorState.TextSelection)) return null;
-  let {
-    $head
-  } = view.state.selection;
-
-  for (let d = $head.depth - 1; d >= 0; d--) {
-    let parent = $head.node(d),
-        index = dir < 0 ? $head.index(d) : $head.indexAfter(d);
-    if (index != (dir < 0 ? 0 : parent.childCount)) return null;
-
-    if (parent.type.spec.tableRole == 'cell' || parent.type.spec.tableRole == 'header_cell') {
-      let cellPos = $head.before(d);
-      let dirStr = axis == 'vert' ? dir > 0 ? 'down' : 'up' : dir > 0 ? 'right' : 'left';
-      return view.endOfTextblock(dirStr) ? cellPos : null;
-    }
-  }
-
-  return null;
-}
-
-function domInCell(view, dom) {
-  for (; dom && dom != view.dom; dom = dom.parentNode) if (dom.nodeName == 'TD' || dom.nodeName == 'TH') return dom;
-}
-
-function cellUnderMouse(view, event) {
-  let mousePos = view.posAtCoords({
-    left: event.clientX,
-    top: event.clientY
-  });
-  if (!mousePos) return null;
-  return mousePos ? cellAround(view.state.doc.resolve(mousePos.pos)) : null;
-}
-
-// This file defines helpers for normalizing tables, making sure no
-const fixTablesKey = new prosemirrorState.PluginKey('fix-tables'); // Helper for iterating through the nodes in a document that changed
-// compared to the given previous document. Useful for avoiding
-// duplicate work on each transaction.
-
-function changedDescendants(old, cur, offset, f) {
-  let oldSize = old.childCount,
-      curSize = cur.childCount;
-
-  outer: for (let i = 0, j = 0; i < curSize; i++) {
-    let child = cur.child(i);
-
-    for (let scan = j, e = Math.min(oldSize, i + 3); scan < e; scan++) {
-      if (old.child(scan) == child) {
-        j = scan + 1;
-        offset += child.nodeSize;
-        continue outer;
-      }
-    }
-
-    f(child, offset);
-    if (j < oldSize && old.child(j).sameMarkup(child)) changedDescendants(old.child(j), child, offset + 1, f);else child.nodesBetween(0, child.content.size, f, offset + 1);
-    offset += child.nodeSize;
-  }
-} // :: (EditorState, ?EditorState) → ?Transaction
-// Inspect all tables in the given state's document and return a
-// transaction that fixes them, if necessary. If `oldState` was
-// provided, that is assumed to hold a previous, known-good state,
-// which will be used to avoid re-scanning unchanged parts of the
-// document.
-
-
-function fixTables(state, oldState) {
-  let tr,
-      check = (node, pos) => {
-    if (node.type.spec.tableRole == 'table') tr = fixTable(state, node, pos, tr);
-  };
-
-  if (!oldState) state.doc.descendants(check);else if (oldState.doc != state.doc) changedDescendants(oldState.doc, state.doc, 0, check);
-  return tr;
-} // : (EditorState, Node, number, ?Transaction) → ?Transaction
-// Fix the given table, if necessary. Will append to the transaction
-// it was given, if non-null, or create a new one if necessary.
-
-function fixTable(state, table, tablePos, tr) {
-  let map = TableMap.get(table);
-  if (!map.problems) return tr;
-  if (!tr) tr = state.tr; // Track which rows we must add cells to, so that we can adjust that
-  // when fixing collisions.
-
-  let mustAdd = [];
-
-  for (let i = 0; i < map.height; i++) mustAdd.push(0);
-
-  for (let i = 0; i < map.problems.length; i++) {
-    let prob = map.problems[i];
-
-    if (prob.type == 'collision') {
-      let cell = table.nodeAt(prob.pos);
-
-      for (let j = 0; j < cell.attrs.rowspan; j++) mustAdd[prob.row + j] += prob.n;
-
-      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), null, removeColSpan(cell.attrs, cell.attrs.colspan - prob.n, prob.n));
-    } else if (prob.type == 'missing') {
-      mustAdd[prob.row] += prob.n;
-    } else if (prob.type == 'overlong_rowspan') {
-      let cell = table.nodeAt(prob.pos);
-      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), null, setAttr(cell.attrs, 'rowspan', cell.attrs.rowspan - prob.n));
-    } else if (prob.type == 'colwidth mismatch') {
-      let cell = table.nodeAt(prob.pos);
-      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), null, setAttr(cell.attrs, 'colwidth', prob.colwidth));
-    }
-  }
-
-  let first, last;
-
-  for (let i = 0; i < mustAdd.length; i++) if (mustAdd[i]) {
-    if (first == null) first = i;
-    last = i;
-  } // Add the necessary cells, using a heuristic for whether to add the
-  // cells at the start or end of the rows (if it looks like a 'bite'
-  // was taken out of the table, add cells at the start of the row
-  // after the bite. Otherwise add them at the end).
-
-
-  for (let i = 0, pos = tablePos + 1; i < map.height; i++) {
-    let row = table.child(i);
-    let end = pos + row.nodeSize;
-    let add = mustAdd[i];
-
-    if (add > 0) {
-      let tableNodeType = 'cell';
-
-      if (row.firstChild) {
-        tableNodeType = row.firstChild.type.spec.tableRole;
-      }
-
-      let nodes = [];
-
-      for (let j = 0; j < add; j++) nodes.push(tableNodeTypes(state.schema)[tableNodeType].createAndFill());
-
-      let side = (i == 0 || first == i - 1) && last == i ? pos + 1 : end - 1;
-      tr.insert(tr.mapping.map(side), nodes);
-    }
-
-    pos = end;
-  }
-
-  return tr.setMeta(fixTablesKey, {
-    fixTables: true
-  });
-}
-
-// This file defines a number of table-related commands.
-// map, table node, and table start offset to the object for
-// convenience.
-
-function selectedRect(state) {
-  let sel = state.selection,
-      $pos = selectionCell(state);
-  let table = $pos.node(-1),
-      tableStart = $pos.start(-1),
-      map = TableMap.get(table);
-  let rect;
-  if (sel instanceof CellSelection) rect = map.rectBetween(sel.$anchorCell.pos - tableStart, sel.$headCell.pos - tableStart);else rect = map.findCell($pos.pos - tableStart);
-  rect.tableStart = tableStart;
-  rect.map = map;
-  rect.table = table;
-  return rect;
-} // Add a column at the given position in a table.
-
-function addColumn(tr, {
-  map,
-  tableStart,
-  table
-}, col) {
-  let refColumn = col > 0 ? -1 : 0;
-  if (columnIsHeader(map, table, col + refColumn)) refColumn = col == 0 || col == map.width ? null : 0;
-
-  for (let row = 0; row < map.height; row++) {
-    let index = row * map.width + col; // If this position falls inside a col-spanning cell
-
-    if (col > 0 && col < map.width && map.map[index - 1] == map.map[index]) {
-      let pos = map.map[index],
-          cell = table.nodeAt(pos);
-      tr.setNodeMarkup(tr.mapping.map(tableStart + pos), null, addColSpan(cell.attrs, col - map.colCount(pos))); // Skip ahead if rowspan > 1
-
-      row += cell.attrs.rowspan - 1;
-    } else {
-      let type = refColumn == null ? tableNodeTypes(table.type.schema).cell : table.nodeAt(map.map[index + refColumn]).type;
-      let pos = map.positionAt(row, col, table);
-      tr.insert(tr.mapping.map(tableStart + pos), type.createAndFill());
-    }
-  }
-
-  return tr;
-} // :: (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Command to add a column before the column with the selection.
-
-function addColumnBefore(state, dispatch) {
-  if (!isInTable(state)) return false;
-
-  if (dispatch) {
-    let rect = selectedRect(state);
-    dispatch(addColumn(state.tr, rect, rect.left));
-  }
-
-  return true;
-} // :: (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Command to add a column after the column with the selection.
-
-function addColumnAfter(state, dispatch) {
-  if (!isInTable(state)) return false;
-
-  if (dispatch) {
-    let rect = selectedRect(state);
-    dispatch(addColumn(state.tr, rect, rect.right));
-  }
-
-  return true;
-}
-function removeColumn(tr, {
-  map,
-  table,
-  tableStart
-}, col) {
-  let mapStart = tr.mapping.maps.length;
-
-  for (let row = 0; row < map.height;) {
-    let index = row * map.width + col,
-        pos = map.map[index],
-        cell = table.nodeAt(pos); // If this is part of a col-spanning cell
-
-    if (col > 0 && map.map[index - 1] == pos || col < map.width - 1 && map.map[index + 1] == pos) {
-      tr.setNodeMarkup(tr.mapping.slice(mapStart).map(tableStart + pos), null, removeColSpan(cell.attrs, col - map.colCount(pos)));
-    } else {
-      let start = tr.mapping.slice(mapStart).map(tableStart + pos);
-      tr.delete(start, start + cell.nodeSize);
-    }
-
-    row += cell.attrs.rowspan;
-  }
-} // :: (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Command function that removes the selected columns from a table.
-
-function deleteColumn(state, dispatch) {
-  if (!isInTable(state)) return false;
-
-  if (dispatch) {
-    let rect = selectedRect(state),
-        tr = state.tr;
-    if (rect.left == 0 && rect.right == rect.map.width) return false;
-
-    for (let i = rect.right - 1;; i--) {
-      removeColumn(tr, rect, i);
-      if (i == rect.left) break;
-      rect.table = rect.tableStart ? tr.doc.nodeAt(rect.tableStart - 1) : tr.doc;
-      rect.map = TableMap.get(rect.table);
-    }
-
-    dispatch(tr);
-  }
-
-  return true;
-}
-function rowIsHeader(map, table, row) {
-  let headerCell = tableNodeTypes(table.type.schema).header_cell;
-
-  for (let col = 0; col < map.width; col++) if (table.nodeAt(map.map[col + row * map.width]).type != headerCell) return false;
-
-  return true;
-}
-function addRow(tr, {
-  map,
-  tableStart,
-  table
-}, row) {
-  let rowPos = tableStart;
-
-  for (let i = 0; i < row; i++) rowPos += table.child(i).nodeSize;
-
-  let cells = [],
-      refRow = row > 0 ? -1 : 0;
-  if (rowIsHeader(map, table, row + refRow)) refRow = row == 0 || row == map.height ? null : 0;
-
-  for (let col = 0, index = map.width * row; col < map.width; col++, index++) {
-    // Covered by a rowspan cell
-    if (row > 0 && row < map.height && map.map[index] == map.map[index - map.width]) {
-      let pos = map.map[index],
-          attrs = table.nodeAt(pos).attrs;
-      tr.setNodeMarkup(tableStart + pos, null, setAttr(attrs, 'rowspan', attrs.rowspan + 1));
-      col += attrs.colspan - 1;
-    } else {
-      let type = refRow == null ? tableNodeTypes(table.type.schema).cell : table.nodeAt(map.map[index + refRow * map.width]).type;
-      cells.push(type.createAndFill());
-    }
-  }
-
-  tr.insert(rowPos, tableNodeTypes(table.type.schema).row.create(null, cells));
-  return tr;
-} // :: (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Add a table row before the selection.
-
-function addRowBefore(state, dispatch) {
-  if (!isInTable(state)) return false;
-
-  if (dispatch) {
-    let rect = selectedRect(state);
-    dispatch(addRow(state.tr, rect, rect.top));
-  }
-
-  return true;
-} // :: (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Add a table row after the selection.
-
-function addRowAfter(state, dispatch) {
-  if (!isInTable(state)) return false;
-
-  if (dispatch) {
-    let rect = selectedRect(state);
-    dispatch(addRow(state.tr, rect, rect.bottom));
-  }
-
-  return true;
-}
-function removeRow(tr, {
-  map,
-  table,
-  tableStart
-}, row) {
-  let rowPos = 0;
-
-  for (let i = 0; i < row; i++) rowPos += table.child(i).nodeSize;
-
-  let nextRow = rowPos + table.child(row).nodeSize;
-  let mapFrom = tr.mapping.maps.length;
-  tr.delete(rowPos + tableStart, nextRow + tableStart);
-
-  for (let col = 0, index = row * map.width; col < map.width; col++, index++) {
-    let pos = map.map[index];
-
-    if (row > 0 && pos == map.map[index - map.width]) {
-      // If this cell starts in the row above, simply reduce its rowspan
-      let attrs = table.nodeAt(pos).attrs;
-      tr.setNodeMarkup(tr.mapping.slice(mapFrom).map(pos + tableStart), null, setAttr(attrs, 'rowspan', attrs.rowspan - 1));
-      col += attrs.colspan - 1;
-    } else if (row < map.width && pos == map.map[index + map.width]) {
-      // Else, if it continues in the row below, it has to be moved down
-      let cell = table.nodeAt(pos);
-      let copy = cell.type.create(setAttr(cell.attrs, 'rowspan', cell.attrs.rowspan - 1), cell.content);
-      let newPos = map.positionAt(row + 1, col, table);
-      tr.insert(tr.mapping.slice(mapFrom).map(tableStart + newPos), copy);
-      col += cell.attrs.colspan - 1;
-    }
-  }
-} // :: (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Remove the selected rows from a table.
-
-function deleteRow(state, dispatch) {
-  if (!isInTable(state)) return false;
-
-  if (dispatch) {
-    let rect = selectedRect(state),
-        tr = state.tr;
-    if (rect.top == 0 && rect.bottom == rect.map.height) return false;
-
-    for (let i = rect.bottom - 1;; i--) {
-      removeRow(tr, rect, i);
-      if (i == rect.top) break;
-      rect.table = rect.tableStart ? tr.doc.nodeAt(rect.tableStart - 1) : tr.doc;
-      rect.map = TableMap.get(rect.table);
-    }
-
-    dispatch(tr);
-  }
-
-  return true;
-}
-
-function isEmpty(cell) {
-  let c = cell.content;
-  return c.childCount == 1 && c.firstChild.isTextblock && c.firstChild.childCount == 0;
-}
-
-function cellsOverlapRectangle({
-  width,
-  height,
-  map
-}, rect) {
-  let indexTop = rect.top * width + rect.left,
-      indexLeft = indexTop;
-  let indexBottom = (rect.bottom - 1) * width + rect.left,
-      indexRight = indexTop + (rect.right - rect.left - 1);
-
-  for (let i = rect.top; i < rect.bottom; i++) {
-    if (rect.left > 0 && map[indexLeft] == map[indexLeft - 1] || rect.right < width && map[indexRight] == map[indexRight + 1]) return true;
-    indexLeft += width;
-    indexRight += width;
-  }
-
-  for (let i = rect.left; i < rect.right; i++) {
-    if (rect.top > 0 && map[indexTop] == map[indexTop - width] || rect.bottom < height && map[indexBottom] == map[indexBottom + width]) return true;
-    indexTop++;
-    indexBottom++;
-  }
-
-  return false;
-} // :: (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Merge the selected cells into a single cell. Only available when
-// the selected cells' outline forms a rectangle.
-
-
-function mergeCells(state, dispatch) {
-  let sel = state.selection;
-  if (!(sel instanceof CellSelection) || sel.$anchorCell.pos == sel.$headCell.pos) return false;
-  let rect = selectedRect(state),
-      {
-    map
-  } = rect;
-  if (cellsOverlapRectangle(map, rect)) return false;
-
-  if (dispatch) {
-    let tr = state.tr,
-        seen = {},
-        content = prosemirrorModel.Fragment.empty,
-        mergedPos,
-        mergedCell;
-
-    for (let row = rect.top; row < rect.bottom; row++) {
-      for (let col = rect.left; col < rect.right; col++) {
-        let cellPos = map.map[row * map.width + col],
-            cell = rect.table.nodeAt(cellPos);
-        if (seen[cellPos]) continue;
-        seen[cellPos] = true;
-
-        if (mergedPos == null) {
-          mergedPos = cellPos;
-          mergedCell = cell;
-        } else {
-          if (!isEmpty(cell)) content = content.append(cell.content);
-          let mapped = tr.mapping.map(cellPos + rect.tableStart);
-          tr.delete(mapped, mapped + cell.nodeSize);
-        }
-      }
-    }
-
-    tr.setNodeMarkup(mergedPos + rect.tableStart, null, setAttr(addColSpan(mergedCell.attrs, mergedCell.attrs.colspan, rect.right - rect.left - mergedCell.attrs.colspan), 'rowspan', rect.bottom - rect.top));
-
-    if (content.size) {
-      let end = mergedPos + 1 + mergedCell.content.size;
-      let start = isEmpty(mergedCell) ? mergedPos + 1 : end;
-      tr.replaceWith(start + rect.tableStart, end + rect.tableStart, content);
-    }
-
-    tr.setSelection(new CellSelection(tr.doc.resolve(mergedPos + rect.tableStart)));
-    dispatch(tr);
-  }
-
-  return true;
-} // :: (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Split a selected cell, whose rowpan or colspan is greater than one,
-// into smaller cells. Use the first cell type for the new cells.
-
-function splitCell(state, dispatch) {
-  const nodeTypes = tableNodeTypes(state.schema);
-  return splitCellWithType(({
-    node
-  }) => {
-    return nodeTypes[node.type.spec.tableRole];
-  })(state, dispatch);
-} // :: (getCellType: ({ row: number, col: number, node: Node}) → NodeType) → (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Split a selected cell, whose rowpan or colspan is greater than one,
-// into smaller cells with the cell type (th, td) returned by getType function.
-
-function splitCellWithType(getCellType) {
-  return (state, dispatch) => {
-    let sel = state.selection;
-    let cellNode, cellPos;
-
-    if (!(sel instanceof CellSelection)) {
-      cellNode = cellWrapping(sel.$from);
-      if (!cellNode) return false;
-      cellPos = cellAround(sel.$from).pos;
-    } else {
-      if (sel.$anchorCell.pos != sel.$headCell.pos) return false;
-      cellNode = sel.$anchorCell.nodeAfter;
-      cellPos = sel.$anchorCell.pos;
-    }
-
-    if (cellNode.attrs.colspan == 1 && cellNode.attrs.rowspan == 1) {
-      return false;
-    }
-
-    if (dispatch) {
-      let baseAttrs = cellNode.attrs,
-          attrs = [],
-          colwidth = baseAttrs.colwidth;
-      if (baseAttrs.rowspan > 1) baseAttrs = setAttr(baseAttrs, 'rowspan', 1);
-      if (baseAttrs.colspan > 1) baseAttrs = setAttr(baseAttrs, 'colspan', 1);
-      let rect = selectedRect(state),
-          tr = state.tr;
-
-      for (let i = 0; i < rect.right - rect.left; i++) attrs.push(colwidth ? setAttr(baseAttrs, 'colwidth', colwidth && colwidth[i] ? [colwidth[i]] : null) : baseAttrs);
-
-      let lastCell;
-
-      for (let row = rect.top; row < rect.bottom; row++) {
-        let pos = rect.map.positionAt(row, rect.left, rect.table);
-        if (row == rect.top) pos += cellNode.nodeSize;
-
-        for (let col = rect.left, i = 0; col < rect.right; col++, i++) {
-          if (col == rect.left && row == rect.top) continue;
-          tr.insert(lastCell = tr.mapping.map(pos + rect.tableStart, 1), getCellType({
-            node: cellNode,
-            row,
-            col
-          }).createAndFill(attrs[i]));
-        }
-      }
-
-      tr.setNodeMarkup(cellPos, getCellType({
-        node: cellNode,
-        row: rect.top,
-        col: rect.left
-      }), attrs[0]);
-      if (sel instanceof CellSelection) tr.setSelection(new CellSelection(tr.doc.resolve(sel.$anchorCell.pos), lastCell && tr.doc.resolve(lastCell)));
-      dispatch(tr);
-    }
-
-    return true;
-  };
-} // :: (string, any) → (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Returns a command that sets the given attribute to the given value,
-// and is only available when the currently selected cell doesn't
-// already have that attribute set to that value.
-
-function setCellAttr(name, value) {
-  return function (state, dispatch) {
-    if (!isInTable(state)) return false;
-    let $cell = selectionCell(state);
-    if ($cell.nodeAfter.attrs[name] === value) return false;
-
-    if (dispatch) {
-      let tr = state.tr;
-      if (state.selection instanceof CellSelection) state.selection.forEachCell((node, pos) => {
-        if (node.attrs[name] !== value) tr.setNodeMarkup(pos, null, setAttr(node.attrs, name, value));
-      });else tr.setNodeMarkup($cell.pos, null, setAttr($cell.nodeAfter.attrs, name, value));
-      dispatch(tr);
-    }
-
-    return true;
-  };
-}
-
-function deprecated_toggleHeader(type) {
-  return function (state, dispatch) {
-    if (!isInTable(state)) return false;
-
-    if (dispatch) {
-      let types = tableNodeTypes(state.schema);
-      let rect = selectedRect(state),
-          tr = state.tr;
-      let cells = rect.map.cellsInRect(type == 'column' ? new Rect(rect.left, 0, rect.right, rect.map.height) : type == 'row' ? new Rect(0, rect.top, rect.map.width, rect.bottom) : rect);
-      let nodes = cells.map(pos => rect.table.nodeAt(pos));
-
-      for (let i = 0; i < cells.length; i++ // Remove headers, if any
-      ) 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++ // No headers removed, add instead
-      ) tr.setNodeMarkup(rect.tableStart + cells[i], types.header_cell, nodes[i].attrs);
-      dispatch(tr);
-    }
-
-    return true;
-  };
-}
-
-function isHeaderEnabledByType(type, rect, types) {
-  // Get cell positions for first row or first column
-  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;
-} // :: (string, ?{ useDeprecatedLogic: bool }) → (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Toggles between row/column header and normal cells (Only applies to first row/column).
-// For deprecated behavior pass `useDeprecatedLogic` in options with true.
-
-
-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) {
-      let types = tableNodeTypes(state.schema);
-      let rect = selectedRect(state),
-          tr = state.tr;
-      let isHeaderRowEnabled = isHeaderEnabledByType('row', rect, types);
-      let isHeaderColumnEnabled = isHeaderEnabledByType('column', rect, types);
-      let isHeaderEnabled = type === 'column' ? isHeaderRowEnabled : type === 'row' ? isHeaderColumnEnabled : false;
-      let selectionStartsAt = isHeaderEnabled ? 1 : 0;
-      let cellsRect = type == 'column' ? new Rect(0, selectionStartsAt, 1, rect.map.height) : type == 'row' ? new Rect(selectionStartsAt, 0, rect.map.width, 1) : rect;
-      let 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;
-  };
-} // :: (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Toggles whether the selected row contains header cells.
-
-toggleHeader('row', {
-  useDeprecatedLogic: true
-}); // :: (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Toggles whether the selected column contains header cells.
-
-toggleHeader('column', {
-  useDeprecatedLogic: true
-}); // :: (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Toggles whether the selected cells are header cells.
-
-let toggleHeaderCell = toggleHeader('cell', {
-  useDeprecatedLogic: true
-});
-
-function findNextCell($cell, dir) {
-  if (dir < 0) {
-    let before = $cell.nodeBefore;
-    if (before) return $cell.pos - before.nodeSize;
-
-    for (let row = $cell.index(-1) - 1, rowEnd = $cell.before(); row >= 0; row--) {
-      let rowNode = $cell.node(-1).child(row);
-      if (rowNode.childCount) return rowEnd - 1 - rowNode.lastChild.nodeSize;
-      rowEnd -= rowNode.nodeSize;
-    }
-  } else {
-    if ($cell.index() < $cell.parent.childCount - 1) return $cell.pos + $cell.nodeAfter.nodeSize;
-    let table = $cell.node(-1);
-
-    for (let row = $cell.indexAfter(-1), rowStart = $cell.after(); row < table.childCount; row++) {
-      let rowNode = table.child(row);
-      if (rowNode.childCount) return rowStart + 1;
-      rowStart += rowNode.nodeSize;
-    }
-  }
-} // :: (number) → (EditorState, dispatch: ?(tr: Transaction)) → bool
-// Returns a command for selecting the next (direction=1) or previous
-// (direction=-1) cell in a table.
-
-
-function goToNextCell(direction) {
-  return function (state, dispatch) {
-    if (!isInTable(state)) return false;
-    let cell = findNextCell(selectionCell(state), direction);
-    if (cell == null) return;
-
-    if (dispatch) {
-      let $cell = state.doc.resolve(cell);
-      dispatch(state.tr.setSelection(prosemirrorState.TextSelection.between($cell, moveCellForward($cell))).scrollIntoView());
-    }
-
-    return true;
-  };
-} // :: (EditorState, ?(tr: Transaction)) → bool
-// Deletes the table around the selection, if any.
-
-function deleteTable(state, dispatch) {
-  let $pos = state.selection.$anchor;
-
-  for (let d = $pos.depth; d > 0; d--) {
-    let node = $pos.node(d);
-
-    if (node.type.spec.tableRole == 'table') {
-      if (dispatch) dispatch(state.tr.delete($pos.before(d), $pos.after(d)).scrollIntoView());
-      return true;
-    }
-  }
-
-  return false;
-}
-
-class TableView$1 {
-  constructor(node, cellMinWidth) {
-    this.node = node;
-    this.cellMinWidth = cellMinWidth;
-    this.dom = document.createElement('div');
-    this.dom.className = 'tableWrapper';
-    this.table = this.dom.appendChild(document.createElement('table'));
-    this.colgroup = this.table.appendChild(document.createElement('colgroup'));
-    updateColumns$1(node, this.colgroup, this.table, cellMinWidth);
-    this.contentDOM = this.table.appendChild(document.createElement('tbody'));
-  }
-
-  update(node) {
-    if (node.type != this.node.type) return false;
-    this.node = node;
-    updateColumns$1(node, this.colgroup, this.table, this.cellMinWidth);
-    return true;
-  }
-
-  ignoreMutation(record) {
-    return record.type == 'attributes' && (record.target == this.table || this.colgroup.contains(record.target));
-  }
-
-}
-function updateColumns$1(node, colgroup, table, cellMinWidth, overrideCol, overrideValue) {
-  let totalWidth = 0,
-      fixedWidth = true;
-  let nextDOM = colgroup.firstChild,
-      row = node.firstChild;
-
-  for (let i = 0, col = 0; i < row.childCount; i++) {
-    let {
-      colspan,
-      colwidth
-    } = row.child(i).attrs;
-
-    for (let j = 0; j < colspan; j++, col++) {
-      let hasWidth = overrideCol == col ? overrideValue : colwidth && colwidth[j];
-      let cssWidth = hasWidth ? hasWidth + 'px' : '';
-      totalWidth += hasWidth || cellMinWidth;
-      if (!hasWidth) fixedWidth = false;
-
-      if (!nextDOM) {
-        colgroup.appendChild(document.createElement('col')).style.width = cssWidth;
-      } else {
-        if (nextDOM.style.width != cssWidth) nextDOM.style.width = cssWidth;
-        nextDOM = nextDOM.nextSibling;
-      }
-    }
-  }
-
-  while (nextDOM) {
-    let after = nextDOM.nextSibling;
-    nextDOM.parentNode.removeChild(nextDOM);
-    nextDOM = after;
-  }
-
-  if (fixedWidth) {
-    table.style.width = totalWidth + 'px';
-    table.style.minWidth = '';
-  } else {
-    table.style.width = '';
-    table.style.minWidth = totalWidth + 'px';
-  }
-}
-
-const key = new prosemirrorState.PluginKey('tableColumnResizing');
-function columnResizing({
-  handleWidth = 5,
-  cellMinWidth = 25,
-  View = TableView$1,
-  lastColumnResizable = true
-} = {}) {
-  let plugin = new prosemirrorState.Plugin({
-    key,
-    state: {
-      init(_, state) {
-        this.spec.props.nodeViews[tableNodeTypes(state.schema).table.name] = (node, view) => new View(node, cellMinWidth, view);
-
-        return new ResizeState(-1, false);
-      },
-
-      apply(tr, prev) {
-        return prev.apply(tr);
-      }
-
-    },
-    props: {
-      attributes(state) {
-        let pluginState = key.getState(state);
-        return pluginState.activeHandle > -1 ? {
-          class: 'resize-cursor'
-        } : null;
-      },
-
-      handleDOMEvents: {
-        mousemove(view, event) {
-          handleMouseMove(view, event, handleWidth, cellMinWidth, lastColumnResizable);
-        },
-
-        mouseleave(view) {
-          handleMouseLeave(view);
-        },
-
-        mousedown(view, event) {
-          handleMouseDown(view, event, cellMinWidth);
-        }
-
-      },
-
-      decorations(state) {
-        let pluginState = key.getState(state);
-        if (pluginState.activeHandle > -1) return handleDecorations(state, pluginState.activeHandle);
-      },
-
-      nodeViews: {}
-    }
-  });
-  return plugin;
-}
-
-class ResizeState {
-  constructor(activeHandle, dragging) {
-    this.activeHandle = activeHandle;
-    this.dragging = dragging;
-  }
-
-  apply(tr) {
-    let state = this,
-        action = tr.getMeta(key);
-    if (action && action.setHandle != null) return new ResizeState(action.setHandle, null);
-    if (action && action.setDragging !== undefined) return new ResizeState(state.activeHandle, action.setDragging);
-
-    if (state.activeHandle > -1 && tr.docChanged) {
-      let handle = tr.mapping.map(state.activeHandle, -1);
-      if (!pointsAtCell(tr.doc.resolve(handle))) handle = null;
-      state = new ResizeState(handle, state.dragging);
-    }
-
-    return state;
-  }
-
-}
-
-function handleMouseMove(view, event, handleWidth, cellMinWidth, lastColumnResizable) {
-  let pluginState = key.getState(view.state);
-
-  if (!pluginState.dragging) {
-    let target = domCellAround(event.target),
-        cell = -1;
-
-    if (target) {
-      let {
-        left,
-        right
-      } = target.getBoundingClientRect();
-      if (event.clientX - left <= handleWidth) cell = edgeCell(view, event, 'left');else if (right - event.clientX <= handleWidth) cell = edgeCell(view, event, 'right');
-    }
-
-    if (cell != pluginState.activeHandle) {
-      if (!lastColumnResizable && cell !== -1) {
-        let $cell = view.state.doc.resolve(cell);
-        let table = $cell.node(-1),
-            map = TableMap.get(table),
-            start = $cell.start(-1);
-        let col = map.colCount($cell.pos - start) + $cell.nodeAfter.attrs.colspan - 1;
-
-        if (col == map.width - 1) {
-          return;
-        }
-      }
-
-      updateHandle(view, cell);
-    }
-  }
-}
-
-function handleMouseLeave(view) {
-  let pluginState = key.getState(view.state);
-  if (pluginState.activeHandle > -1 && !pluginState.dragging) updateHandle(view, -1);
-}
-
-function handleMouseDown(view, event, cellMinWidth) {
-  let pluginState = key.getState(view.state);
-  if (pluginState.activeHandle == -1 || pluginState.dragging) return false;
-  let cell = view.state.doc.nodeAt(pluginState.activeHandle);
-  let width = currentColWidth(view, pluginState.activeHandle, cell.attrs);
-  view.dispatch(view.state.tr.setMeta(key, {
-    setDragging: {
-      startX: event.clientX,
-      startWidth: width
-    }
-  }));
-
-  function finish(event) {
-    window.removeEventListener('mouseup', finish);
-    window.removeEventListener('mousemove', move);
-    let pluginState = key.getState(view.state);
-
-    if (pluginState.dragging) {
-      updateColumnWidth(view, pluginState.activeHandle, draggedWidth(pluginState.dragging, event, cellMinWidth));
-      view.dispatch(view.state.tr.setMeta(key, {
-        setDragging: null
-      }));
-    }
-  }
-
-  function move(event) {
-    if (!event.which) return finish(event);
-    let pluginState = key.getState(view.state);
-    let dragged = draggedWidth(pluginState.dragging, event, cellMinWidth);
-    displayColumnWidth(view, pluginState.activeHandle, dragged, cellMinWidth);
-  }
-
-  window.addEventListener('mouseup', finish);
-  window.addEventListener('mousemove', move);
-  event.preventDefault();
-  return true;
-}
-
-function currentColWidth(view, cellPos, {
-  colspan,
-  colwidth
-}) {
-  let width = colwidth && colwidth[colwidth.length - 1];
-  if (width) return width;
-  let dom = view.domAtPos(cellPos);
-  let node = dom.node.childNodes[dom.offset];
-  let domWidth = node.offsetWidth,
-      parts = colspan;
-  if (colwidth) for (let i = 0; i < colspan; i++) if (colwidth[i]) {
-    domWidth -= colwidth[i];
-    parts--;
-  }
-  return domWidth / parts;
-}
-
-function domCellAround(target) {
-  while (target && target.nodeName != 'TD' && target.nodeName != 'TH') target = target.classList.contains('ProseMirror') ? null : target.parentNode;
-
-  return target;
-}
-
-function edgeCell(view, event, side) {
-  let found = view.posAtCoords({
-    left: event.clientX,
-    top: event.clientY
-  });
-  if (!found) return -1;
-  let {
-    pos
-  } = found;
-  let $cell = cellAround(view.state.doc.resolve(pos));
-  if (!$cell) return -1;
-  if (side == 'right') return $cell.pos;
-  let map = TableMap.get($cell.node(-1)),
-      start = $cell.start(-1);
-  let index = map.map.indexOf($cell.pos - start);
-  return index % map.width == 0 ? -1 : start + map.map[index - 1];
-}
-
-function draggedWidth(dragging, event, cellMinWidth) {
-  let offset = event.clientX - dragging.startX;
-  return Math.max(cellMinWidth, dragging.startWidth + offset);
-}
-
-function updateHandle(view, value) {
-  view.dispatch(view.state.tr.setMeta(key, {
-    setHandle: value
-  }));
-}
-
-function updateColumnWidth(view, cell, width) {
-  let $cell = view.state.doc.resolve(cell);
-  let table = $cell.node(-1),
-      map = TableMap.get(table),
-      start = $cell.start(-1);
-  let col = map.colCount($cell.pos - start) + $cell.nodeAfter.attrs.colspan - 1;
-  let tr = view.state.tr;
-
-  for (let row = 0; row < map.height; row++) {
-    let mapIndex = row * map.width + col; // Rowspanning cell that has already been handled
-
-    if (row && map.map[mapIndex] == map.map[mapIndex - map.width]) continue;
-    let pos = map.map[mapIndex],
-        {
-      attrs
-    } = table.nodeAt(pos);
-    let index = attrs.colspan == 1 ? 0 : col - map.colCount(pos);
-    if (attrs.colwidth && attrs.colwidth[index] == width) continue;
-    let colwidth = attrs.colwidth ? attrs.colwidth.slice() : zeroes(attrs.colspan);
-    colwidth[index] = width;
-    tr.setNodeMarkup(start + pos, null, setAttr(attrs, 'colwidth', colwidth));
-  }
-
-  if (tr.docChanged) view.dispatch(tr);
-}
-
-function displayColumnWidth(view, cell, width, cellMinWidth) {
-  let $cell = view.state.doc.resolve(cell);
-  let table = $cell.node(-1),
-      start = $cell.start(-1);
-  let col = TableMap.get(table).colCount($cell.pos - start) + $cell.nodeAfter.attrs.colspan - 1;
-  let dom = view.domAtPos($cell.start(-1)).node;
-
-  while (dom.nodeName != 'TABLE') dom = dom.parentNode;
-
-  updateColumns$1(table, dom.firstChild, dom, cellMinWidth, col, width);
-}
-
-function zeroes(n) {
-  let result = [];
-
-  for (let i = 0; i < n; i++) result.push(0);
-
-  return result;
-}
-
-function handleDecorations(state, cell) {
-  let decorations = [];
-  let $cell = state.doc.resolve(cell);
-  let table = $cell.node(-1),
-      map = TableMap.get(table),
-      start = $cell.start(-1);
-  let col = map.colCount($cell.pos - start) + $cell.nodeAfter.attrs.colspan;
-
-  for (let row = 0; row < map.height; row++) {
-    let index = col + row * map.width - 1; // For positions that are have either a different cell or the end
-    // of the table to their right, and either the top of the table or
-    // a different cell above them, add a decoration
-
-    if ((col == map.width || map.map[index] != map.map[index + 1]) && (row == 0 || map.map[index - 1] != map.map[index - 1 - map.width])) {
-      let cellPos = map.map[index];
-      let pos = start + cellPos + table.nodeAt(cellPos).nodeSize - 1;
-      let dom = document.createElement('div');
-      dom.className = 'column-resize-handle';
-      decorations.push(prosemirrorView.Decoration.widget(pos, dom));
-    }
-  }
-
-  return prosemirrorView.DecorationSet.create(state.doc, decorations);
-}
-
-// This file defines a plugin that handles the drawing of cell
-//
-// Creates a [plugin](http://prosemirror.net/docs/ref/#state.Plugin)
-// that, when added to an editor, enables cell-selection, handles
-// cell-based copy/paste, and makes sure tables stay well-formed (each
-// row has the same width, and cells don't overlap).
-//
-// You should probably put this plugin near the end of your array of
-// plugins, since it handles mouse and arrow key events in tables
-// rather broadly, and other plugins, like the gap cursor or the
-// column-width dragging plugin, might want to get a turn first to
-// perform more specific behavior.
-
-function tableEditing({
-  allowTableNodeSelection = false
-} = {}) {
-  return new prosemirrorState.Plugin({
-    key: key$1,
-    // This piece of state is used to remember when a mouse-drag
-    // cell-selection is happening, so that it can continue even as
-    // transactions (which might move its anchor cell) come in.
-    state: {
-      init() {
-        return null;
-      },
-
-      apply(tr, cur) {
-        let set = tr.getMeta(key$1);
-        if (set != null) return set == -1 ? null : set;
-        if (cur == null || !tr.docChanged) return cur;
-        let {
-          deleted,
-          pos
-        } = tr.mapping.mapResult(cur);
-        return deleted ? null : pos;
-      }
-
-    },
-    props: {
-      decorations: drawCellSelection,
-      handleDOMEvents: {
-        mousedown: handleMouseDown$1
-      },
-
-      createSelectionBetween(view) {
-        if (key$1.getState(view.state) != null) return view.state.selection;
-      },
-
-      handleTripleClick,
-      handleKeyDown,
-      handlePaste
-    },
-
-    appendTransaction(_, oldState, state) {
-      return normalizeSelection(state, fixTables(state, oldState), allowTableNodeSelection);
-    }
-
-  });
-}
 
 function updateColumns(node, colgroup, table, cellMinWidth, overrideCol, overrideValue) {
     let totalWidth = 0;
@@ -4497,7 +115,7 @@ function createTable(schema, rowsCount, colsCount, withHeaderRow, cellContent) {
 }
 
 function isCellSelection(value) {
-    return value instanceof CellSelection;
+    return value instanceof prosemirrorTables.CellSelection;
 }
 
 const deleteTableWhenAllCellsSelected = ({ editor }) => {
@@ -4565,65 +183,65 @@ const Table = core.Node.create({
                 return true;
             },
             addColumnBefore: () => ({ state, dispatch }) => {
-                return addColumnBefore(state, dispatch);
+                return prosemirrorTables.addColumnBefore(state, dispatch);
             },
             addColumnAfter: () => ({ state, dispatch }) => {
-                return addColumnAfter(state, dispatch);
+                return prosemirrorTables.addColumnAfter(state, dispatch);
             },
             deleteColumn: () => ({ state, dispatch }) => {
-                return deleteColumn(state, dispatch);
+                return prosemirrorTables.deleteColumn(state, dispatch);
             },
             addRowBefore: () => ({ state, dispatch }) => {
-                return addRowBefore(state, dispatch);
+                return prosemirrorTables.addRowBefore(state, dispatch);
             },
             addRowAfter: () => ({ state, dispatch }) => {
-                return addRowAfter(state, dispatch);
+                return prosemirrorTables.addRowAfter(state, dispatch);
             },
             deleteRow: () => ({ state, dispatch }) => {
-                return deleteRow(state, dispatch);
+                return prosemirrorTables.deleteRow(state, dispatch);
             },
             deleteTable: () => ({ state, dispatch }) => {
-                return deleteTable(state, dispatch);
+                return prosemirrorTables.deleteTable(state, dispatch);
             },
             mergeCells: () => ({ state, dispatch }) => {
-                return mergeCells(state, dispatch);
+                return prosemirrorTables.mergeCells(state, dispatch);
             },
             splitCell: () => ({ state, dispatch }) => {
-                return splitCell(state, dispatch);
+                return prosemirrorTables.splitCell(state, dispatch);
             },
             toggleHeaderColumn: () => ({ state, dispatch }) => {
-                return toggleHeader('column')(state, dispatch);
+                return prosemirrorTables.toggleHeader('column')(state, dispatch);
             },
             toggleHeaderRow: () => ({ state, dispatch }) => {
-                return toggleHeader('row')(state, dispatch);
+                return prosemirrorTables.toggleHeader('row')(state, dispatch);
             },
             toggleHeaderCell: () => ({ state, dispatch }) => {
-                return toggleHeaderCell(state, dispatch);
+                return prosemirrorTables.toggleHeaderCell(state, dispatch);
             },
             mergeOrSplit: () => ({ state, dispatch }) => {
-                if (mergeCells(state, dispatch)) {
+                if (prosemirrorTables.mergeCells(state, dispatch)) {
                     return true;
                 }
-                return splitCell(state, dispatch);
+                return prosemirrorTables.splitCell(state, dispatch);
             },
             setCellAttribute: (name, value) => ({ state, dispatch }) => {
-                return setCellAttr(name, value)(state, dispatch);
+                return prosemirrorTables.setCellAttr(name, value)(state, dispatch);
             },
             goToNextCell: () => ({ state, dispatch }) => {
-                return goToNextCell(1)(state, dispatch);
+                return prosemirrorTables.goToNextCell(1)(state, dispatch);
             },
             goToPreviousCell: () => ({ state, dispatch }) => {
-                return goToNextCell(-1)(state, dispatch);
+                return prosemirrorTables.goToNextCell(-1)(state, dispatch);
             },
             fixTables: () => ({ state, dispatch }) => {
                 if (dispatch) {
-                    fixTables(state);
+                    prosemirrorTables.fixTables(state);
                 }
                 return true;
             },
             setCellSelection: position => ({ tr, dispatch }) => {
                 if (dispatch) {
-                    const selection = CellSelection.create(tr.doc, position.anchorCell, position.headCell);
+                    const selection = prosemirrorTables.CellSelection.create(tr.doc, position.anchorCell, position.headCell);
                     // @ts-ignore
                     tr.setSelection(selection);
                 }
@@ -4656,7 +274,7 @@ const Table = core.Node.create({
     addProseMirrorPlugins() {
         const isResizable = this.options.resizable && this.editor.isEditable;
         return [
-            ...(isResizable ? [columnResizing({
+            ...(isResizable ? [prosemirrorTables.columnResizing({
                     handleWidth: this.options.handleWidth,
                     cellMinWidth: this.options.cellMinWidth,
                     View: this.options.View,
@@ -4664,7 +282,7 @@ const Table = core.Node.create({
                     // @ts-ignore (incorrect type)
                     lastColumnResizable: this.options.lastColumnResizable,
                 })] : []),
-            tableEditing({
+            prosemirrorTables.tableEditing({
                 allowTableNodeSelection: this.options.allowTableNodeSelection,
             }),
         ];