@bigbinary/neeto-editor 1.41.1 → 1.42.0-beta1

package/dist/cjs/{chunk-c2f54026.cjs.js → chunk-eee94a18.cjs.js}

@@ -7,7 +7,7 @@ var React = require('react');
 var ramda = require('ramda');
 var injectCss = require('./chunk-da9ee471.cjs.js');
 var i18n = require('i18next');
-var utils = require('./chunk-42becde2.cjs.js');
+var utils = require('./chunk-b18ba907.cjs.js');
 var tippy = require('tippy.js');
 var ReactDOM = require('react-dom');
 var classnames = require('classnames');
@@ -6060,17 +6060,17 @@ function keydownHandler(bindings) {
 // 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;
+const lower16$1 = 0xffff;
+const factor16$1 = Math.pow(2, 16);
+function makeRecover$1(index, offset) { return index + offset * factor16$1; }
+function recoverIndex$1(value) { return value & lower16$1; }
+function recoverOffset$1(value) { return (value - (value & lower16$1)) / factor16$1; }
+const DEL_BEFORE$1 = 1, DEL_AFTER$1 = 2, DEL_ACROSS$1 = 4, DEL_SIDE$1 = 8;
 /**
 An object representing a mapped position with extra
 information.
 */
-class MapResult {
+class MapResult$1 {
     /**
     @internal
     */
@@ -6096,21 +6096,21 @@ class MapResult {
     step removed the token on the side queried (via the `assoc`)
     argument from the document.
     */
-    get deleted() { return (this.delInfo & DEL_SIDE) > 0; }
+    get deleted() { return (this.delInfo & DEL_SIDE$1) > 0; }
     /**
     Tells you whether the token before the mapped position was deleted.
     */
-    get deletedBefore() { return (this.delInfo & (DEL_BEFORE | DEL_ACROSS)) > 0; }
+    get deletedBefore() { return (this.delInfo & (DEL_BEFORE$1 | DEL_ACROSS$1)) > 0; }
     /**
     True when the token after the mapped position was deleted.
     */
-    get deletedAfter() { return (this.delInfo & (DEL_AFTER | DEL_ACROSS)) > 0; }
+    get deletedAfter() { return (this.delInfo & (DEL_AFTER$1 | DEL_ACROSS$1)) > 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; }
+    get deletedAcross() { return (this.delInfo & DEL_ACROSS$1) > 0; }
 }
 /**
 A map describing the deletions and insertions made by a step, which
@@ -6118,7 +6118,7 @@ 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 {
+class StepMap$1 {
     /**
     Create a position map. The modifications to the document are
     represented as an array of numbers, in which each group of three
@@ -6135,18 +6135,18 @@ class StepMap {
     inverted = false) {
         this.ranges = ranges;
         this.inverted = inverted;
-        if (!ranges.length && StepMap.empty)
-            return StepMap.empty;
+        if (!ranges.length && StepMap$1.empty)
+            return StepMap$1.empty;
     }
     /**
     @internal
     */
     recover(value) {
-        let diff = 0, index = recoverIndex(value);
+        let diff = 0, index = recoverIndex$1(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);
+        return this.ranges[index * 3] + diff + recoverOffset$1(value);
     }
     mapResult(pos, assoc = 1) { return this._map(pos, assoc, false); }
     map(pos, assoc = 1) { return this._map(pos, assoc, true); }
@@ -6165,21 +6165,21 @@ class StepMap {
                 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;
+                let recover = pos == (assoc < 0 ? start : end) ? null : makeRecover$1(i / 3, pos - start);
+                let del = pos == start ? DEL_AFTER$1 : pos == end ? DEL_BEFORE$1 : DEL_ACROSS$1;
                 if (assoc < 0 ? pos != start : pos != end)
-                    del |= DEL_SIDE;
-                return new MapResult(result, del, recover);
+                    del |= DEL_SIDE$1;
+                return new MapResult$1(result, del, recover);
             }
             diff += newSize - oldSize;
         }
-        return simple ? pos + diff : new MapResult(pos + diff, 0, null);
+        return simple ? pos + diff : new MapResult$1(pos + diff, 0, null);
     }
     /**
     @internal
     */
     touches(pos, recover) {
-        let diff = 0, index = recoverIndex(recover);
+        let diff = 0, index = recoverIndex$1(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);
@@ -6210,7 +6210,7 @@ class StepMap {
     map positions in the post-step document to the pre-step document.
     */
     invert() {
-        return new StepMap(this.ranges, !this.inverted);
+        return new StepMap$1(this.ranges, !this.inverted);
     }
     /**
     @internal
@@ -6224,13 +6224,13 @@ class StepMap {
     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]);
+        return n == 0 ? StepMap$1.empty : new StepMap$1(n < 0 ? [0, -n, 0] : [0, 0, n]);
     }
 }
 /**
 A StepMap that contains no changed ranges.
 */
-StepMap.empty = new StepMap([]);
+StepMap$1.empty = new StepMap$1([]);
 /**
 A mapping represents a pipeline of zero or more [step
 maps](https://prosemirror.net/docs/ref/#transform.StepMap). It has special provisions for losslessly
@@ -6367,11 +6367,11 @@ class Mapping {
             delInfo |= result.delInfo;
             pos = result.pos;
         }
-        return simple ? pos : new MapResult(pos, delInfo, null);
+        return simple ? pos : new MapResult$1(pos, delInfo, null);
     }
 }
 
-const stepsByID = Object.create(null);
+const stepsByID$1 = Object.create(null);
 /**
 A step object represents an atomic change. It generally applies
 only to the document it was created for, since the positions
@@ -6383,13 +6383,13 @@ methods, and registering your class with a unique
 JSON-serialization identifier using
 [`Step.jsonID`](https://prosemirror.net/docs/ref/#transform.Step^jsonID).
 */
-class Step {
+class Step$1 {
     /**
     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; }
+    getMap() { return StepMap$1.empty; }
     /**
     Try to merge this step with another one, to be applied directly
     after it. Returns the merged step when possible, null if the
@@ -6403,7 +6403,7 @@ class Step {
     static fromJSON(schema, json) {
         if (!json || !json.stepType)
             throw new RangeError("Invalid input for Step.fromJSON");
-        let type = stepsByID[json.stepType];
+        let type = stepsByID$1[json.stepType];
         if (!type)
             throw new RangeError(`No step type ${json.stepType} defined`);
         return type.fromJSON(schema, json);
@@ -6415,9 +6415,9 @@ class Step {
     that's unlikely to clash with steps from other modules.
     */
     static jsonID(id, stepClass) {
-        if (id in stepsByID)
+        if (id in stepsByID$1)
             throw new RangeError("Duplicate use of step JSON ID " + id);
-        stepsByID[id] = stepClass;
+        stepsByID$1[id] = stepClass;
         stepClass.prototype.jsonID = id;
         return stepClass;
     }
@@ -6426,7 +6426,7 @@ class Step {
 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 {
+class StepResult$1 {
     /**
     @internal
     */
@@ -6445,11 +6445,11 @@ class StepResult {
     /**
     Create a successful step result.
     */
-    static ok(doc) { return new StepResult(doc, null); }
+    static ok(doc) { return new StepResult$1(doc, null); }
     /**
     Create a failed step result.
     */
-    static fail(message) { return new StepResult(null, message); }
+    static fail(message) { return new StepResult$1(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
@@ -6457,22 +6457,22 @@ class StepResult {
     */
     static fromReplace(doc, from, to, slice) {
         try {
-            return StepResult.ok(doc.replace(from, to, slice));
+            return StepResult$1.ok(doc.replace(from, to, slice));
         }
         catch (e) {
             if (e instanceof utils.ReplaceError)
-                return StepResult.fail(e.message);
+                return StepResult$1.fail(e.message);
             throw e;
         }
     }
 }
 
-function mapFragment(fragment, f, parent) {
+function mapFragment$1(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));
+            child = child.copy(mapFragment$1(child.content, f, child));
         if (child.isInline)
             child = f(child, parent, i);
         mapped.push(child);
@@ -6482,7 +6482,7 @@ function mapFragment(fragment, f, parent) {
 /**
 Add a mark to all inline content between two positions.
 */
-class AddMarkStep extends Step {
+class AddMarkStep$1 extends Step$1 {
     /**
     Create a mark step.
     */
@@ -6507,27 +6507,27 @@ class AddMarkStep extends Step {
     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 utils.Slice(mapFragment(oldSlice.content, (node, parent) => {
+        let slice = new utils.Slice(mapFragment$1(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);
+        return StepResult$1.fromReplace(doc, this.from, this.to, slice);
     }
     invert() {
-        return new RemoveMarkStep(this.from, this.to, this.mark);
+        return new RemoveMarkStep$1(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);
+        return new AddMarkStep$1(from.pos, to.pos, this.mark);
     }
     merge(other) {
-        if (other instanceof AddMarkStep &&
+        if (other instanceof AddMarkStep$1 &&
             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 new AddMarkStep$1(Math.min(this.from, other.from), Math.max(this.to, other.to), this.mark);
         return null;
     }
     toJSON() {
@@ -6540,14 +6540,14 @@ class AddMarkStep extends Step {
     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));
+        return new AddMarkStep$1(json.from, json.to, schema.markFromJSON(json.mark));
     }
 }
-Step.jsonID("addMark", AddMarkStep);
+Step$1.jsonID("addMark", AddMarkStep$1);
 /**
 Remove a mark from all inline content between two positions.
 */
-class RemoveMarkStep extends Step {
+class RemoveMarkStep$1 extends Step$1 {
     /**
     Create a mark-removing step.
     */
@@ -6571,25 +6571,25 @@ class RemoveMarkStep extends Step {
     }
     apply(doc) {
         let oldSlice = doc.slice(this.from, this.to);
-        let slice = new utils.Slice(mapFragment(oldSlice.content, node => {
+        let slice = new utils.Slice(mapFragment$1(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);
+        return StepResult$1.fromReplace(doc, this.from, this.to, slice);
     }
     invert() {
-        return new AddMarkStep(this.from, this.to, this.mark);
+        return new AddMarkStep$1(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);
+        return new RemoveMarkStep$1(from.pos, to.pos, this.mark);
     }
     merge(other) {
-        if (other instanceof RemoveMarkStep &&
+        if (other instanceof RemoveMarkStep$1 &&
             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 new RemoveMarkStep$1(Math.min(this.from, other.from), Math.max(this.to, other.to), this.mark);
         return null;
     }
     toJSON() {
@@ -6602,14 +6602,14 @@ class RemoveMarkStep extends Step {
     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));
+        return new RemoveMarkStep$1(json.from, json.to, schema.markFromJSON(json.mark));
     }
 }
-Step.jsonID("removeMark", RemoveMarkStep);
+Step$1.jsonID("removeMark", RemoveMarkStep$1);
 /**
 Add a mark to a specific node.
 */
-class AddNodeMarkStep extends Step {
+class AddNodeMarkStep$1 extends Step$1 {
     /**
     Create a node mark step.
     */
@@ -6629,9 +6629,9 @@ class AddNodeMarkStep extends Step {
     apply(doc) {
         let node = doc.nodeAt(this.pos);
         if (!node)
-            return StepResult.fail("No node at mark step's position");
+            return StepResult$1.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 utils.Slice(utils.Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
+        return StepResult$1.fromReplace(doc, this.pos, this.pos + 1, new utils.Slice(utils.Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
     }
     invert(doc) {
         let node = doc.nodeAt(this.pos);
@@ -6640,15 +6640,15 @@ class AddNodeMarkStep extends Step {
             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 AddNodeMarkStep$1(this.pos, node.marks[i]);
+                return new AddNodeMarkStep$1(this.pos, this.mark);
             }
         }
-        return new RemoveNodeMarkStep(this.pos, this.mark);
+        return new RemoveNodeMarkStep$1(this.pos, this.mark);
     }
     map(mapping) {
         let pos = mapping.mapResult(this.pos, 1);
-        return pos.deletedAfter ? null : new AddNodeMarkStep(pos.pos, this.mark);
+        return pos.deletedAfter ? null : new AddNodeMarkStep$1(pos.pos, this.mark);
     }
     toJSON() {
         return { stepType: "addNodeMark", pos: this.pos, mark: this.mark.toJSON() };
@@ -6659,14 +6659,14 @@ class AddNodeMarkStep extends Step {
     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));
+        return new AddNodeMarkStep$1(json.pos, schema.markFromJSON(json.mark));
     }
 }
-Step.jsonID("addNodeMark", AddNodeMarkStep);
+Step$1.jsonID("addNodeMark", AddNodeMarkStep$1);
 /**
 Remove a mark from a specific node.
 */
-class RemoveNodeMarkStep extends Step {
+class RemoveNodeMarkStep$1 extends Step$1 {
     /**
     Create a mark-removing step.
     */
@@ -6686,19 +6686,19 @@ class RemoveNodeMarkStep extends Step {
     apply(doc) {
         let node = doc.nodeAt(this.pos);
         if (!node)
-            return StepResult.fail("No node at mark step's position");
+            return StepResult$1.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 utils.Slice(utils.Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
+        return StepResult$1.fromReplace(doc, this.pos, this.pos + 1, new utils.Slice(utils.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);
+        return new AddNodeMarkStep$1(this.pos, this.mark);
     }
     map(mapping) {
         let pos = mapping.mapResult(this.pos, 1);
-        return pos.deletedAfter ? null : new RemoveNodeMarkStep(pos.pos, this.mark);
+        return pos.deletedAfter ? null : new RemoveNodeMarkStep$1(pos.pos, this.mark);
     }
     toJSON() {
         return { stepType: "removeNodeMark", pos: this.pos, mark: this.mark.toJSON() };
@@ -6709,15 +6709,15 @@ class RemoveNodeMarkStep extends Step {
     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));
+        return new RemoveNodeMarkStep$1(json.pos, schema.markFromJSON(json.mark));
     }
 }
-Step.jsonID("removeNodeMark", RemoveNodeMarkStep);
+Step$1.jsonID("removeNodeMark", RemoveNodeMarkStep$1);
 
 /**
 Replace a part of the document with a slice of new content.
 */
-class ReplaceStep extends Step {
+class ReplaceStep$1 extends Step$1 {
     /**
     The given `slice` should fit the 'gap' between `from` and
     `to`—the depths must line up, and the surrounding nodes must be
@@ -6751,34 +6751,34 @@ class ReplaceStep extends Step {
         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);
+        if (this.structure && contentBetween$1(doc, this.from, this.to))
+            return StepResult$1.fail("Structure replace would overwrite content");
+        return StepResult$1.fromReplace(doc, this.from, this.to, this.slice);
     }
     getMap() {
-        return new StepMap([this.from, this.to - this.from, this.slice.size]);
+        return new StepMap$1([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));
+        return new ReplaceStep$1(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);
+        return new ReplaceStep$1(from.pos, Math.max(from.pos, to.pos), this.slice);
     }
     merge(other) {
-        if (!(other instanceof ReplaceStep) || other.structure || this.structure)
+        if (!(other instanceof ReplaceStep$1) || 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 ? utils.Slice.empty
                 : new utils.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);
+            return new ReplaceStep$1(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 ? utils.Slice.empty
                 : new utils.Slice(other.slice.content.append(this.slice.content), other.slice.openStart, this.slice.openEnd);
-            return new ReplaceStep(other.from, this.to, slice, this.structure);
+            return new ReplaceStep$1(other.from, this.to, slice, this.structure);
         }
         else {
             return null;
@@ -6798,16 +6798,16 @@ class ReplaceStep extends Step {
     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, utils.Slice.fromJSON(schema, json.slice), !!json.structure);
+        return new ReplaceStep$1(json.from, json.to, utils.Slice.fromJSON(schema, json.slice), !!json.structure);
     }
 }
-Step.jsonID("replace", ReplaceStep);
+Step$1.jsonID("replace", ReplaceStep$1);
 /**
 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 {
+class ReplaceAroundStep$1 extends Step$1 {
     /**
     Create a replace-around step with the given range and gap.
     `insert` should be the point in the slice into which the content
@@ -6854,24 +6854,24 @@ class ReplaceAroundStep extends Step {
         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");
+        if (this.structure && (contentBetween$1(doc, this.from, this.gapFrom) ||
+            contentBetween$1(doc, this.gapTo, this.to)))
+            return StepResult$1.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");
+            return StepResult$1.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);
+            return StepResult$1.fail("Content does not fit in gap");
+        return StepResult$1.fromReplace(doc, this.from, this.to, inserted);
     }
     getMap() {
-        return new StepMap([this.from, this.gapFrom - this.from, this.insert,
+        return new StepMap$1([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);
+        return new ReplaceAroundStep$1(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);
@@ -6879,7 +6879,7 @@ class ReplaceAroundStep extends Step {
         let gapTo = this.to == this.gapTo ? to.pos : mapping.map(this.gapTo, 1);
         if ((from.deletedAcross && to.deletedAcross) || gapFrom < from.pos || gapTo > to.pos)
             return null;
-        return new ReplaceAroundStep(from.pos, to.pos, gapFrom, gapTo, this.slice, this.insert, this.structure);
+        return new ReplaceAroundStep$1(from.pos, to.pos, gapFrom, gapTo, this.slice, this.insert, this.structure);
     }
     toJSON() {
         let json = { stepType: "replaceAround", from: this.from, to: this.to,
@@ -6897,11 +6897,11 @@ class ReplaceAroundStep extends Step {
         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, utils.Slice.fromJSON(schema, json.slice), json.insert, !!json.structure);
+        return new ReplaceAroundStep$1(json.from, json.to, json.gapFrom, json.gapTo, utils.Slice.fromJSON(schema, json.slice), json.insert, !!json.structure);
     }
 }
-Step.jsonID("replaceAround", ReplaceAroundStep);
-function contentBetween(doc, from, to) {
+Step$1.jsonID("replaceAround", ReplaceAroundStep$1);
+function contentBetween$1(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--;
@@ -6934,13 +6934,13 @@ function addMark(tr, from, to, mark) {
                     if (removing && removing.to == start && removing.mark.eq(marks[i]))
                         removing.to = end;
                     else
-                        removed.push(removing = new RemoveMarkStep(start, end, marks[i]));
+                        removed.push(removing = new RemoveMarkStep$1(start, end, marks[i]));
                 }
             }
             if (adding && adding.to == start)
                 adding.to = end;
             else
-                added.push(adding = new AddMarkStep(start, end, mark));
+                added.push(adding = new AddMarkStep$1(start, end, mark));
         }
     });
     removed.forEach(s => tr.step(s));
@@ -6986,7 +6986,7 @@ function removeMark(tr, from, to, mark) {
             }
         }
     });
-    matched.forEach(m => tr.step(new RemoveMarkStep(m.from, m.to, m.style)));
+    matched.forEach(m => tr.step(new RemoveMarkStep$1(m.from, m.to, m.style)));
 }
 function clearIncompatible(tr, pos, parentType, match = parentType.contentMatch, clearNewlines = true) {
     let node = tr.doc.nodeAt(pos);
@@ -6995,19 +6995,19 @@ function clearIncompatible(tr, pos, parentType, match = parentType.contentMatch,
         let child = node.child(i), end = cur + child.nodeSize;
         let allowed = match.matchType(child.type);
         if (!allowed) {
-            replSteps.push(new ReplaceStep(cur, end, utils.Slice.empty));
+            replSteps.push(new ReplaceStep$1(cur, end, utils.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]));
+                    tr.step(new RemoveMarkStep$1(cur, end, child.marks[j]));
             if (clearNewlines && child.isText && parentType.whitespace != "pre") {
                 let m, newline = /\r?\n|\r/g, slice;
                 while (m = newline.exec(child.text)) {
                     if (!slice)
                         slice = new utils.Slice(utils.Fragment.from(parentType.schema.text(" ", parentType.allowedMarks(child.marks))), 0, 0);
-                    replSteps.push(new ReplaceStep(cur + m.index, cur + m.index + m[0].length, slice));
+                    replSteps.push(new ReplaceStep$1(cur + m.index, cur + m.index + m[0].length, slice));
                 }
             }
         }
@@ -7021,7 +7021,7 @@ function clearIncompatible(tr, pos, parentType, match = parentType.contentMatch,
         tr.step(replSteps[i]);
 }
 
-function canCut(node, start, end) {
+function canCut$1(node, start, end) {
     return (start == 0 || node.canReplace(start, node.childCount)) &&
         (end == node.childCount || node.canReplace(0, end));
 }
@@ -7030,7 +7030,7 @@ Try to find a target depth to which the content in the given range
 can be lifted. Will not go across
 [isolating](https://prosemirror.net/docs/ref/#model.NodeSpec.isolating) parent nodes.
 */
-function liftTarget(range) {
+function liftTarget$1(range) {
     let parent = range.parent;
     let content = parent.content.cutByIndex(range.startIndex, range.endIndex);
     for (let depth = range.depth;; --depth) {
@@ -7038,7 +7038,7 @@ function liftTarget(range) {
         let index = range.$from.index(depth), endIndex = range.$to.indexAfter(depth);
         if (depth < range.depth && node.canReplace(index, endIndex, content))
             return depth;
-        if (depth == 0 || node.type.spec.isolating || !canCut(node, index, endIndex))
+        if (depth == 0 || node.type.spec.isolating || !canCut$1(node, index, endIndex))
             break;
     }
     return null;
@@ -7067,7 +7067,7 @@ function lift$2(tr, range, target) {
         else {
             end++;
         }
-    tr.step(new ReplaceAroundStep(start, end, gapStart, gapEnd, new utils.Slice(before.append(after), openStart, openEnd), before.size - openStart, true));
+    tr.step(new ReplaceAroundStep$1(start, end, gapStart, gapEnd, new utils.Slice(before.append(after), openStart, openEnd), before.size - openStart, true));
 }
 /**
 Try to find a valid way to wrap the content in the given range in a
@@ -7077,16 +7077,16 @@ could be found. When `innerRange` is given, that range's content is
 used as the content to fit into the wrapping, instead of the
 content of `range`.
 */
-function findWrapping(range, nodeType, attrs = null, innerRange = range) {
-    let around = findWrappingOutside(range, nodeType);
-    let inner = around && findWrappingInside(innerRange, nodeType);
+function findWrapping$1(range, nodeType, attrs = null, innerRange = range) {
+    let around = findWrappingOutside$1(range, nodeType);
+    let inner = around && findWrappingInside$1(innerRange, nodeType);
     if (!inner)
         return null;
-    return around.map(withAttrs)
-        .concat({ type: nodeType, attrs }).concat(inner.map(withAttrs));
+    return around.map(withAttrs$1)
+        .concat({ type: nodeType, attrs }).concat(inner.map(withAttrs$1));
 }
-function withAttrs(type) { return { type, attrs: null }; }
-function findWrappingOutside(range, type) {
+function withAttrs$1(type) { return { type, attrs: null }; }
+function findWrappingOutside$1(range, type) {
     let { parent, startIndex, endIndex } = range;
     let around = parent.contentMatchAt(startIndex).findWrapping(type);
     if (!around)
@@ -7094,7 +7094,7 @@ function findWrappingOutside(range, type) {
     let outer = around.length ? around[0] : type;
     return parent.canReplaceWith(startIndex, endIndex, outer) ? around : null;
 }
-function findWrappingInside(range, type) {
+function findWrappingInside$1(range, type) {
     let { parent, startIndex, endIndex } = range;
     let inner = parent.child(startIndex);
     let inside = type.contentMatch.findWrapping(inner.type);
@@ -7119,14 +7119,16 @@ function wrap(tr, range, wrappers) {
         content = utils.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 utils.Slice(content, 0, 0), wrappers.length, true));
+    tr.step(new ReplaceAroundStep$1(start, end, start, end, new utils.Slice(content, 0, 0), wrappers.length, true));
 }
 function setBlockType$1(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)) {
+        let attrsHere = typeof attrs == "function" ? attrs(node) : attrs;
+        if (node.isTextblock && !node.hasMarkup(type, attrsHere) &&
+            canChangeType(tr.doc, tr.mapping.slice(mapFrom).map(pos), type)) {
             let convertNewlines = null;
             if (type.schema.linebreakReplacement) {
                 let pre = type.whitespace == "pre", supportLinebreak = !!type.contentMatch.matchType(type.schema.linebreakReplacement);
@@ -7141,7 +7143,7 @@ function setBlockType$1(tr, from, to, type, attrs) {
             clearIncompatible(tr, tr.mapping.slice(mapFrom).map(pos, 1), type, undefined, convertNewlines === null);
             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 utils.Slice(utils.Fragment.from(type.create(attrs, null, node.marks)), 0, 0), 1, true));
+            tr.step(new ReplaceAroundStep$1(startM, endM, startM + 1, endM - 1, new utils.Slice(utils.Fragment.from(type.create(attrsHere, null, node.marks)), 0, 0), 1, true));
             if (convertNewlines === true)
                 replaceNewlines(tr, node, pos, mapFrom);
             return false;
@@ -7186,12 +7188,12 @@ function setNodeMarkup(tr, pos, type, attrs, marks) {
         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 utils.Slice(utils.Fragment.from(newNode), 0, 0), 1, true));
+    tr.step(new ReplaceAroundStep$1(pos, pos + node.nodeSize, pos + 1, pos + node.nodeSize - 1, new utils.Slice(utils.Fragment.from(newNode), 0, 0), 1, true));
 }
 /**
 Check whether splitting at the given position is allowed.
 */
-function canSplit(doc, pos, depth = 1, typesAfter) {
+function canSplit$1(doc, pos, depth = 1, typesAfter) {
     let $pos = doc.resolve(pos), base = $pos.depth - depth;
     let innerType = (typesAfter && typesAfter[typesAfter.length - 1]) || $pos.parent;
     if (base < 0 || $pos.parent.type.spec.isolating ||
@@ -7221,18 +7223,18 @@ function split(tr, pos, depth = 1, typesAfter) {
         let typeAfter = typesAfter && typesAfter[i];
         after = utils.Fragment.from(typeAfter ? typeAfter.type.create(typeAfter.attrs, after) : $pos.node(d).copy(after));
     }
-    tr.step(new ReplaceStep(pos, pos, new utils.Slice(before.append(after), depth, depth), true));
+    tr.step(new ReplaceStep$1(pos, pos, new utils.Slice(before.append(after), depth, depth), true));
 }
 /**
 Test whether the blocks before and after a given position can be
 joined.
 */
-function canJoin(doc, pos) {
+function canJoin$1(doc, pos) {
     let $pos = doc.resolve(pos), index = $pos.index();
-    return joinable($pos.nodeBefore, $pos.nodeAfter) &&
+    return joinable$1($pos.nodeBefore, $pos.nodeAfter) &&
         $pos.parent.canReplace(index, index + 1);
 }
-function joinable(a, b) {
+function joinable$1(a, b) {
     return !!(a && b && !a.isLeaf && a.canAppend(b));
 }
 /**
@@ -7257,7 +7259,7 @@ function joinPoint(doc, pos, dir = -1) {
             before = $pos.node(d).maybeChild(index - 1);
             after = $pos.node(d + 1);
         }
-        if (before && !before.isTextblock && joinable(before, after) &&
+        if (before && !before.isTextblock && joinable$1(before, after) &&
             $pos.node(d).canReplace(index, index + 1))
             return pos;
         if (d == 0)
@@ -7266,7 +7268,7 @@ function joinPoint(doc, pos, dir = -1) {
     }
 }
 function join(tr, pos, depth) {
-    let step = new ReplaceStep(pos - depth, pos + depth, utils.Slice.empty, true);
+    let step = new ReplaceStep$1(pos - depth, pos + depth, utils.Slice.empty, true);
     tr.step(step);
 }
 /**
@@ -7310,7 +7312,7 @@ function replaceStep(doc, from, to = from, slice = utils.Slice.empty) {
     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 ReplaceStep$1(from, to, slice);
     return new Fitter($from, $to, slice).fit();
 }
 function fitsTrivially($from, $to, slice) {
@@ -7384,9 +7386,9 @@ class Fitter {
         }
         let slice = new utils.Slice(content, openStart, openEnd);
         if (moveInline > -1)
-            return new ReplaceAroundStep($from.pos, moveInline, this.$to.pos, this.$to.end(), slice, placedSize);
+            return new ReplaceAroundStep$1($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 new ReplaceStep$1($from.pos, $to.pos, slice);
         return null;
     }
     // Find a position on the start spine of `this.unplaced` that has
@@ -7617,7 +7619,7 @@ function replaceRange(tr, from, to, slice) {
         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));
+        return tr.step(new ReplaceStep$1(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)
@@ -7747,7 +7749,7 @@ function coveredDepths($from, $to) {
 /**
 Update an attribute in a specific node.
 */
-class AttrStep extends Step {
+class AttrStep$1 extends Step$1 {
     /**
     Construct an attribute step.
     */
@@ -7770,23 +7772,23 @@ class AttrStep extends Step {
     apply(doc) {
         let node = doc.nodeAt(this.pos);
         if (!node)
-            return StepResult.fail("No node at attribute step's position");
+            return StepResult$1.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 utils.Slice(utils.Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
+        return StepResult$1.fromReplace(doc, this.pos, this.pos + 1, new utils.Slice(utils.Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
     }
     getMap() {
-        return StepMap.empty;
+        return StepMap$1.empty;
     }
     invert(doc) {
-        return new AttrStep(this.pos, this.attr, doc.nodeAt(this.pos).attrs[this.attr]);
+        return new AttrStep$1(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);
+        return pos.deletedAfter ? null : new AttrStep$1(pos.pos, this.attr, this.value);
     }
     toJSON() {
         return { stepType: "attr", pos: this.pos, attr: this.attr, value: this.value };
@@ -7794,14 +7796,14 @@ class AttrStep extends Step {
     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);
+        return new AttrStep$1(json.pos, json.attr, json.value);
     }
 }
-Step.jsonID("attr", AttrStep);
+Step$1.jsonID("attr", AttrStep$1);
 /**
 Update an attribute in the doc node.
 */
-class DocAttrStep extends Step {
+class DocAttrStep$1 extends Step$1 {
     /**
     Construct an attribute step.
     */
@@ -7822,13 +7824,13 @@ class DocAttrStep extends Step {
             attrs[name] = doc.attrs[name];
         attrs[this.attr] = this.value;
         let updated = doc.type.create(attrs, doc.content, doc.marks);
-        return StepResult.ok(updated);
+        return StepResult$1.ok(updated);
     }
     getMap() {
-        return StepMap.empty;
+        return StepMap$1.empty;
     }
     invert(doc) {
-        return new DocAttrStep(this.attr, doc.attrs[this.attr]);
+        return new DocAttrStep$1(this.attr, doc.attrs[this.attr]);
     }
     map(mapping) {
         return this;
@@ -7839,24 +7841,24 @@ class DocAttrStep extends Step {
     static fromJSON(schema, json) {
         if (typeof json.attr != "string")
             throw new RangeError("Invalid input for DocAttrStep.fromJSON");
-        return new DocAttrStep(json.attr, json.value);
+        return new DocAttrStep$1(json.attr, json.value);
     }
 }
-Step.jsonID("docAttr", DocAttrStep);
+Step$1.jsonID("docAttr", DocAttrStep$1);
 
 /**
 @internal
 */
-let TransformError = class extends Error {
+let TransformError$1 = class extends Error {
 };
-TransformError = function TransformError(message) {
+TransformError$1 = 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";
+TransformError$1.prototype = Object.create(Error.prototype);
+TransformError$1.prototype.constructor = TransformError$1;
+TransformError$1.prototype.name = "TransformError";
 /**
 Abstraction to build up and track an array of
 [steps](https://prosemirror.net/docs/ref/#transform.Step) representing a document transformation.
@@ -7899,7 +7901,7 @@ class Transform {
     step(step) {
         let result = this.maybeStep(step);
         if (result.failed)
-            throw new TransformError(result.failed);
+            throw new TransformError$1(result.failed);
         return this;
     }
     /**
@@ -8051,21 +8053,21 @@ class Transform {
     to set attributes on the document itself.
     */
     setNodeAttribute(pos, attr, value) {
-        this.step(new AttrStep(pos, attr, value));
+        this.step(new AttrStep$1(pos, attr, value));
         return this;
     }
     /**
     Set a single attribute on the document to a new value.
     */
     setDocAttribute(attr, value) {
-        this.step(new DocAttrStep(attr, value));
+        this.step(new DocAttrStep$1(attr, value));
         return this;
     }
     /**
     Add a mark to the node at position `pos`.
     */
     addNodeMark(pos, mark) {
-        this.step(new AddNodeMarkStep(pos, mark));
+        this.step(new AddNodeMarkStep$1(pos, mark));
         return this;
     }
     /**
@@ -8081,7 +8083,7 @@ class Transform {
             if (!mark)
                 return this;
         }
-        this.step(new RemoveNodeMarkStep(pos, mark));
+        this.step(new RemoveNodeMarkStep$1(pos, mark));
         return this;
     }
     /**
@@ -8166,21 +8168,26 @@ const joinBackward$1 = (state, dispatch, view) => {
     }
     let before = $cut.nodeBefore;
     // Apply the joining algorithm
-    if (!before.type.spec.isolating && deleteBarrier(state, $cut, dispatch))
+    if (deleteBarrier(state, $cut, dispatch, -1))
         return true;
     // If the node below has no content and the node above is
     // selectable, delete the node below and select the one above.
     if ($cursor.parent.content.size == 0 &&
         (textblockAt(before, "end") || utils.NodeSelection.isSelectable(before))) {
-        let delStep = utils.replaceStep(state.doc, $cursor.before(), $cursor.after(), utils.Slice.empty);
-        if (delStep && delStep.slice.size < delStep.to - delStep.from) {
-            if (dispatch) {
-                let tr = state.tr.step(delStep);
-                tr.setSelection(textblockAt(before, "end") ? utils.Selection.findFrom(tr.doc.resolve(tr.mapping.map($cut.pos, -1)), -1)
-                    : utils.NodeSelection.create(tr.doc, $cut.pos - before.nodeSize));
-                dispatch(tr.scrollIntoView());
+        for (let depth = $cursor.depth;; depth--) {
+            let delStep = utils.replaceStep(state.doc, $cursor.before(depth), $cursor.after(depth), utils.Slice.empty);
+            if (delStep && delStep.slice.size < delStep.to - delStep.from) {
+                if (dispatch) {
+                    let tr = state.tr.step(delStep);
+                    tr.setSelection(textblockAt(before, "end")
+                        ? utils.Selection.findFrom(tr.doc.resolve(tr.mapping.map($cut.pos, -1)), -1)
+                        : utils.NodeSelection.create(tr.doc, $cut.pos - before.nodeSize));
+                    dispatch(tr.scrollIntoView());
+                }
+                return true;
             }
-            return true;
+            if (depth == 1 || $cursor.node(depth - 1).childCount > 1)
+                break;
         }
     }
     // If the node before is an atom, delete it
@@ -8312,7 +8319,7 @@ const joinForward$1 = (state, dispatch, view) => {
         return false;
     let after = $cut.nodeAfter;
     // Try the joining algorithm
-    if (deleteBarrier(state, $cut, dispatch))
+    if (deleteBarrier(state, $cut, dispatch, 1))
         return true;
     // If the node above has no content and the node below is
     // selectable, delete the node above and select the one below.
@@ -8544,13 +8551,12 @@ function joinMaybeClear(state, $pos, dispatch) {
             .scrollIntoView());
     return true;
 }
-function deleteBarrier(state, $cut, dispatch) {
+function deleteBarrier(state, $cut, dispatch, dir) {
     let before = $cut.nodeBefore, after = $cut.nodeAfter, conn, match;
-    if (before.type.spec.isolating || after.type.spec.isolating)
-        return false;
-    if (joinMaybeClear(state, $cut, dispatch))
+    let isolated = before.type.spec.isolating || after.type.spec.isolating;
+    if (!isolated && joinMaybeClear(state, $cut, dispatch))
         return true;
-    let canDelAfter = $cut.parent.canReplace($cut.index(), $cut.index() + 1);
+    let canDelAfter = !isolated && $cut.parent.canReplace($cut.index(), $cut.index() + 1);
     if (canDelAfter &&
         (conn = (match = before.contentMatchAt(before.childCount)).findWrapping(after.type)) &&
         match.matchType(conn[0] || after.type).validEnd) {
@@ -8567,7 +8573,7 @@ function deleteBarrier(state, $cut, dispatch) {
         }
         return true;
     }
-    let selAfter = utils.Selection.findFrom($cut, 1);
+    let selAfter = after.type.spec.isolating || (dir > 0 && isolated) ? null : utils.Selection.findFrom($cut, 1);
     let range = selAfter && selAfter.$from.blockRange(selAfter.$to), target = range && utils.liftTarget(range);
     if (target != null && target >= $cut.depth) {
         if (dispatch)
@@ -8678,6 +8684,949 @@ typeof navigator != "undefined" ? /Mac|iP(hone|[oa]d)/.test(navigator.platform)
     // @ts-ignore
     : typeof os != "undefined" && os.platform ? os.platform() == "darwin" : 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([]);
+
+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 utils.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 utils.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 utils.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 utils.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 utils.Slice(utils.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 utils.Slice(utils.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 ? utils.Slice.empty
+                : new utils.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 ? utils.Slice.empty
+                : new utils.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, utils.Slice.fromJSON(schema, json.slice), !!json.structure);
+    }
+}
+Step.jsonID("replace", ReplaceStep);
+/**
+Replace a part of the document with a slice of content, but
+preserve a range of the replaced content by moving it into the
+slice.
+*/
+class ReplaceAroundStep extends Step {
+    /**
+    Create a replace-around step with the given range and gap.
+    `insert` should be the point in the slice into which the content
+    of the gap should be moved. `structure` has the same meaning as
+    it has in the [`ReplaceStep`](https://prosemirror.net/docs/ref/#transform.ReplaceStep) class.
+    */
+    constructor(
+    /**
+    The start position of the replaced range.
+    */
+    from, 
+    /**
+    The end position of the replaced range.
+    */
+    to, 
+    /**
+    The start of preserved range.
+    */
+    gapFrom, 
+    /**
+    The end of preserved range.
+    */
+    gapTo, 
+    /**
+    The slice to insert.
+    */
+    slice, 
+    /**
+    The position in the slice where the preserved range should be
+    inserted.
+    */
+    insert, 
+    /**
+    @internal
+    */
+    structure = false) {
+        super();
+        this.from = from;
+        this.to = to;
+        this.gapFrom = gapFrom;
+        this.gapTo = gapTo;
+        this.slice = slice;
+        this.insert = insert;
+        this.structure = structure;
+    }
+    apply(doc) {
+        if (this.structure && (contentBetween(doc, this.from, this.gapFrom) ||
+            contentBetween(doc, this.gapTo, this.to)))
+            return StepResult.fail("Structure gap-replace would overwrite content");
+        let gap = doc.slice(this.gapFrom, this.gapTo);
+        if (gap.openStart || gap.openEnd)
+            return StepResult.fail("Gap is not a flat range");
+        let inserted = this.slice.insertAt(this.insert, gap.content);
+        if (!inserted)
+            return StepResult.fail("Content does not fit in gap");
+        return StepResult.fromReplace(doc, this.from, this.to, inserted);
+    }
+    getMap() {
+        return new StepMap([this.from, this.gapFrom - this.from, this.insert,
+            this.gapTo, this.to - this.gapTo, this.slice.size - this.insert]);
+    }
+    invert(doc) {
+        let gap = this.gapTo - this.gapFrom;
+        return new ReplaceAroundStep(this.from, this.from + this.slice.size + gap, this.from + this.insert, this.from + this.insert + gap, doc.slice(this.from, this.to).removeBetween(this.gapFrom - this.from, this.gapTo - this.from), this.gapFrom - this.from, this.structure);
+    }
+    map(mapping) {
+        let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
+        let gapFrom = this.from == this.gapFrom ? from.pos : mapping.map(this.gapFrom, -1);
+        let gapTo = this.to == this.gapTo ? to.pos : mapping.map(this.gapTo, 1);
+        if ((from.deletedAcross && to.deletedAcross) || gapFrom < from.pos || gapTo > to.pos)
+            return null;
+        return new ReplaceAroundStep(from.pos, to.pos, gapFrom, gapTo, this.slice, this.insert, this.structure);
+    }
+    toJSON() {
+        let json = { stepType: "replaceAround", from: this.from, to: this.to,
+            gapFrom: this.gapFrom, gapTo: this.gapTo, insert: this.insert };
+        if (this.slice.size)
+            json.slice = this.slice.toJSON();
+        if (this.structure)
+            json.structure = true;
+        return json;
+    }
+    /**
+    @internal
+    */
+    static fromJSON(schema, json) {
+        if (typeof json.from != "number" || typeof json.to != "number" ||
+            typeof json.gapFrom != "number" || typeof json.gapTo != "number" || typeof json.insert != "number")
+            throw new RangeError("Invalid input for ReplaceAroundStep.fromJSON");
+        return new ReplaceAroundStep(json.from, json.to, json.gapFrom, json.gapTo, utils.Slice.fromJSON(schema, json.slice), json.insert, !!json.structure);
+    }
+}
+Step.jsonID("replaceAround", ReplaceAroundStep);
+function contentBetween(doc, from, to) {
+    let $from = doc.resolve(from), dist = to - from, depth = $from.depth;
+    while (dist > 0 && depth > 0 && $from.indexAfter(depth) == $from.node(depth).childCount) {
+        depth--;
+        dist--;
+    }
+    if (dist > 0) {
+        let next = $from.node(depth).maybeChild($from.indexAfter(depth));
+        while (dist > 0) {
+            if (!next || next.isLeaf)
+                return true;
+            next = next.firstChild;
+            dist--;
+        }
+    }
+    return false;
+}
+
+function canCut(node, start, end) {
+    return (start == 0 || node.canReplace(start, node.childCount)) &&
+        (end == node.childCount || node.canReplace(0, end));
+}
+/**
+Try to find a target depth to which the content in the given range
+can be lifted. Will not go across
+[isolating](https://prosemirror.net/docs/ref/#model.NodeSpec.isolating) parent nodes.
+*/
+function liftTarget(range) {
+    let parent = range.parent;
+    let content = parent.content.cutByIndex(range.startIndex, range.endIndex);
+    for (let depth = range.depth;; --depth) {
+        let node = range.$from.node(depth);
+        let index = range.$from.index(depth), endIndex = range.$to.indexAfter(depth);
+        if (depth < range.depth && node.canReplace(index, endIndex, content))
+            return depth;
+        if (depth == 0 || node.type.spec.isolating || !canCut(node, index, endIndex))
+            break;
+    }
+    return null;
+}
+/**
+Try to find a valid way to wrap the content in the given range in a
+node of the given type. May introduce extra nodes around and inside
+the wrapper node, if necessary. Returns null if no valid wrapping
+could be found. When `innerRange` is given, that range's content is
+used as the content to fit into the wrapping, instead of the
+content of `range`.
+*/
+function findWrapping(range, nodeType, attrs = null, innerRange = range) {
+    let around = findWrappingOutside(range, nodeType);
+    let inner = around && findWrappingInside(innerRange, nodeType);
+    if (!inner)
+        return null;
+    return around.map(withAttrs)
+        .concat({ type: nodeType, attrs }).concat(inner.map(withAttrs));
+}
+function withAttrs(type) { return { type, attrs: null }; }
+function findWrappingOutside(range, type) {
+    let { parent, startIndex, endIndex } = range;
+    let around = parent.contentMatchAt(startIndex).findWrapping(type);
+    if (!around)
+        return null;
+    let outer = around.length ? around[0] : type;
+    return parent.canReplaceWith(startIndex, endIndex, outer) ? around : null;
+}
+function findWrappingInside(range, type) {
+    let { parent, startIndex, endIndex } = range;
+    let inner = parent.child(startIndex);
+    let inside = type.contentMatch.findWrapping(inner.type);
+    if (!inside)
+        return null;
+    let lastType = inside.length ? inside[inside.length - 1] : type;
+    let innerMatch = lastType.contentMatch;
+    for (let i = startIndex; innerMatch && i < endIndex; i++)
+        innerMatch = innerMatch.matchType(parent.child(i).type);
+    if (!innerMatch || !innerMatch.validEnd)
+        return null;
+    return inside;
+}
+/**
+Check whether splitting at the given position is allowed.
+*/
+function canSplit(doc, pos, depth = 1, typesAfter) {
+    let $pos = doc.resolve(pos), base = $pos.depth - depth;
+    let innerType = (typesAfter && typesAfter[typesAfter.length - 1]) || $pos.parent;
+    if (base < 0 || $pos.parent.type.spec.isolating ||
+        !$pos.parent.canReplace($pos.index(), $pos.parent.childCount) ||
+        !innerType.type.validContent($pos.parent.content.cutByIndex($pos.index(), $pos.parent.childCount)))
+        return false;
+    for (let d = $pos.depth - 1, i = depth - 2; d > base; d--, i--) {
+        let node = $pos.node(d), index = $pos.index(d);
+        if (node.type.spec.isolating)
+            return false;
+        let rest = node.content.cutByIndex(index, node.childCount);
+        let overrideChild = typesAfter && typesAfter[i + 1];
+        if (overrideChild)
+            rest = rest.replaceChild(0, overrideChild.type.create(overrideChild.attrs));
+        let after = (typesAfter && typesAfter[i]) || node;
+        if (!node.canReplace(index + 1, node.childCount) || !after.type.validContent(rest))
+            return false;
+    }
+    let index = $pos.indexAfter(base);
+    let baseType = typesAfter && typesAfter[0];
+    return $pos.node(base).canReplaceWith(index, index, baseType ? baseType.type : $pos.node(base + 1).type);
+}
+/**
+Test whether the blocks before and after a given position can be
+joined.
+*/
+function canJoin(doc, pos) {
+    let $pos = doc.resolve(pos), index = $pos.index();
+    return joinable($pos.nodeBefore, $pos.nodeAfter) &&
+        $pos.parent.canReplace(index, index + 1);
+}
+function joinable(a, b) {
+    return !!(a && b && !a.isLeaf && a.canAppend(b));
+}
+
+/**
+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 utils.Slice(utils.Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
+    }
+    getMap() {
+        return StepMap.empty;
+    }
+    invert(doc) {
+        return new AttrStep(this.pos, this.attr, doc.nodeAt(this.pos).attrs[this.attr]);
+    }
+    map(mapping) {
+        let pos = mapping.mapResult(this.pos, 1);
+        return pos.deletedAfter ? null : new AttrStep(pos.pos, this.attr, this.value);
+    }
+    toJSON() {
+        return { stepType: "attr", pos: this.pos, attr: this.attr, value: this.value };
+    }
+    static fromJSON(schema, json) {
+        if (typeof json.pos != "number" || typeof json.attr != "string")
+            throw new RangeError("Invalid input for AttrStep.fromJSON");
+        return new AttrStep(json.pos, json.attr, json.value);
+    }
+}
+Step.jsonID("attr", AttrStep);
+/**
+Update an attribute in the doc node.
+*/
+class DocAttrStep extends Step {
+    /**
+    Construct an attribute step.
+    */
+    constructor(
+    /**
+    The attribute to set.
+    */
+    attr, 
+    // The attribute's new value.
+    value) {
+        super();
+        this.attr = attr;
+        this.value = value;
+    }
+    apply(doc) {
+        let attrs = Object.create(null);
+        for (let name in doc.attrs)
+            attrs[name] = doc.attrs[name];
+        attrs[this.attr] = this.value;
+        let updated = doc.type.create(attrs, doc.content, doc.marks);
+        return StepResult.ok(updated);
+    }
+    getMap() {
+        return StepMap.empty;
+    }
+    invert(doc) {
+        return new DocAttrStep(this.attr, doc.attrs[this.attr]);
+    }
+    map(mapping) {
+        return this;
+    }
+    toJSON() {
+        return { stepType: "docAttr", attr: this.attr, value: this.value };
+    }
+    static fromJSON(schema, json) {
+        if (typeof json.attr != "string")
+            throw new RangeError("Invalid input for DocAttrStep.fromJSON");
+        return new DocAttrStep(json.attr, json.value);
+    }
+}
+Step.jsonID("docAttr", DocAttrStep);
+
+/**
+@internal
+*/
+let TransformError = class extends Error {
+};
+TransformError = function TransformError(message) {
+    let err = Error.call(this, message);
+    err.__proto__ = TransformError.prototype;
+    return err;
+};
+TransformError.prototype = Object.create(Error.prototype);
+TransformError.prototype.constructor = TransformError;
+TransformError.prototype.name = "TransformError";
+
 /**
 Returns a command function that wraps the selection in a list with
 the given type an attributes. If `dispatch` is null, only return a
@@ -8701,7 +9650,7 @@ function wrapInList$1(listType, attrs = null) {
                 range = new utils.NodeRange($from, state.doc.resolve($to.end(range.depth)), range.depth);
             doJoin = true;
         }
-        let wrap = utils.findWrapping(outerRange, listType, attrs, range);
+        let wrap = findWrapping(outerRange, listType, attrs, range);
         if (!wrap)
             return false;
         if (dispatch)
@@ -8713,7 +9662,7 @@ function doWrapInList(tr, range, wrappers, joinBefore, listType) {
     let content = utils.Fragment.empty;
     for (let i = wrappers.length - 1; i >= 0; i--)
         content = utils.Fragment.from(wrappers[i].type.create(wrappers[i].attrs, content));
-    tr.step(new utils.ReplaceAroundStep(range.start - (joinBefore ? 2 : 0), range.end, range.start, range.end, new utils.Slice(content, 0, 0), wrappers.length, true));
+    tr.step(new ReplaceAroundStep(range.start - (joinBefore ? 2 : 0), range.end, range.start, range.end, new utils.Slice(content, 0, 0), wrappers.length, true));
     let found = 0;
     for (let i = 0; i < wrappers.length; i++)
         if (wrappers[i].type == listType)
@@ -8721,7 +9670,7 @@ function doWrapInList(tr, range, wrappers, joinBefore, listType) {
     let splitDepth = wrappers.length - found;
     let splitPos = range.start + wrappers.length - (joinBefore ? 2 : 0), parent = range.parent;
     for (let i = range.startIndex, e = range.endIndex, first = true; i < e; i++, first = false) {
-        if (!first && utils.canSplit(tr.doc, splitPos, splitDepth)) {
+        if (!first && canSplit(tr.doc, splitPos, splitDepth)) {
             tr.split(splitPos, splitDepth);
             splitPos += 2 * splitDepth;
         }
@@ -8752,15 +9701,15 @@ function liftToOuterList(state, dispatch, itemType, range) {
     if (end < endOfList) {
         // There are siblings after the lifted items, which must become
         // children of the last item
-        tr.step(new utils.ReplaceAroundStep(end - 1, endOfList, end, endOfList, new utils.Slice(utils.Fragment.from(itemType.create(null, range.parent.copy())), 1, 0), 1, true));
+        tr.step(new ReplaceAroundStep(end - 1, endOfList, end, endOfList, new utils.Slice(utils.Fragment.from(itemType.create(null, range.parent.copy())), 1, 0), 1, true));
         range = new utils.NodeRange(tr.doc.resolve(range.$from.pos), tr.doc.resolve(endOfList), range.depth);
     }
-    const target = utils.liftTarget(range);
+    const target = liftTarget(range);
     if (target == null)
         return false;
     tr.lift(range, target);
     let after = tr.mapping.map(end, -1) - 1;
-    if (utils.canJoin(tr.doc, after))
+    if (canJoin(tr.doc, after))
         tr.join(after);
     dispatch(tr.scrollIntoView());
     return true;
@@ -8783,7 +9732,7 @@ function liftOutOfList(state, dispatch, range) {
     // Strip off the surrounding list. At the sides where we're not at
     // the end of the list, the existing list is closed. At sides where
     // this is the end, it is overwritten to its end.
-    tr.step(new utils.ReplaceAroundStep(start - (atStart ? 1 : 0), end + (atEnd ? 1 : 0), start + 1, end - 1, new utils.Slice((atStart ? utils.Fragment.empty : utils.Fragment.from(list.copy(utils.Fragment.empty)))
+    tr.step(new ReplaceAroundStep(start - (atStart ? 1 : 0), end + (atEnd ? 1 : 0), start + 1, end - 1, new utils.Slice((atStart ? utils.Fragment.empty : utils.Fragment.from(list.copy(utils.Fragment.empty)))
         .append(atEnd ? utils.Fragment.empty : utils.Fragment.from(list.copy(utils.Fragment.empty))), atStart ? 0 : 1, atEnd ? 0 : 1), atStart ? 0 : 1));
     dispatch(tr.scrollIntoView());
     return true;
@@ -8809,7 +9758,7 @@ function sinkListItem$1(itemType) {
             let inner = utils.Fragment.from(nestedBefore ? itemType.create() : null);
             let slice = new utils.Slice(utils.Fragment.from(itemType.create(null, utils.Fragment.from(parent.type.create(null, inner)))), nestedBefore ? 3 : 1, 0);
             let before = range.start, after = range.end;
-            dispatch(state.tr.step(new utils.ReplaceAroundStep(before - (nestedBefore ? 3 : 1), after, before, after, slice, 1, true))
+            dispatch(state.tr.step(new ReplaceAroundStep(before - (nestedBefore ? 3 : 1), after, before, after, slice, 1, true))
                 .scrollIntoView());
         }
         return true;
@@ -10247,7 +11196,7 @@ const clearNodes = () => ({ state, tr, dispatch }) => {
             if (!nodeRange) {
                 return;
             }
-            const targetLiftDepth = liftTarget(nodeRange);
+            const targetLiftDepth = liftTarget$1(nodeRange);
             if (node.type.isTextblock) {
                 const { defaultType } = $mappedFrom.parent.contentMatchAt($mappedFrom.index());
                 tr.setNodeMarkup(nodeRange.start, defaultType);
@@ -10642,7 +11591,7 @@ function selectionToInsertionEnd(tr, startLen, bias) {
         return;
     }
     const step = tr.steps[last];
-    if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep)) {
+    if (!(step instanceof ReplaceStep$1 || step instanceof ReplaceAroundStep$1)) {
         return;
     }
     const map = tr.mapping.maps[last];
@@ -11717,7 +12666,7 @@ const splitBlock = ({ keepMarks = true } = {}) => ({ tr, state, dispatch, editor
     const extensionAttributes = editor.extensionManager.attributes;
     const newAttributes = getSplittedAttributes(extensionAttributes, $from.node().type.name, $from.node().attrs);
     if (selection instanceof utils.NodeSelection && selection.node.isBlock) {
-        if (!$from.parentOffset || !canSplit(doc, $from.pos)) {
+        if (!$from.parentOffset || !canSplit$1(doc, $from.pos)) {
             return false;
         }
         if (dispatch) {
@@ -11743,10 +12692,10 @@ const splitBlock = ({ keepMarks = true } = {}) => ({ tr, state, dispatch, editor
             },
         ]
         : undefined;
-    let can = canSplit(tr.doc, tr.mapping.map($from.pos), 1, types);
+    let can = canSplit$1(tr.doc, tr.mapping.map($from.pos), 1, types);
     if (!types
         && !can
-        && canSplit(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : undefined)) {
+        && canSplit$1(tr.doc, tr.mapping.map($from.pos), 1, deflt ? [{ type: deflt }] : undefined)) {
         can = true;
         types = deflt
             ? [
@@ -11846,7 +12795,7 @@ const splitListItem = typeOrName => ({ tr, state, dispatch, editor, }) => {
             { type: nextType, attrs: newNextTypeAttributes },
         ]
         : [{ type, attrs: newTypeAttributes }];
-    if (!canSplit(tr.doc, $from.pos, 2)) {
+    if (!canSplit$1(tr.doc, $from.pos, 2)) {
         return false;
     }
     if (dispatch) {
@@ -11873,7 +12822,7 @@ const joinListBackwards = (tr, listType) => {
         return true;
     }
     const nodeBefore = tr.doc.nodeAt(before);
-    const canJoinBackwards = list.node.type === (nodeBefore === null || nodeBefore === void 0 ? void 0 : nodeBefore.type) && canJoin(tr.doc, list.pos);
+    const canJoinBackwards = list.node.type === (nodeBefore === null || nodeBefore === void 0 ? void 0 : nodeBefore.type) && canJoin$1(tr.doc, list.pos);
     if (!canJoinBackwards) {
         return true;
     }
@@ -11890,7 +12839,7 @@ const joinListForwards = (tr, listType) => {
         return true;
     }
     const nodeAfter = tr.doc.nodeAt(after);
-    const canJoinForwards = list.node.type === (nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.type) && canJoin(tr.doc, after);
+    const canJoinForwards = list.node.type === (nodeAfter === null || nodeAfter === void 0 ? void 0 : nodeAfter.type) && canJoin$1(tr.doc, after);
     if (!canJoinForwards) {
         return true;
     }
@@ -13169,7 +14118,7 @@ function wrappingInputRule(config) {
             const tr = state.tr.delete(range.from, range.to);
             const $start = tr.doc.resolve(range.from);
             const blockRange = $start.blockRange();
-            const wrapping = blockRange && findWrapping(blockRange, config.type, attributes);
+            const wrapping = blockRange && findWrapping$1(blockRange, config.type, attributes);
             if (!wrapping) {
                 return null;
             }
@@ -13191,7 +14140,7 @@ function wrappingInputRule(config) {
             const before = tr.doc.resolve(range.from - 1).nodeBefore;
             if (before
                 && before.type === config.type
-                && canJoin(tr.doc, range.from - 1)
+                && canJoin$1(tr.doc, range.from - 1)
                 && (!config.joinPredicate || config.joinPredicate(match, before))) {
                 tr.join(range.from - 1);
             }
@@ -18486,7 +19435,7 @@ exports.getMarksBetween = getMarksBetween;
 exports.highlightFocussedNode = highlightFocussedNode;
 exports.isNodeSelection = isNodeSelection;
 exports.keydownHandler = keydownHandler;
-exports.liftTarget = liftTarget;
+exports.liftTarget = liftTarget$1;
 exports.markInputRule = markInputRule;
 exports.markPasteRule = markPasteRule;
 exports.mergeAttributes = mergeAttributes;
@@ -18497,4 +19446,4 @@ exports.useEditor = useEditor;
 exports.useEditorState = useEditorState$1;
 exports.validateUrl = validateUrl;
 exports.wrappingInputRule = wrappingInputRule;
-//# sourceMappingURL=chunk-c2f54026.cjs.js.map
+//# sourceMappingURL=chunk-eee94a18.cjs.js.map