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

package/dist/tiptap-extension-table.cjs

@@ -3,8 +3,4390 @@
 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;
@@ -115,7 +4497,7 @@ function createTable(schema, rowsCount, colsCount, withHeaderRow, cellContent) {
 }
 
 function isCellSelection(value) {
-    return value instanceof prosemirrorTables.CellSelection;
+    return value instanceof CellSelection;
 }
 
 const deleteTableWhenAllCellsSelected = ({ editor }) => {
@@ -183,65 +4565,65 @@ const Table = core.Node.create({
                 return true;
             },
             addColumnBefore: () => ({ state, dispatch }) => {
-                return prosemirrorTables.addColumnBefore(state, dispatch);
+                return addColumnBefore(state, dispatch);
             },
             addColumnAfter: () => ({ state, dispatch }) => {
-                return prosemirrorTables.addColumnAfter(state, dispatch);
+                return addColumnAfter(state, dispatch);
             },
             deleteColumn: () => ({ state, dispatch }) => {
-                return prosemirrorTables.deleteColumn(state, dispatch);
+                return deleteColumn(state, dispatch);
             },
             addRowBefore: () => ({ state, dispatch }) => {
-                return prosemirrorTables.addRowBefore(state, dispatch);
+                return addRowBefore(state, dispatch);
             },
             addRowAfter: () => ({ state, dispatch }) => {
-                return prosemirrorTables.addRowAfter(state, dispatch);
+                return addRowAfter(state, dispatch);
             },
             deleteRow: () => ({ state, dispatch }) => {
-                return prosemirrorTables.deleteRow(state, dispatch);
+                return deleteRow(state, dispatch);
             },
             deleteTable: () => ({ state, dispatch }) => {
-                return prosemirrorTables.deleteTable(state, dispatch);
+                return deleteTable(state, dispatch);
             },
             mergeCells: () => ({ state, dispatch }) => {
-                return prosemirrorTables.mergeCells(state, dispatch);
+                return mergeCells(state, dispatch);
             },
             splitCell: () => ({ state, dispatch }) => {
-                return prosemirrorTables.splitCell(state, dispatch);
+                return splitCell(state, dispatch);
             },
             toggleHeaderColumn: () => ({ state, dispatch }) => {
-                return prosemirrorTables.toggleHeader('column')(state, dispatch);
+                return toggleHeader('column')(state, dispatch);
             },
             toggleHeaderRow: () => ({ state, dispatch }) => {
-                return prosemirrorTables.toggleHeader('row')(state, dispatch);
+                return toggleHeader('row')(state, dispatch);
             },
             toggleHeaderCell: () => ({ state, dispatch }) => {
-                return prosemirrorTables.toggleHeaderCell(state, dispatch);
+                return toggleHeaderCell(state, dispatch);
             },
             mergeOrSplit: () => ({ state, dispatch }) => {
-                if (prosemirrorTables.mergeCells(state, dispatch)) {
+                if (mergeCells(state, dispatch)) {
                     return true;
                 }
-                return prosemirrorTables.splitCell(state, dispatch);
+                return splitCell(state, dispatch);
             },
             setCellAttribute: (name, value) => ({ state, dispatch }) => {
-                return prosemirrorTables.setCellAttr(name, value)(state, dispatch);
+                return setCellAttr(name, value)(state, dispatch);
             },
             goToNextCell: () => ({ state, dispatch }) => {
-                return prosemirrorTables.goToNextCell(1)(state, dispatch);
+                return goToNextCell(1)(state, dispatch);
             },
             goToPreviousCell: () => ({ state, dispatch }) => {
-                return prosemirrorTables.goToNextCell(-1)(state, dispatch);
+                return goToNextCell(-1)(state, dispatch);
             },
             fixTables: () => ({ state, dispatch }) => {
                 if (dispatch) {
-                    prosemirrorTables.fixTables(state);
+                    fixTables(state);
                 }
                 return true;
             },
             setCellSelection: position => ({ tr, dispatch }) => {
                 if (dispatch) {
-                    const selection = prosemirrorTables.CellSelection.create(tr.doc, position.anchorCell, position.headCell);
+                    const selection = CellSelection.create(tr.doc, position.anchorCell, position.headCell);
                     // @ts-ignore
                     tr.setSelection(selection);
                 }
@@ -274,7 +4656,7 @@ const Table = core.Node.create({
     addProseMirrorPlugins() {
         const isResizable = this.options.resizable && this.editor.isEditable;
         return [
-            ...(isResizable ? [prosemirrorTables.columnResizing({
+            ...(isResizable ? [columnResizing({
                     handleWidth: this.options.handleWidth,
                     cellMinWidth: this.options.cellMinWidth,
                     View: this.options.View,
@@ -282,7 +4664,7 @@ const Table = core.Node.create({
                     // @ts-ignore (incorrect type)
                     lastColumnResizable: this.options.lastColumnResizable,
                 })] : []),
-            prosemirrorTables.tableEditing({
+            tableEditing({
                 allowTableNodeSelection: this.options.allowTableNodeSelection,
             }),
         ];