@fewangsit/wangsvue 1.5.219-alpha.0 → 1.5.219-alpha.2

package/vendor/prosemirror-transform/dist/index.es.js

@@ -1,21 +1,24 @@
-import { b as w, F as g, M as se, d as oe, R as le } from "../../prosemirror-model/dist/index.es.js";
-const Q = 65535, U = Math.pow(2, 16);
-function ae(s, e) {
-  return s + e * U;
+import { b as Slice, F as Fragment, M as Mark, d as MarkType, R as ReplaceError } from "../../prosemirror-model/dist/index.es.js";
+const lower16 = 65535;
+const factor16 = Math.pow(2, 16);
+function makeRecover(index, offset) {
+  return index + offset * factor16;
 }
-function H(s) {
-  return s & Q;
+function recoverIndex(value) {
+  return value & lower16;
 }
-function he(s) {
-  return (s - (s & Q)) / U;
+function recoverOffset(value) {
+  return (value - (value & lower16)) / factor16;
 }
-const V = 1, X = 2, J = 4, Y = 8;
-class L {
+const DEL_BEFORE = 1, DEL_AFTER = 2, DEL_ACROSS = 4, DEL_SIDE = 8;
+class MapResult {
   /**
   @internal
   */
-  constructor(e, t, r) {
-    this.pos = e, this.delInfo = t, this.recover = r;
+  constructor(pos, delInfo, recover) {
+    this.pos = pos;
+    this.delInfo = delInfo;
+    this.recover = recover;
   }
   /**
   Tells you whether the position was deleted, that is, whether the
@@ -23,19 +26,19 @@ class L {
   argument from the document.
   */
   get deleted() {
-    return (this.delInfo & Y) > 0;
+    return (this.delInfo & DEL_SIDE) > 0;
   }
   /**
   Tells you whether the token before the mapped position was deleted.
   */
   get deletedBefore() {
-    return (this.delInfo & (V | J)) > 0;
+    return (this.delInfo & (DEL_BEFORE | DEL_ACROSS)) > 0;
   }
   /**
   True when the token after the mapped position was deleted.
   */
   get deletedAfter() {
-    return (this.delInfo & (X | J)) > 0;
+    return (this.delInfo & (DEL_AFTER | DEL_ACROSS)) > 0;
   }
   /**
   Tells whether any of the steps mapped through deletes across the
@@ -43,81 +46,90 @@ class L {
   position).
   */
   get deletedAcross() {
-    return (this.delInfo & J) > 0;
+    return (this.delInfo & DEL_ACROSS) > 0;
   }
 }
-class S {
+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(e, t = !1) {
-    if (this.ranges = e, this.inverted = t, !e.length && S.empty)
-      return S.empty;
+  constructor(ranges, inverted = false) {
+    this.ranges = ranges;
+    this.inverted = inverted;
+    if (!ranges.length && StepMap.empty)
+      return StepMap.empty;
   }
   /**
   @internal
   */
-  recover(e) {
-    let t = 0, r = H(e);
+  recover(value) {
+    let diff = 0, index = recoverIndex(value);
     if (!this.inverted)
-      for (let n = 0; n < r; n++)
-        t += this.ranges[n * 3 + 2] - this.ranges[n * 3 + 1];
-    return this.ranges[r * 3] + t + he(e);
+      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(e, t = 1) {
-    return this._map(e, t, !1);
+  mapResult(pos, assoc = 1) {
+    return this._map(pos, assoc, false);
   }
-  map(e, t = 1) {
-    return this._map(e, t, !0);
+  map(pos, assoc = 1) {
+    return this._map(pos, assoc, true);
   }
   /**
   @internal
   */
-  _map(e, t, r) {
-    let n = 0, i = this.inverted ? 2 : 1, o = this.inverted ? 1 : 2;
-    for (let l = 0; l < this.ranges.length; l += 3) {
-      let a = this.ranges[l] - (this.inverted ? n : 0);
-      if (a > e)
+  _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 h = this.ranges[l + i], p = this.ranges[l + o], c = a + h;
-      if (e <= c) {
-        let f = h ? e == a ? -1 : e == c ? 1 : t : t, d = a + n + (f < 0 ? 0 : p);
-        if (r)
-          return d;
-        let u = e == (t < 0 ? a : c) ? null : ae(l / 3, e - a), m = e == a ? X : e == c ? V : J;
-        return (t < 0 ? e != a : e != c) && (m |= Y), new L(d, m, u);
+      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);
       }
-      n += p - h;
+      diff += newSize - oldSize;
     }
-    return r ? e + n : new L(e + n, 0, null);
+    return simple ? pos + diff : new MapResult(pos + diff, 0, null);
   }
   /**
   @internal
   */
-  touches(e, t) {
-    let r = 0, n = H(t), i = this.inverted ? 2 : 1, o = this.inverted ? 1 : 2;
-    for (let l = 0; l < this.ranges.length; l += 3) {
-      let a = this.ranges[l] - (this.inverted ? r : 0);
-      if (a > e)
+  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 h = this.ranges[l + i], p = a + h;
-      if (e <= p && l == n * 3)
-        return !0;
-      r += this.ranges[l + o] - h;
+      let oldSize = this.ranges[i + oldIndex], end = start + oldSize;
+      if (pos <= end && i == index * 3)
+        return true;
+      diff += this.ranges[i + newIndex] - oldSize;
     }
-    return !1;
+    return false;
   }
   /**
   Calls the given function on each of the changed ranges included in
   this map.
   */
-  forEach(e) {
-    let t = this.inverted ? 2 : 1, r = this.inverted ? 1 : 2;
-    for (let n = 0, i = 0; n < this.ranges.length; n += 3) {
-      let o = this.ranges[n], l = o - (this.inverted ? i : 0), a = o + (this.inverted ? 0 : i), h = this.ranges[n + t], p = this.ranges[n + r];
-      e(l, l + h, a, a + p), i += p - h;
+  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;
     }
   }
   /**
@@ -125,7 +137,7 @@ class S {
   map positions in the post-step document to the pre-step document.
   */
   invert() {
-    return new S(this.ranges, !this.inverted);
+    return new StepMap(this.ranges, !this.inverted);
   }
   /**
   @internal
@@ -138,17 +150,21 @@ class S {
   negative). This can be useful when applying steps meant for a
   sub-document to a larger document, or vice-versa.
   */
-  static offset(e) {
-    return e == 0 ? S.empty : new S(e < 0 ? [0, -e, 0] : [0, 0, e]);
+  static offset(n) {
+    return n == 0 ? StepMap.empty : new StepMap(n < 0 ? [0, -n, 0] : [0, 0, n]);
   }
 }
-S.empty = new S([]);
-class A {
+StepMap.empty = new StepMap([]);
+class Mapping {
   /**
   Create a new mapping with the given position maps.
   */
-  constructor(e, t, r = 0, n = e ? e.length : 0) {
-    this.mirror = t, this.from = r, this.to = n, this._maps = e || [], this.ownData = !(e || t);
+  constructor(maps, mirror, from = 0, to = maps ? maps.length : 0) {
+    this.mirror = mirror;
+    this.from = from;
+    this.to = to;
+    this._maps = maps || [];
+    this.ownData = !(maps || mirror);
   }
   /**
   The step maps in this mapping.
@@ -159,25 +175,32 @@ class A {
   /**
   Create a mapping that maps only through a part of this one.
   */
-  slice(e = 0, t = this.maps.length) {
-    return new A(this._maps, this.mirror, e, t);
+  slice(from = 0, to = this.maps.length) {
+    return new Mapping(this._maps, this.mirror, from, to);
   }
   /**
   Add a step map to the end of this mapping. If `mirrors` is
   given, it should be the index of the step map that is the mirror
   image of this one.
   */
-  appendMap(e, t) {
-    this.ownData || (this._maps = this._maps.slice(), this.mirror = this.mirror && this.mirror.slice(), this.ownData = !0), this.to = this._maps.push(e), t != null && this.setMirror(this._maps.length - 1, t);
+  appendMap(map, mirrors) {
+    if (!this.ownData) {
+      this._maps = this._maps.slice();
+      this.mirror = this.mirror && this.mirror.slice();
+      this.ownData = true;
+    }
+    this.to = this._maps.push(map);
+    if (mirrors != null)
+      this.setMirror(this._maps.length - 1, mirrors);
   }
   /**
   Add all the step maps in a given mapping to this one (preserving
   mirroring information).
   */
-  appendMapping(e) {
-    for (let t = 0, r = this._maps.length; t < e._maps.length; t++) {
-      let n = e.getMirror(t);
-      this.appendMap(e._maps[t], n != null && n < t ? r + n : void 0);
+  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 : void 0);
     }
   }
   /**
@@ -185,100 +208,105 @@ class A {
   given offset, in this mapping (as per the second argument to
   `appendMap`).
   */
-  getMirror(e) {
+  getMirror(n) {
     if (this.mirror) {
-      for (let t = 0; t < this.mirror.length; t++)
-        if (this.mirror[t] == e)
-          return this.mirror[t + (t % 2 ? -1 : 1)];
+      for (let i = 0; i < this.mirror.length; i++)
+        if (this.mirror[i] == n)
+          return this.mirror[i + (i % 2 ? -1 : 1)];
     }
   }
   /**
   @internal
   */
-  setMirror(e, t) {
-    this.mirror || (this.mirror = []), this.mirror.push(e, t);
+  setMirror(n, m) {
+    if (!this.mirror)
+      this.mirror = [];
+    this.mirror.push(n, m);
   }
   /**
   Append the inverse of the given mapping to this one.
   */
-  appendMappingInverted(e) {
-    for (let t = e.maps.length - 1, r = this._maps.length + e._maps.length; t >= 0; t--) {
-      let n = e.getMirror(t);
-      this.appendMap(e._maps[t].invert(), n != null && n > t ? r - n - 1 : void 0);
+  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 : void 0);
     }
   }
   /**
   Create an inverted version of this mapping.
   */
   invert() {
-    let e = new A();
-    return e.appendMappingInverted(this), e;
+    let inverse = new Mapping();
+    inverse.appendMappingInverted(this);
+    return inverse;
   }
   /**
   Map a position through this mapping.
   */
-  map(e, t = 1) {
+  map(pos, assoc = 1) {
     if (this.mirror)
-      return this._map(e, t, !0);
-    for (let r = this.from; r < this.to; r++)
-      e = this._maps[r].map(e, t);
-    return e;
+      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(e, t = 1) {
-    return this._map(e, t, !1);
+  mapResult(pos, assoc = 1) {
+    return this._map(pos, assoc, false);
   }
   /**
   @internal
   */
-  _map(e, t, r) {
-    let n = 0;
+  _map(pos, assoc, simple) {
+    let delInfo = 0;
     for (let i = this.from; i < this.to; i++) {
-      let o = this._maps[i], l = o.mapResult(e, t);
-      if (l.recover != null) {
-        let a = this.getMirror(i);
-        if (a != null && a > i && a < this.to) {
-          i = a, e = this._maps[a].recover(l.recover);
+      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;
         }
       }
-      n |= l.delInfo, e = l.pos;
+      delInfo |= result.delInfo;
+      pos = result.pos;
     }
-    return r ? e : new L(e, n, null);
+    return simple ? pos : new MapResult(pos, delInfo, null);
   }
 }
-const B = /* @__PURE__ */ Object.create(null);
-class k {
+const stepsByID = /* @__PURE__ */ Object.create(null);
+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 S.empty;
+    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(e) {
+  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(e, t) {
-    if (!t || !t.stepType)
+  static fromJSON(schema, json) {
+    if (!json || !json.stepType)
       throw new RangeError("Invalid input for Step.fromJSON");
-    let r = B[t.stepType];
-    if (!r)
-      throw new RangeError(`No step type ${t.stepType} defined`);
-    return r.fromJSON(e, t);
+    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
@@ -286,74 +314,94 @@ class k {
   register an ID for your step classes. Try to pick something
   that's unlikely to clash with steps from other modules.
   */
-  static jsonID(e, t) {
-    if (e in B)
-      throw new RangeError("Duplicate use of step JSON ID " + e);
-    return B[e] = t, t.prototype.jsonID = e, t;
+  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;
   }
 }
-class y {
+class StepResult {
   /**
   @internal
   */
-  constructor(e, t) {
-    this.doc = e, this.failed = t;
+  constructor(doc, failed) {
+    this.doc = doc;
+    this.failed = failed;
   }
   /**
   Create a successful step result.
   */
-  static ok(e) {
-    return new y(e, null);
+  static ok(doc) {
+    return new StepResult(doc, null);
   }
   /**
   Create a failed step result.
   */
-  static fail(e) {
-    return new y(null, e);
+  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(e, t, r, n) {
+  static fromReplace(doc, from, to, slice) {
     try {
-      return y.ok(e.replace(t, r, n));
-    } catch (i) {
-      if (i instanceof le)
-        return y.fail(i.message);
-      throw i;
+      return StepResult.ok(doc.replace(from, to, slice));
+    } catch (e) {
+      if (e instanceof ReplaceError)
+        return StepResult.fail(e.message);
+      throw e;
     }
   }
 }
-function P(s, e, t) {
-  let r = [];
-  for (let n = 0; n < s.childCount; n++) {
-    let i = s.child(n);
-    i.content.size && (i = i.copy(P(i.content, e, i))), i.isInline && (i = e(i, t, n)), r.push(i);
-  }
-  return g.fromArray(r);
+function mapFragment(fragment, f, parent) {
+  let mapped = [];
+  for (let i = 0; i < fragment.childCount; i++) {
+    let child = fragment.child(i);
+    if (child.content.size)
+      child = child.copy(mapFragment(child.content, f, child));
+    if (child.isInline)
+      child = f(child, parent, i);
+    mapped.push(child);
+  }
+  return Fragment.fromArray(mapped);
 }
-class C extends k {
+class AddMarkStep extends Step {
   /**
   Create a mark step.
   */
-  constructor(e, t, r) {
-    super(), this.from = e, this.to = t, this.mark = r;
-  }
-  apply(e) {
-    let t = e.slice(this.from, this.to), r = e.resolve(this.from), n = r.node(r.sharedDepth(this.to)), i = new w(P(t.content, (o, l) => !o.isAtom || !l.type.allowsMarkType(this.mark.type) ? o : o.mark(this.mark.addToSet(o.marks)), n), t.openStart, t.openEnd);
-    return y.fromReplace(e, this.from, this.to, i);
+  constructor(from, to, mark) {
+    super();
+    this.from = from;
+    this.to = to;
+    this.mark = mark;
+  }
+  apply(doc) {
+    let oldSlice = doc.slice(this.from, this.to), $from = doc.resolve(this.from);
+    let parent = $from.node($from.sharedDepth(this.to));
+    let slice = new Slice(mapFragment(oldSlice.content, (node, parent2) => {
+      if (!node.isAtom || !parent2.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 b(this.from, this.to, this.mark);
+    return new RemoveMarkStep(this.from, this.to, this.mark);
   }
-  map(e) {
-    let t = e.mapResult(this.from, 1), r = e.mapResult(this.to, -1);
-    return t.deleted && r.deleted || t.pos >= r.pos ? null : new C(t.pos, r.pos, 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(e) {
-    return e instanceof C && e.mark.eq(this.mark) && this.from <= e.to && this.to >= e.from ? new C(Math.min(this.from, e.from), Math.max(this.to, e.to), this.mark) : null;
+  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 {
@@ -366,33 +414,43 @@ class C extends k {
   /**
   @internal
   */
-  static fromJSON(e, t) {
-    if (typeof t.from != "number" || typeof t.to != "number")
+  static fromJSON(schema, json) {
+    if (typeof json.from != "number" || typeof json.to != "number")
       throw new RangeError("Invalid input for AddMarkStep.fromJSON");
-    return new C(t.from, t.to, e.markFromJSON(t.mark));
+    return new AddMarkStep(json.from, json.to, schema.markFromJSON(json.mark));
   }
 }
-k.jsonID("addMark", C);
-class b extends k {
+Step.jsonID("addMark", AddMarkStep);
+class RemoveMarkStep extends Step {
   /**
   Create a mark-removing step.
   */
-  constructor(e, t, r) {
-    super(), this.from = e, this.to = t, this.mark = r;
+  constructor(from, to, mark) {
+    super();
+    this.from = from;
+    this.to = to;
+    this.mark = mark;
   }
-  apply(e) {
-    let t = e.slice(this.from, this.to), r = new w(P(t.content, (n) => n.mark(this.mark.removeFromSet(n.marks)), e), t.openStart, t.openEnd);
-    return y.fromReplace(e, this.from, this.to, r);
+  apply(doc) {
+    let oldSlice = doc.slice(this.from, this.to);
+    let slice = new Slice(mapFragment(oldSlice.content, (node) => {
+      return node.mark(this.mark.removeFromSet(node.marks));
+    }, doc), oldSlice.openStart, oldSlice.openEnd);
+    return StepResult.fromReplace(doc, this.from, this.to, slice);
   }
   invert() {
-    return new C(this.from, this.to, this.mark);
+    return new AddMarkStep(this.from, this.to, this.mark);
   }
-  map(e) {
-    let t = e.mapResult(this.from, 1), r = e.mapResult(this.to, -1);
-    return t.deleted && r.deleted || t.pos >= r.pos ? null : new b(t.pos, r.pos, 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(e) {
-    return e instanceof b && e.mark.eq(this.mark) && this.from <= e.to && this.to >= e.from ? new b(Math.min(this.from, e.from), Math.max(this.to, e.to), this.mark) : null;
+  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 {
@@ -405,43 +463,45 @@ class b extends k {
   /**
   @internal
   */
-  static fromJSON(e, t) {
-    if (typeof t.from != "number" || typeof t.to != "number")
+  static fromJSON(schema, json) {
+    if (typeof json.from != "number" || typeof json.to != "number")
       throw new RangeError("Invalid input for RemoveMarkStep.fromJSON");
-    return new b(t.from, t.to, e.markFromJSON(t.mark));
+    return new RemoveMarkStep(json.from, json.to, schema.markFromJSON(json.mark));
   }
 }
-k.jsonID("removeMark", b);
-class N extends k {
+Step.jsonID("removeMark", RemoveMarkStep);
+class AddNodeMarkStep extends Step {
   /**
   Create a node mark step.
   */
-  constructor(e, t) {
-    super(), this.pos = e, this.mark = t;
-  }
-  apply(e) {
-    let t = e.nodeAt(this.pos);
-    if (!t)
-      return y.fail("No node at mark step's position");
-    let r = t.type.create(t.attrs, null, this.mark.addToSet(t.marks));
-    return y.fromReplace(e, this.pos, this.pos + 1, new w(g.from(r), 0, t.isLeaf ? 0 : 1));
-  }
-  invert(e) {
-    let t = e.nodeAt(this.pos);
-    if (t) {
-      let r = this.mark.addToSet(t.marks);
-      if (r.length == t.marks.length) {
-        for (let n = 0; n < t.marks.length; n++)
-          if (!t.marks[n].isInSet(r))
-            return new N(this.pos, t.marks[n]);
-        return new N(this.pos, this.mark);
+  constructor(pos, mark) {
+    super();
+    this.pos = pos;
+    this.mark = mark;
+  }
+  apply(doc) {
+    let node = doc.nodeAt(this.pos);
+    if (!node)
+      return StepResult.fail("No node at mark step's position");
+    let updated = node.type.create(node.attrs, null, this.mark.addToSet(node.marks));
+    return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
+  }
+  invert(doc) {
+    let node = doc.nodeAt(this.pos);
+    if (node) {
+      let newSet = this.mark.addToSet(node.marks);
+      if (newSet.length == node.marks.length) {
+        for (let i = 0; i < node.marks.length; i++)
+          if (!node.marks[i].isInSet(newSet))
+            return new AddNodeMarkStep(this.pos, node.marks[i]);
+        return new AddNodeMarkStep(this.pos, this.mark);
       }
     }
-    return new R(this.pos, this.mark);
+    return new RemoveNodeMarkStep(this.pos, this.mark);
   }
-  map(e) {
-    let t = e.mapResult(this.pos, 1);
-    return t.deletedAfter ? null : new N(t.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() };
@@ -449,34 +509,38 @@ class N extends k {
   /**
   @internal
   */
-  static fromJSON(e, t) {
-    if (typeof t.pos != "number")
+  static fromJSON(schema, json) {
+    if (typeof json.pos != "number")
       throw new RangeError("Invalid input for AddNodeMarkStep.fromJSON");
-    return new N(t.pos, e.markFromJSON(t.mark));
+    return new AddNodeMarkStep(json.pos, schema.markFromJSON(json.mark));
   }
 }
-k.jsonID("addNodeMark", N);
-class R extends k {
+Step.jsonID("addNodeMark", AddNodeMarkStep);
+class RemoveNodeMarkStep extends Step {
   /**
   Create a mark-removing step.
   */
-  constructor(e, t) {
-    super(), this.pos = e, this.mark = t;
+  constructor(pos, mark) {
+    super();
+    this.pos = pos;
+    this.mark = mark;
   }
-  apply(e) {
-    let t = e.nodeAt(this.pos);
-    if (!t)
-      return y.fail("No node at mark step's position");
-    let r = t.type.create(t.attrs, null, this.mark.removeFromSet(t.marks));
-    return y.fromReplace(e, this.pos, this.pos + 1, new w(g.from(r), 0, t.isLeaf ? 0 : 1));
+  apply(doc) {
+    let node = doc.nodeAt(this.pos);
+    if (!node)
+      return StepResult.fail("No node at mark step's position");
+    let updated = node.type.create(node.attrs, null, this.mark.removeFromSet(node.marks));
+    return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
   }
-  invert(e) {
-    let t = e.nodeAt(this.pos);
-    return !t || !this.mark.isInSet(t.marks) ? this : new N(this.pos, this.mark);
+  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(e) {
-    let t = e.mapResult(this.pos, 1);
-    return t.deletedAfter ? null : new R(t.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() };
@@ -484,14 +548,14 @@ class R extends k {
   /**
   @internal
   */
-  static fromJSON(e, t) {
-    if (typeof t.pos != "number")
+  static fromJSON(schema, json) {
+    if (typeof json.pos != "number")
       throw new RangeError("Invalid input for RemoveNodeMarkStep.fromJSON");
-    return new R(t.pos, e.markFromJSON(t.mark));
+    return new RemoveNodeMarkStep(json.pos, schema.markFromJSON(json.mark));
   }
 }
-k.jsonID("removeNodeMark", R);
-class v extends k {
+Step.jsonID("removeNodeMark", RemoveNodeMarkStep);
+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
@@ -501,69 +565,91 @@ class v extends k {
   tokens (this is to guard against rebased replace steps
   overwriting something they weren't supposed to).
   */
-  constructor(e, t, r, n = !1) {
-    super(), this.from = e, this.to = t, this.slice = r, this.structure = n;
+  constructor(from, to, slice, structure = false) {
+    super();
+    this.from = from;
+    this.to = to;
+    this.slice = slice;
+    this.structure = structure;
   }
-  apply(e) {
-    return this.structure && q(e, this.from, this.to) ? y.fail("Structure replace would overwrite content") : y.fromReplace(e, this.from, this.to, this.slice);
+  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 S([this.from, this.to - this.from, this.slice.size]);
+    return new StepMap([this.from, this.to - this.from, this.slice.size]);
   }
-  invert(e) {
-    return new v(this.from, this.from + this.slice.size, e.slice(this.from, this.to));
+  invert(doc) {
+    return new ReplaceStep(this.from, this.from + this.slice.size, doc.slice(this.from, this.to));
   }
-  map(e) {
-    let t = e.mapResult(this.from, 1), r = e.mapResult(this.to, -1);
-    return t.deletedAcross && r.deletedAcross ? null : new v(t.pos, Math.max(t.pos, r.pos), this.slice, this.structure);
+  map(mapping) {
+    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
+    if (from.deletedAcross && to.deletedAcross)
+      return null;
+    return new ReplaceStep(from.pos, Math.max(from.pos, to.pos), this.slice, this.structure);
   }
-  merge(e) {
-    if (!(e instanceof v) || e.structure || this.structure)
+  merge(other) {
+    if (!(other instanceof ReplaceStep) || other.structure || this.structure)
       return null;
-    if (this.from + this.slice.size == e.from && !this.slice.openEnd && !e.slice.openStart) {
-      let t = this.slice.size + e.slice.size == 0 ? w.empty : new w(this.slice.content.append(e.slice.content), this.slice.openStart, e.slice.openEnd);
-      return new v(this.from, this.to + (e.to - e.from), t, this.structure);
-    } else if (e.to == this.from && !this.slice.openStart && !e.slice.openEnd) {
-      let t = this.slice.size + e.slice.size == 0 ? w.empty : new w(e.slice.content.append(this.slice.content), e.slice.openStart, this.slice.openEnd);
-      return new v(e.from, this.to, t, this.structure);
-    } else
+    if (this.from + this.slice.size == other.from && !this.slice.openEnd && !other.slice.openStart) {
+      let slice = this.slice.size + other.slice.size == 0 ? Slice.empty : new Slice(this.slice.content.append(other.slice.content), this.slice.openStart, other.slice.openEnd);
+      return new ReplaceStep(this.from, this.to + (other.to - other.from), slice, this.structure);
+    } else if (other.to == this.from && !this.slice.openStart && !other.slice.openEnd) {
+      let slice = this.slice.size + other.slice.size == 0 ? Slice.empty : new Slice(other.slice.content.append(this.slice.content), other.slice.openStart, this.slice.openEnd);
+      return new ReplaceStep(other.from, this.to, slice, this.structure);
+    } else {
       return null;
+    }
   }
   toJSON() {
-    let e = { stepType: "replace", from: this.from, to: this.to };
-    return this.slice.size && (e.slice = this.slice.toJSON()), this.structure && (e.structure = !0), e;
+    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(e, t) {
-    if (typeof t.from != "number" || typeof t.to != "number")
+  static fromJSON(schema, json) {
+    if (typeof json.from != "number" || typeof json.to != "number")
       throw new RangeError("Invalid input for ReplaceStep.fromJSON");
-    return new v(t.from, t.to, w.fromJSON(e, t.slice), !!t.structure);
+    return new ReplaceStep(json.from, json.to, Slice.fromJSON(schema, json.slice), !!json.structure);
   }
 }
-k.jsonID("replace", v);
-class M extends k {
+Step.jsonID("replace", ReplaceStep);
+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(e, t, r, n, i, o, l = !1) {
-    super(), this.from = e, this.to = t, this.gapFrom = r, this.gapTo = n, this.slice = i, this.insert = o, this.structure = l;
-  }
-  apply(e) {
-    if (this.structure && (q(e, this.from, this.gapFrom) || q(e, this.gapTo, this.to)))
-      return y.fail("Structure gap-replace would overwrite content");
-    let t = e.slice(this.gapFrom, this.gapTo);
-    if (t.openStart || t.openEnd)
-      return y.fail("Gap is not a flat range");
-    let r = this.slice.insertAt(this.insert, t.content);
-    return r ? y.fromReplace(e, this.from, this.to, r) : y.fail("Content does not fit in gap");
+  constructor(from, to, gapFrom, gapTo, slice, insert, 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 S([
+    return new StepMap([
       this.from,
       this.gapFrom - this.from,
       this.insert,
@@ -572,16 +658,20 @@ class M extends k {
       this.slice.size - this.insert
     ]);
   }
-  invert(e) {
-    let t = this.gapTo - this.gapFrom;
-    return new M(this.from, this.from + this.slice.size + t, this.from + this.insert, this.from + this.insert + t, e.slice(this.from, this.to).removeBetween(this.gapFrom - this.from, this.gapTo - this.from), this.gapFrom - this.from, this.structure);
+  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(e) {
-    let t = e.mapResult(this.from, 1), r = e.mapResult(this.to, -1), n = this.from == this.gapFrom ? t.pos : e.map(this.gapFrom, -1), i = this.to == this.gapTo ? r.pos : e.map(this.gapTo, 1);
-    return t.deletedAcross && r.deletedAcross || n < t.pos || i > r.pos ? null : new M(t.pos, r.pos, n, i, this.slice, this.insert, 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 e = {
+    let json = {
       stepType: "replaceAround",
       from: this.from,
       to: this.to,
@@ -589,690 +679,892 @@ class M extends k {
       gapTo: this.gapTo,
       insert: this.insert
     };
-    return this.slice.size && (e.slice = this.slice.toJSON()), this.structure && (e.structure = !0), e;
+    if (this.slice.size)
+      json.slice = this.slice.toJSON();
+    if (this.structure)
+      json.structure = true;
+    return json;
   }
   /**
   @internal
   */
-  static fromJSON(e, t) {
-    if (typeof t.from != "number" || typeof t.to != "number" || typeof t.gapFrom != "number" || typeof t.gapTo != "number" || typeof t.insert != "number")
+  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 M(t.from, t.to, t.gapFrom, t.gapTo, w.fromJSON(e, t.slice), t.insert, !!t.structure);
+    return new ReplaceAroundStep(json.from, json.to, json.gapFrom, json.gapTo, Slice.fromJSON(schema, json.slice), json.insert, !!json.structure);
   }
 }
-k.jsonID("replaceAround", M);
-function q(s, e, t) {
-  let r = s.resolve(e), n = t - e, i = r.depth;
-  for (; n > 0 && i > 0 && r.indexAfter(i) == r.node(i).childCount; )
-    i--, n--;
-  if (n > 0) {
-    let o = r.node(i).maybeChild(r.indexAfter(i));
-    for (; n > 0; ) {
-      if (!o || o.isLeaf)
-        return !0;
-      o = o.firstChild, n--;
+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 !1;
+  return false;
 }
-function pe(s, e, t, r) {
-  let n = [], i = [], o, l;
-  s.doc.nodesBetween(e, t, (a, h, p) => {
-    if (!a.isInline)
+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 c = a.marks;
-    if (!r.isInSet(c) && p.type.allowsMarkType(r.type)) {
-      let f = Math.max(h, e), d = Math.min(h + a.nodeSize, t), u = r.addToSet(c);
-      for (let m = 0; m < c.length; m++)
-        c[m].isInSet(u) || (o && o.to == f && o.mark.eq(c[m]) ? o.to = d : n.push(o = new b(f, d, c[m])));
-      l && l.to == f ? l.to = d : i.push(l = new C(f, d, r));
+    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));
     }
-  }), n.forEach((a) => s.step(a)), i.forEach((a) => s.step(a));
+  });
+  removed.forEach((s) => tr.step(s));
+  added.forEach((s) => tr.step(s));
 }
-function fe(s, e, t, r) {
-  let n = [], i = 0;
-  s.doc.nodesBetween(e, t, (o, l) => {
-    if (!o.isInline)
+function removeMark(tr, from, to, mark) {
+  let matched = [], step = 0;
+  tr.doc.nodesBetween(from, to, (node, pos) => {
+    if (!node.isInline)
       return;
-    i++;
-    let a = null;
-    if (r instanceof oe) {
-      let h = o.marks, p;
-      for (; p = r.isInSet(h); )
-        (a || (a = [])).push(p), h = p.removeFromSet(h);
-    } else r ? r.isInSet(o.marks) && (a = [r]) : a = o.marks;
-    if (a && a.length) {
-      let h = Math.min(l + o.nodeSize, t);
-      for (let p = 0; p < a.length; p++) {
-        let c = a[p], f;
-        for (let d = 0; d < n.length; d++) {
-          let u = n[d];
-          u.step == i - 1 && c.eq(n[d].style) && (f = u);
+    step++;
+    let toRemove = null;
+    if (mark instanceof 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 });
         }
-        f ? (f.to = h, f.step = i) : n.push({ style: c, from: Math.max(l, e), to: h, step: i });
       }
     }
-  }), n.forEach((o) => s.step(new b(o.from, o.to, o.style)));
+  });
+  matched.forEach((m) => tr.step(new RemoveMarkStep(m.from, m.to, m.style)));
 }
-function $(s, e, t, r = t.contentMatch, n = !0) {
-  let i = s.doc.nodeAt(e), o = [], l = e + 1;
-  for (let a = 0; a < i.childCount; a++) {
-    let h = i.child(a), p = l + h.nodeSize, c = r.matchType(h.type);
-    if (!c)
-      o.push(new v(l, p, w.empty));
-    else {
-      r = c;
-      for (let f = 0; f < h.marks.length; f++)
-        t.allowsMarkType(h.marks[f].type) || s.step(new b(l, p, h.marks[f]));
-      if (n && h.isText && t.whitespace != "pre") {
-        let f, d = /\r?\n|\r/g, u;
-        for (; f = d.exec(h.text); )
-          u || (u = new w(g.from(t.schema.text(" ", t.allowedMarks(h.marks))), 0, 0)), o.push(new v(l + f.index, l + f.index + f[0].length, u));
+function clearIncompatible(tr, pos, parentType, match = parentType.contentMatch, clearNewlines = true) {
+  let node = tr.doc.nodeAt(pos);
+  let replSteps = [], 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) {
+      replSteps.push(new ReplaceStep(cur, end, 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]));
+      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 Slice(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));
+        }
       }
     }
-    l = p;
+    cur = end;
   }
-  if (!r.validEnd) {
-    let a = r.fillBefore(g.empty, !0);
-    s.replace(l, l, new w(a, 0, 0));
+  if (!match.validEnd) {
+    let fill = match.fillBefore(Fragment.empty, true);
+    tr.replace(cur, cur, new Slice(fill, 0, 0));
   }
-  for (let a = o.length - 1; a >= 0; a--)
-    s.step(o[a]);
+  for (let i = replSteps.length - 1; i >= 0; i--)
+    tr.step(replSteps[i]);
 }
-function ce(s, e, t) {
-  return (e == 0 || s.canReplace(e, s.childCount)) && (t == s.childCount || s.canReplace(0, t));
+function canCut(node, start, end) {
+  return (start == 0 || node.canReplace(start, node.childCount)) && (end == node.childCount || node.canReplace(0, end));
 }
-function Fe(s) {
-  let t = s.parent.content.cutByIndex(s.startIndex, s.endIndex);
-  for (let r = s.depth; ; --r) {
-    let n = s.$from.node(r), i = s.$from.index(r), o = s.$to.indexAfter(r);
-    if (r < s.depth && n.canReplace(i, o, t))
-      return r;
-    if (r == 0 || n.type.spec.isolating || !ce(n, i, o))
+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;
 }
-function de(s, e, t) {
-  let { $from: r, $to: n, depth: i } = e, o = r.before(i + 1), l = n.after(i + 1), a = o, h = l, p = g.empty, c = 0;
-  for (let u = i, m = !1; u > t; u--)
-    m || r.index(u) > 0 ? (m = !0, p = g.from(r.node(u).copy(p)), c++) : a--;
-  let f = g.empty, d = 0;
-  for (let u = i, m = !1; u > t; u--)
-    m || n.after(u + 1) < n.end(u) ? (m = !0, f = g.from(n.node(u).copy(f)), d++) : h++;
-  s.step(new M(a, h, o, l, new w(p.append(f), c, d), p.size - c, !0));
+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 = Fragment.empty, openStart = 0;
+  for (let d = depth, splitting = false; d > target; d--)
+    if (splitting || $from.index(d) > 0) {
+      splitting = true;
+      before = Fragment.from($from.node(d).copy(before));
+      openStart++;
+    } else {
+      start--;
+    }
+  let after = 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 = Fragment.from($to.node(d).copy(after));
+      openEnd++;
+    } else {
+      end++;
+    }
+  tr.step(new ReplaceAroundStep(start, end, gapStart, gapEnd, new Slice(before.append(after), openStart, openEnd), before.size - openStart, true));
 }
-function ze(s, e, t = null, r = s) {
-  let n = ue(s, e), i = n && me(r, e);
-  return i ? n.map(K).concat({ type: e, attrs: t }).concat(i.map(K)) : null;
+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 K(s) {
-  return { type: s, attrs: null };
+function withAttrs(type) {
+  return { type, attrs: null };
 }
-function ue(s, e) {
-  let { parent: t, startIndex: r, endIndex: n } = s, i = t.contentMatchAt(r).findWrapping(e);
-  if (!i)
+function findWrappingOutside(range, type) {
+  let { parent, startIndex, endIndex } = range;
+  let around = parent.contentMatchAt(startIndex).findWrapping(type);
+  if (!around)
     return null;
-  let o = i.length ? i[0] : e;
-  return t.canReplaceWith(r, n, o) ? i : null;
+  let outer = around.length ? around[0] : type;
+  return parent.canReplaceWith(startIndex, endIndex, outer) ? around : null;
 }
-function me(s, e) {
-  let { parent: t, startIndex: r, endIndex: n } = s, i = t.child(r), o = e.contentMatch.findWrapping(i.type);
-  if (!o)
+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;
-  let a = (o.length ? o[o.length - 1] : e).contentMatch;
-  for (let h = r; a && h < n; h++)
-    a = a.matchType(t.child(h).type);
-  return !a || !a.validEnd ? null : o;
+  return inside;
 }
-function we(s, e, t) {
-  let r = g.empty;
-  for (let o = t.length - 1; o >= 0; o--) {
-    if (r.size) {
-      let l = t[o].type.contentMatch.matchFragment(r);
-      if (!l || !l.validEnd)
+function wrap(tr, range, wrappers) {
+  let content = 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");
     }
-    r = g.from(t[o].type.create(t[o].attrs, r));
+    content = Fragment.from(wrappers[i].type.create(wrappers[i].attrs, content));
   }
-  let n = e.start, i = e.end;
-  s.step(new M(n, i, n, i, new w(r, 0, 0), t.length, !0));
+  let start = range.start, end = range.end;
+  tr.step(new ReplaceAroundStep(start, end, start, end, new Slice(content, 0, 0), wrappers.length, true));
 }
-function ge(s, e, t, r, n) {
-  if (!r.isTextblock)
+function setBlockType(tr, from, to, type, attrs) {
+  if (!type.isTextblock)
     throw new RangeError("Type given to setBlockType should be a textblock");
-  let i = s.steps.length;
-  s.doc.nodesBetween(e, t, (o, l) => {
-    let a = typeof n == "function" ? n(o) : n;
-    if (o.isTextblock && !o.hasMarkup(r, a) && ye(s.doc, s.mapping.slice(i).map(l), r)) {
-      let h = null;
-      if (r.schema.linebreakReplacement) {
-        let d = r.whitespace == "pre", u = !!r.contentMatch.matchType(r.schema.linebreakReplacement);
-        d && !u ? h = !1 : !d && u && (h = !0);
+  let mapFrom = tr.steps.length;
+  tr.doc.nodesBetween(from, to, (node, pos) => {
+    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);
+        if (pre && !supportLinebreak)
+          convertNewlines = false;
+        else if (!pre && supportLinebreak)
+          convertNewlines = true;
       }
-      h === !1 && _(s, o, l, i), $(s, s.mapping.slice(i).map(l, 1), r, void 0, h === null);
-      let p = s.mapping.slice(i), c = p.map(l, 1), f = p.map(l + o.nodeSize, 1);
-      return s.step(new M(c, f, c + 1, f - 1, new w(g.from(r.create(a, null, o.marks)), 0, 0), 1, !0)), h === !0 && Z(s, o, l, i), !1;
+      if (convertNewlines === false)
+        replaceLinebreaks(tr, node, pos, mapFrom);
+      clearIncompatible(tr, tr.mapping.slice(mapFrom).map(pos, 1), type, void 0, 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 Slice(Fragment.from(type.create(attrsHere, null, node.marks)), 0, 0), 1, true));
+      if (convertNewlines === true)
+        replaceNewlines(tr, node, pos, mapFrom);
+      return false;
     }
   });
 }
-function Z(s, e, t, r) {
-  e.forEach((n, i) => {
-    if (n.isText) {
-      let o, l = /\r?\n|\r/g;
-      for (; o = l.exec(n.text); ) {
-        let a = s.mapping.slice(r).map(t + 1 + i + o.index);
-        s.replaceWith(a, a + 1, e.type.schema.linebreakReplacement.create());
+function replaceNewlines(tr, node, pos, mapFrom) {
+  node.forEach((child, offset) => {
+    if (child.isText) {
+      let m, newline = /\r?\n|\r/g;
+      while (m = newline.exec(child.text)) {
+        let start = tr.mapping.slice(mapFrom).map(pos + 1 + offset + m.index);
+        tr.replaceWith(start, start + 1, node.type.schema.linebreakReplacement.create());
       }
     }
   });
 }
-function _(s, e, t, r) {
-  e.forEach((n, i) => {
-    if (n.type == n.type.schema.linebreakReplacement) {
-      let o = s.mapping.slice(r).map(t + 1 + i);
-      s.replaceWith(o, o + 1, e.type.schema.text(`
-`));
+function replaceLinebreaks(tr, node, pos, mapFrom) {
+  node.forEach((child, offset) => {
+    if (child.type == child.type.schema.linebreakReplacement) {
+      let start = tr.mapping.slice(mapFrom).map(pos + 1 + offset);
+      tr.replaceWith(start, start + 1, node.type.schema.text("\n"));
     }
   });
 }
-function ye(s, e, t) {
-  let r = s.resolve(e), n = r.index();
-  return r.parent.canReplaceWith(n, n + 1, t);
+function canChangeType(doc, pos, type) {
+  let $pos = doc.resolve(pos), index = $pos.index();
+  return $pos.parent.canReplaceWith(index, index + 1, type);
 }
-function ke(s, e, t, r, n) {
-  let i = s.doc.nodeAt(e);
-  if (!i)
+function setNodeMarkup(tr, pos, type, attrs, marks) {
+  let node = tr.doc.nodeAt(pos);
+  if (!node)
     throw new RangeError("No node at given position");
-  t || (t = i.type);
-  let o = t.create(r, null, n || i.marks);
-  if (i.isLeaf)
-    return s.replaceWith(e, e + i.nodeSize, o);
-  if (!t.validContent(i.content))
-    throw new RangeError("Invalid content for node type " + t.name);
-  s.step(new M(e, e + i.nodeSize, e + 1, e + i.nodeSize - 1, new w(g.from(o), 0, 0), 1, !0));
+  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 Slice(Fragment.from(newNode), 0, 0), 1, true));
 }
-function Je(s, e, t = 1, r) {
-  let n = s.resolve(e), i = n.depth - t, o = r && r[r.length - 1] || n.parent;
-  if (i < 0 || n.parent.type.spec.isolating || !n.parent.canReplace(n.index(), n.parent.childCount) || !o.type.validContent(n.parent.content.cutByIndex(n.index(), n.parent.childCount)))
-    return !1;
-  for (let h = n.depth - 1, p = t - 2; h > i; h--, p--) {
-    let c = n.node(h), f = n.index(h);
-    if (c.type.spec.isolating)
-      return !1;
-    let d = c.content.cutByIndex(f, c.childCount), u = r && r[p + 1];
-    u && (d = d.replaceChild(0, u.type.create(u.attrs)));
-    let m = r && r[p] || c;
-    if (!c.canReplace(f + 1, c.childCount) || !m.type.validContent(d))
-      return !1;
-  }
-  let l = n.indexAfter(i), a = r && r[0];
-  return n.node(i).canReplaceWith(l, l, a ? a.type : n.node(i + 1).type);
+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), index2 = $pos.index(d);
+    if (node.type.spec.isolating)
+      return false;
+    let rest = node.content.cutByIndex(index2, 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(index2 + 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);
 }
-function ve(s, e, t = 1, r) {
-  let n = s.doc.resolve(e), i = g.empty, o = g.empty;
-  for (let l = n.depth, a = n.depth - t, h = t - 1; l > a; l--, h--) {
-    i = g.from(n.node(l).copy(i));
-    let p = r && r[h];
-    o = g.from(p ? p.type.create(p.attrs, o) : n.node(l).copy(o));
-  }
-  s.step(new v(e, e, new w(i.append(o), t, t), !0));
+function split(tr, pos, depth = 1, typesAfter) {
+  let $pos = tr.doc.resolve(pos), before = Fragment.empty, after = Fragment.empty;
+  for (let d = $pos.depth, e = $pos.depth - depth, i = depth - 1; d > e; d--, i--) {
+    before = Fragment.from($pos.node(d).copy(before));
+    let typeAfter = typesAfter && typesAfter[i];
+    after = Fragment.from(typeAfter ? typeAfter.type.create(typeAfter.attrs, after) : $pos.node(d).copy(after));
+  }
+  tr.step(new ReplaceStep(pos, pos, new Slice(before.append(after), depth, depth), true));
 }
-function Ae(s, e) {
-  let t = s.resolve(e), r = t.index();
-  return j(t.nodeBefore, t.nodeAfter) && t.parent.canReplace(r, r + 1);
+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 xe(s, e) {
-  e.content.size || s.type.compatibleContent(e.type);
-  let t = s.contentMatchAt(s.childCount), { linebreakReplacement: r } = s.type.schema;
-  for (let n = 0; n < e.childCount; n++) {
-    let i = e.child(n), o = i.type == r ? s.type.schema.nodes.text : i.type;
-    if (t = t.matchType(o), !t || !s.type.allowsMarks(i.marks))
-      return !1;
-  }
-  return t.validEnd;
+function canAppendWithSubstitutedLinebreaks(a, b) {
+  if (!b.content.size)
+    a.type.compatibleContent(b.type);
+  let match = a.contentMatchAt(a.childCount);
+  let { linebreakReplacement } = a.type.schema;
+  for (let i = 0; i < b.childCount; i++) {
+    let child = b.child(i);
+    let type = child.type == linebreakReplacement ? a.type.schema.nodes.text : child.type;
+    match = match.matchType(type);
+    if (!match)
+      return false;
+    if (!a.type.allowsMarks(child.marks))
+      return false;
+  }
+  return match.validEnd;
 }
-function j(s, e) {
-  return !!(s && e && !s.isLeaf && xe(s, e));
+function joinable(a, b) {
+  return !!(a && b && !a.isLeaf && canAppendWithSubstitutedLinebreaks(a, b));
 }
-function Be(s, e, t = -1) {
-  let r = s.resolve(e);
-  for (let n = r.depth; ; n--) {
-    let i, o, l = r.index(n);
-    if (n == r.depth ? (i = r.nodeBefore, o = r.nodeAfter) : t > 0 ? (i = r.node(n + 1), l++, o = r.node(n).maybeChild(l)) : (i = r.node(n).maybeChild(l - 1), o = r.node(n + 1)), i && !i.isTextblock && j(i, o) && r.node(n).canReplace(l, l + 1))
-      return e;
-    if (n == 0)
+function joinPoint(doc, pos, dir = -1) {
+  let $pos = doc.resolve(pos);
+  for (let d = $pos.depth; ; d--) {
+    let before, after, index = $pos.index(d);
+    if (d == $pos.depth) {
+      before = $pos.nodeBefore;
+      after = $pos.nodeAfter;
+    } else if (dir > 0) {
+      before = $pos.node(d + 1);
+      index++;
+      after = $pos.node(d).maybeChild(index);
+    } else {
+      before = $pos.node(d).maybeChild(index - 1);
+      after = $pos.node(d + 1);
+    }
+    if (before && !before.isTextblock && joinable(before, after) && $pos.node(d).canReplace(index, index + 1))
+      return pos;
+    if (d == 0)
       break;
-    e = t < 0 ? r.before(n) : r.after(n);
+    pos = dir < 0 ? $pos.before(d) : $pos.after(d);
   }
 }
-function Se(s, e, t) {
-  let r = null, { linebreakReplacement: n } = s.doc.type.schema, i = s.doc.resolve(e - t), o = i.node().type;
-  if (n && o.inlineContent) {
-    let p = o.whitespace == "pre", c = !!o.contentMatch.matchType(n);
-    p && !c ? r = !1 : !p && c && (r = !0);
-  }
-  let l = s.steps.length;
-  if (r === !1) {
-    let p = s.doc.resolve(e + t);
-    _(s, p.node(), p.before(), l);
-  }
-  o.inlineContent && $(s, e + t - 1, o, i.node().contentMatchAt(i.index()), r == null);
-  let a = s.mapping.slice(l), h = a.map(e - t);
-  if (s.step(new v(h, a.map(e + t, -1), w.empty, !0)), r === !0) {
-    let p = s.doc.resolve(h);
-    Z(s, p.node(), p.before(), s.steps.length);
-  }
-  return s;
+function join(tr, pos, depth) {
+  let convertNewlines = null;
+  let { linebreakReplacement } = tr.doc.type.schema;
+  let $before = tr.doc.resolve(pos - depth), beforeType = $before.node().type;
+  if (linebreakReplacement && beforeType.inlineContent) {
+    let pre = beforeType.whitespace == "pre";
+    let supportLinebreak = !!beforeType.contentMatch.matchType(linebreakReplacement);
+    if (pre && !supportLinebreak)
+      convertNewlines = false;
+    else if (!pre && supportLinebreak)
+      convertNewlines = true;
+  }
+  let mapFrom = tr.steps.length;
+  if (convertNewlines === false) {
+    let $after = tr.doc.resolve(pos + depth);
+    replaceLinebreaks(tr, $after.node(), $after.before(), mapFrom);
+  }
+  if (beforeType.inlineContent)
+    clearIncompatible(tr, pos + depth - 1, beforeType, $before.node().contentMatchAt($before.index()), convertNewlines == null);
+  let mapping = tr.mapping.slice(mapFrom), start = mapping.map(pos - depth);
+  tr.step(new ReplaceStep(start, mapping.map(pos + depth, -1), Slice.empty, true));
+  if (convertNewlines === true) {
+    let $full = tr.doc.resolve(start);
+    replaceNewlines(tr, $full.node(), $full.before(), tr.steps.length);
+  }
+  return tr;
 }
-function be(s, e, t) {
-  let r = s.resolve(e);
-  if (r.parent.canReplaceWith(r.index(), r.index(), t))
-    return e;
-  if (r.parentOffset == 0)
-    for (let n = r.depth - 1; n >= 0; n--) {
-      let i = r.index(n);
-      if (r.node(n).canReplaceWith(i, i, t))
-        return r.before(n + 1);
-      if (i > 0)
+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 (r.parentOffset == r.parent.content.size)
-    for (let n = r.depth - 1; n >= 0; n--) {
-      let i = r.indexAfter(n);
-      if (r.node(n).canReplaceWith(i, i, t))
-        return r.after(n + 1);
-      if (i < r.node(n).childCount)
+  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;
 }
-function We(s, e, t) {
-  let r = s.resolve(e);
-  if (!t.content.size)
-    return e;
-  let n = t.content;
-  for (let i = 0; i < t.openStart; i++)
-    n = n.firstChild.content;
-  for (let i = 1; i <= (t.openStart == 0 && t.size ? 2 : 1); i++)
-    for (let o = r.depth; o >= 0; o--) {
-      let l = o == r.depth ? 0 : r.pos <= (r.start(o + 1) + r.end(o + 1)) / 2 ? -1 : 1, a = r.index(o) + (l > 0 ? 1 : 0), h = r.node(o), p = !1;
-      if (i == 1)
-        p = h.canReplace(a, a, n);
-      else {
-        let c = h.contentMatchAt(a).findWrapping(n.firstChild.type);
-        p = c && h.canReplaceWith(a, a, c[0]);
+function dropPoint(doc, pos, slice) {
+  let $pos = doc.resolve(pos);
+  if (!slice.content.size)
+    return pos;
+  let content = slice.content;
+  for (let i = 0; i < slice.openStart; i++)
+    content = content.firstChild.content;
+  for (let pass = 1; pass <= (slice.openStart == 0 && slice.size ? 2 : 1); pass++) {
+    for (let d = $pos.depth; d >= 0; d--) {
+      let bias = d == $pos.depth ? 0 : $pos.pos <= ($pos.start(d + 1) + $pos.end(d + 1)) / 2 ? -1 : 1;
+      let insertPos = $pos.index(d) + (bias > 0 ? 1 : 0);
+      let parent = $pos.node(d), fits = false;
+      if (pass == 1) {
+        fits = parent.canReplace(insertPos, insertPos, content);
+      } else {
+        let wrapping = parent.contentMatchAt(insertPos).findWrapping(content.firstChild.type);
+        fits = wrapping && parent.canReplaceWith(insertPos, insertPos, wrapping[0]);
       }
-      if (p)
-        return l == 0 ? r.pos : l < 0 ? r.before(o + 1) : r.after(o + 1);
+      if (fits)
+        return bias == 0 ? $pos.pos : bias < 0 ? $pos.before(d + 1) : $pos.after(d + 1);
     }
+  }
   return null;
 }
-function Me(s, e, t = e, r = w.empty) {
-  if (e == t && !r.size)
+function replaceStep(doc, from, to = from, slice = Slice.empty) {
+  if (from == to && !slice.size)
     return null;
-  let n = s.resolve(e), i = s.resolve(t);
-  return ee(n, i, r) ? new v(e, t, r) : new Ce(n, i, r).fit();
+  let $from = doc.resolve(from), $to = doc.resolve(to);
+  if (fitsTrivially($from, $to, slice))
+    return new ReplaceStep(from, to, slice);
+  return new Fitter($from, $to, slice).fit();
 }
-function ee(s, e, t) {
-  return !t.openStart && !t.openEnd && s.start() == e.start() && s.parent.canReplace(s.index(), e.index(), t.content);
+function fitsTrivially($from, $to, slice) {
+  return !slice.openStart && !slice.openEnd && $from.start() == $to.start() && $from.parent.canReplace($from.index(), $to.index(), slice.content);
 }
-class Ce {
-  constructor(e, t, r) {
-    this.$from = e, this.$to = t, this.unplaced = r, this.frontier = [], this.placed = g.empty;
-    for (let n = 0; n <= e.depth; n++) {
-      let i = e.node(n);
+class Fitter {
+  constructor($from, $to, unplaced) {
+    this.$from = $from;
+    this.$to = $to;
+    this.unplaced = unplaced;
+    this.frontier = [];
+    this.placed = Fragment.empty;
+    for (let i = 0; i <= $from.depth; i++) {
+      let node = $from.node(i);
       this.frontier.push({
-        type: i.type,
-        match: i.contentMatchAt(e.indexAfter(n))
+        type: node.type,
+        match: node.contentMatchAt($from.indexAfter(i))
       });
     }
-    for (let n = e.depth; n > 0; n--)
-      this.placed = g.from(e.node(n).copy(this.placed));
+    for (let i = $from.depth; i > 0; i--)
+      this.placed = Fragment.from($from.node(i).copy(this.placed));
   }
   get depth() {
     return this.frontier.length - 1;
   }
   fit() {
-    for (; this.unplaced.size; ) {
-      let h = this.findFittable();
-      h ? this.placeNodes(h) : this.openMore() || this.dropNode();
+    while (this.unplaced.size) {
+      let fit = this.findFittable();
+      if (fit)
+        this.placeNodes(fit);
+      else
+        this.openMore() || this.dropNode();
     }
-    let e = this.mustMoveInline(), t = this.placed.size - this.depth - this.$from.depth, r = this.$from, n = this.close(e < 0 ? this.$to : r.doc.resolve(e));
-    if (!n)
+    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;
-    let i = this.placed, o = r.depth, l = n.depth;
-    for (; o && l && i.childCount == 1; )
-      i = i.firstChild.content, o--, l--;
-    let a = new w(i, o, l);
-    return e > -1 ? new M(r.pos, e, this.$to.pos, this.$to.end(), a, t) : a.size || r.pos != this.$to.pos ? new v(r.pos, n.pos, a) : null;
+    let content = this.placed, openStart = $from.depth, openEnd = $to.depth;
+    while (openStart && openEnd && content.childCount == 1) {
+      content = content.firstChild.content;
+      openStart--;
+      openEnd--;
+    }
+    let slice = new Slice(content, openStart, openEnd);
+    if (moveInline > -1)
+      return new ReplaceAroundStep($from.pos, moveInline, this.$to.pos, this.$to.end(), slice, placedSize);
+    if (slice.size || $from.pos != this.$to.pos)
+      return new ReplaceStep($from.pos, $to.pos, slice);
+    return null;
   }
   // Find a position on the start spine of `this.unplaced` that has
   // content that can be moved somewhere on the frontier. Returns two
   // depths, one for the slice and one for the frontier.
   findFittable() {
-    let e = this.unplaced.openStart;
-    for (let t = this.unplaced.content, r = 0, n = this.unplaced.openEnd; r < e; r++) {
-      let i = t.firstChild;
-      if (t.childCount > 1 && (n = 0), i.type.spec.isolating && n <= r) {
-        e = r;
+    let startDepth = this.unplaced.openStart;
+    for (let cur = this.unplaced.content, d = 0, openEnd = this.unplaced.openEnd; d < startDepth; d++) {
+      let node = cur.firstChild;
+      if (cur.childCount > 1)
+        openEnd = 0;
+      if (node.type.spec.isolating && openEnd <= d) {
+        startDepth = d;
         break;
       }
-      t = i.content;
+      cur = node.content;
     }
-    for (let t = 1; t <= 2; t++)
-      for (let r = t == 1 ? e : this.unplaced.openStart; r >= 0; r--) {
-        let n, i = null;
-        r ? (i = W(this.unplaced.content, r - 1).firstChild, n = i.content) : n = this.unplaced.content;
-        let o = n.firstChild;
-        for (let l = this.depth; l >= 0; l--) {
-          let { type: a, match: h } = this.frontier[l], p, c = null;
-          if (t == 1 && (o ? h.matchType(o.type) || (c = h.fillBefore(g.from(o), !1)) : i && a.compatibleContent(i.type)))
-            return { sliceDepth: r, frontierDepth: l, parent: i, inject: c };
-          if (t == 2 && o && (p = h.findWrapping(o.type)))
-            return { sliceDepth: r, frontierDepth: l, parent: i, wrap: p };
-          if (i && h.matchType(i.type))
+    for (let pass = 1; pass <= 2; pass++) {
+      for (let sliceDepth = pass == 1 ? startDepth : this.unplaced.openStart; sliceDepth >= 0; sliceDepth--) {
+        let fragment, parent = null;
+        if (sliceDepth) {
+          parent = contentAt(this.unplaced.content, sliceDepth - 1).firstChild;
+          fragment = parent.content;
+        } else {
+          fragment = this.unplaced.content;
+        }
+        let first = fragment.firstChild;
+        for (let frontierDepth = this.depth; frontierDepth >= 0; frontierDepth--) {
+          let { type, match } = this.frontier[frontierDepth], wrap2, inject = null;
+          if (pass == 1 && (first ? match.matchType(first.type) || (inject = match.fillBefore(Fragment.from(first), false)) : parent && type.compatibleContent(parent.type)))
+            return { sliceDepth, frontierDepth, parent, inject };
+          else if (pass == 2 && first && (wrap2 = match.findWrapping(first.type)))
+            return { sliceDepth, frontierDepth, parent, wrap: wrap2 };
+          if (parent && match.matchType(parent.type))
             break;
         }
       }
+    }
   }
   openMore() {
-    let { content: e, openStart: t, openEnd: r } = this.unplaced, n = W(e, t);
-    return !n.childCount || n.firstChild.isLeaf ? !1 : (this.unplaced = new w(e, t + 1, Math.max(r, n.size + t >= e.size - r ? t + 1 : 0)), !0);
+    let { content, openStart, openEnd } = this.unplaced;
+    let inner = contentAt(content, openStart);
+    if (!inner.childCount || inner.firstChild.isLeaf)
+      return false;
+    this.unplaced = new Slice(content, openStart + 1, Math.max(openEnd, inner.size + openStart >= content.size - openEnd ? openStart + 1 : 0));
+    return true;
   }
   dropNode() {
-    let { content: e, openStart: t, openEnd: r } = this.unplaced, n = W(e, t);
-    if (n.childCount <= 1 && t > 0) {
-      let i = e.size - t <= t + n.size;
-      this.unplaced = new w(O(e, t - 1, 1), t - 1, i ? t - 1 : r);
-    } else
-      this.unplaced = new w(O(e, t, 1), t, r);
+    let { content, openStart, openEnd } = this.unplaced;
+    let inner = contentAt(content, openStart);
+    if (inner.childCount <= 1 && openStart > 0) {
+      let openAtEnd = content.size - openStart <= openStart + inner.size;
+      this.unplaced = new Slice(dropFromFragment(content, openStart - 1, 1), openStart - 1, openAtEnd ? openStart - 1 : openEnd);
+    } else {
+      this.unplaced = new Slice(dropFromFragment(content, openStart, 1), openStart, openEnd);
+    }
   }
   // Move content from the unplaced slice at `sliceDepth` to the
   // frontier node at `frontierDepth`. Close that frontier node when
   // applicable.
-  placeNodes({ sliceDepth: e, frontierDepth: t, parent: r, inject: n, wrap: i }) {
-    for (; this.depth > t; )
+  placeNodes({ sliceDepth, frontierDepth, parent, inject, wrap: wrap2 }) {
+    while (this.depth > frontierDepth)
       this.closeFrontierNode();
-    if (i)
-      for (let m = 0; m < i.length; m++)
-        this.openFrontierNode(i[m]);
-    let o = this.unplaced, l = r ? r.content : o.content, a = o.openStart - e, h = 0, p = [], { match: c, type: f } = this.frontier[t];
-    if (n) {
-      for (let m = 0; m < n.childCount; m++)
-        p.push(n.child(m));
-      c = c.matchFragment(n);
+    if (wrap2)
+      for (let i = 0; i < wrap2.length; i++)
+        this.openFrontierNode(wrap2[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);
     }
-    let d = l.size + e - (o.content.size - o.openEnd);
-    for (; h < l.childCount; ) {
-      let m = l.child(h), x = c.matchType(m.type);
-      if (!x)
+    let openEndCount = fragment.size + sliceDepth - (slice.content.size - slice.openEnd);
+    while (taken < fragment.childCount) {
+      let next = fragment.child(taken), matches = match.matchType(next.type);
+      if (!matches)
         break;
-      h++, (h > 1 || a == 0 || m.content.size) && (c = x, p.push(te(m.mark(f.allowedMarks(m.marks)), h == 1 ? a : 0, h == l.childCount ? d : -1)));
+      taken++;
+      if (taken > 1 || openStart == 0 || next.content.size) {
+        match = matches;
+        add.push(closeNodeStart(next.mark(type.allowedMarks(next.marks)), taken == 1 ? openStart : 0, taken == fragment.childCount ? openEndCount : -1));
+      }
     }
-    let u = h == l.childCount;
-    u || (d = -1), this.placed = F(this.placed, t, g.from(p)), this.frontier[t].match = c, u && d < 0 && r && r.type == this.frontier[this.depth].type && this.frontier.length > 1 && this.closeFrontierNode();
-    for (let m = 0, x = l; m < d; m++) {
-      let I = x.lastChild;
-      this.frontier.push({ type: I.type, match: I.contentMatchAt(I.childCount) }), x = I.content;
+    let toEnd = taken == fragment.childCount;
+    if (!toEnd)
+      openEndCount = -1;
+    this.placed = addToFragment(this.placed, frontierDepth, Fragment.from(add));
+    this.frontier[frontierDepth].match = match;
+    if (toEnd && openEndCount < 0 && parent && parent.type == this.frontier[this.depth].type && this.frontier.length > 1)
+      this.closeFrontierNode();
+    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;
     }
-    this.unplaced = u ? e == 0 ? w.empty : new w(O(o.content, e - 1, 1), e - 1, d < 0 ? o.openEnd : e - 1) : new w(O(o.content, e, h), o.openStart, o.openEnd);
+    this.unplaced = !toEnd ? new Slice(dropFromFragment(slice.content, sliceDepth, taken), slice.openStart, slice.openEnd) : sliceDepth == 0 ? Slice.empty : new Slice(dropFromFragment(slice.content, sliceDepth - 1, 1), sliceDepth - 1, openEndCount < 0 ? slice.openEnd : sliceDepth - 1);
   }
   mustMoveInline() {
     if (!this.$to.parent.isTextblock)
       return -1;
-    let e = this.frontier[this.depth], t;
-    if (!e.type.isTextblock || !D(this.$to, this.$to.depth, e.type, e.match, !1) || this.$to.depth == this.depth && (t = this.findCloseLevel(this.$to)) && t.depth == this.depth)
+    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: r } = this.$to, n = this.$to.after(r);
-    for (; r > 1 && n == this.$to.end(--r); )
-      ++n;
-    return n;
-  }
-  findCloseLevel(e) {
-    e: for (let t = Math.min(this.depth, e.depth); t >= 0; t--) {
-      let { match: r, type: n } = this.frontier[t], i = t < e.depth && e.end(t + 1) == e.pos + (e.depth - (t + 1)), o = D(e, t, n, r, i);
-      if (o) {
-        for (let l = t - 1; l >= 0; l--) {
-          let { match: a, type: h } = this.frontier[l], p = D(e, l, h, a, !0);
-          if (!p || p.childCount)
-            continue e;
-        }
-        return { depth: t, fit: o, move: i ? e.doc.resolve(e.after(t + 1)) : e };
+    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: match2, type: type2 } = this.frontier[d];
+        let matches = contentAfterFits($to, d, type2, match2, true);
+        if (!matches || matches.childCount)
+          continue scan;
       }
+      return { depth: i, fit, move: dropInner ? $to.doc.resolve($to.after(i + 1)) : $to };
     }
   }
-  close(e) {
-    let t = this.findCloseLevel(e);
-    if (!t)
+  close($to) {
+    let close = this.findCloseLevel($to);
+    if (!close)
       return null;
-    for (; this.depth > t.depth; )
+    while (this.depth > close.depth)
       this.closeFrontierNode();
-    t.fit.childCount && (this.placed = F(this.placed, t.depth, t.fit)), e = t.move;
-    for (let r = t.depth + 1; r <= e.depth; r++) {
-      let n = e.node(r), i = n.type.contentMatch.fillBefore(n.content, !0, e.index(r));
-      this.openFrontierNode(n.type, n.attrs, i);
+    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 e;
+    return $to;
   }
-  openFrontierNode(e, t = null, r) {
-    let n = this.frontier[this.depth];
-    n.match = n.match.matchType(e), this.placed = F(this.placed, this.depth, g.from(e.create(t, r))), this.frontier.push({ type: e, match: e.contentMatch });
+  openFrontierNode(type, attrs = null, content) {
+    let top = this.frontier[this.depth];
+    top.match = top.match.matchType(type);
+    this.placed = addToFragment(this.placed, this.depth, Fragment.from(type.create(attrs, content)));
+    this.frontier.push({ type, match: type.contentMatch });
   }
   closeFrontierNode() {
-    let t = this.frontier.pop().match.fillBefore(g.empty, !0);
-    t.childCount && (this.placed = F(this.placed, this.frontier.length, t));
+    let open = this.frontier.pop();
+    let add = open.match.fillBefore(Fragment.empty, true);
+    if (add.childCount)
+      this.placed = addToFragment(this.placed, this.frontier.length, add);
   }
 }
-function O(s, e, t) {
-  return e == 0 ? s.cutByIndex(t, s.childCount) : s.replaceChild(0, s.firstChild.copy(O(s.firstChild.content, e - 1, t)));
+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 F(s, e, t) {
-  return e == 0 ? s.append(t) : s.replaceChild(s.childCount - 1, s.lastChild.copy(F(s.lastChild.content, e - 1, t)));
+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 W(s, e) {
-  for (let t = 0; t < e; t++)
-    s = s.firstChild.content;
-  return s;
+function contentAt(fragment, depth) {
+  for (let i = 0; i < depth; i++)
+    fragment = fragment.firstChild.content;
+  return fragment;
 }
-function te(s, e, t) {
-  if (e <= 0)
-    return s;
-  let r = s.content;
-  return e > 1 && (r = r.replaceChild(0, te(r.firstChild, e - 1, r.childCount == 1 ? t - 1 : 0))), e > 0 && (r = s.type.contentMatch.fillBefore(r).append(r), t <= 0 && (r = r.append(s.type.contentMatch.matchFragment(r).fillBefore(g.empty, !0)))), s.copy(r);
+function closeNodeStart(node, openStart, openEnd) {
+  if (openStart <= 0)
+    return node;
+  let frag = node.content;
+  if (openStart > 1)
+    frag = frag.replaceChild(0, closeNodeStart(frag.firstChild, openStart - 1, frag.childCount == 1 ? openEnd - 1 : 0));
+  if (openStart > 0) {
+    frag = node.type.contentMatch.fillBefore(frag).append(frag);
+    if (openEnd <= 0)
+      frag = frag.append(node.type.contentMatch.matchFragment(frag).fillBefore(Fragment.empty, true));
+  }
+  return node.copy(frag);
 }
-function D(s, e, t, r, n) {
-  let i = s.node(e), o = n ? s.indexAfter(e) : s.index(e);
-  if (o == i.childCount && !t.compatibleContent(i.type))
+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 l = r.fillBefore(i.content, !0, o);
-  return l && !Ne(t, i.content, o) ? l : null;
+  let fit = match.fillBefore(node.content, true, index);
+  return fit && !invalidMarks(type, node.content, index) ? fit : null;
 }
-function Ne(s, e, t) {
-  for (let r = t; r < e.childCount; r++)
-    if (!s.allowsMarks(e.child(r).marks))
-      return !0;
-  return !1;
+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 Ie(s) {
-  return s.spec.defining || s.spec.definingForContent;
+function definesContent(type) {
+  return type.spec.defining || type.spec.definingForContent;
 }
-function Re(s, e, t, r) {
-  if (!r.size)
-    return s.deleteRange(e, t);
-  let n = s.doc.resolve(e), i = s.doc.resolve(t);
-  if (ee(n, i, r))
-    return s.step(new v(e, t, r));
-  let o = ne(n, s.doc.resolve(t));
-  o[o.length - 1] == 0 && o.pop();
-  let l = -(n.depth + 1);
-  o.unshift(l);
-  for (let f = n.depth, d = n.pos - 1; f > 0; f--, d--) {
-    let u = n.node(f).type.spec;
-    if (u.defining || u.definingAsContext || u.isolating)
+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));
+  if (targetDepths[targetDepths.length - 1] == 0)
+    targetDepths.pop();
+  let preferredTarget = -($from.depth + 1);
+  targetDepths.unshift(preferredTarget);
+  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;
-    o.indexOf(f) > -1 ? l = f : n.before(f) == d && o.splice(1, 0, -f);
-  }
-  let a = o.indexOf(l), h = [], p = r.openStart;
-  for (let f = r.content, d = 0; ; d++) {
-    let u = f.firstChild;
-    if (h.push(u), d == r.openStart)
+    if (targetDepths.indexOf(d) > -1)
+      preferredTarget = d;
+    else if ($from.before(d) == pos)
+      targetDepths.splice(1, 0, -d);
+  }
+  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;
-    f = u.content;
+    content = node.content;
   }
-  for (let f = p - 1; f >= 0; f--) {
-    let d = h[f], u = Ie(d.type);
-    if (u && !d.sameMarkup(n.node(Math.abs(l) - 1)))
-      p = f;
-    else if (u || !d.type.isTextblock)
+  for (let d = preferredDepth - 1; d >= 0; d--) {
+    let leftNode = leftNodes[d], def = definesContent(leftNode.type);
+    if (def && !leftNode.sameMarkup($from.node(Math.abs(preferredTarget) - 1)))
+      preferredDepth = d;
+    else if (def || !leftNode.type.isTextblock)
       break;
   }
-  for (let f = r.openStart; f >= 0; f--) {
-    let d = (f + p + 1) % (r.openStart + 1), u = h[d];
-    if (u)
-      for (let m = 0; m < o.length; m++) {
-        let x = o[(m + a) % o.length], I = !0;
-        x < 0 && (I = !1, x = -x);
-        let ie = n.node(x - 1), G = n.index(x - 1);
-        if (ie.canReplaceWith(G, G, u.type, u.marks))
-          return s.replace(n.before(x), I ? i.after(x) : t, new w(re(r.content, 0, r.openStart, d), d, r.openEnd));
+  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++) {
+      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 Slice(closeFragment(slice.content, 0, slice.openStart, openDepth), openDepth, slice.openEnd));
+    }
   }
-  let c = s.steps.length;
-  for (let f = o.length - 1; f >= 0 && (s.replace(e, t, r), !(s.steps.length > c)); f--) {
-    let d = o[f];
-    d < 0 || (e = n.before(d), t = i.after(d));
+  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 re(s, e, t, r, n) {
-  if (e < t) {
-    let i = s.firstChild;
-    s = s.replaceChild(0, i.copy(re(i.content, e + 1, t, r, i)));
+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 (e > r) {
-    let i = n.contentMatchAt(0), o = i.fillBefore(s).append(s);
-    s = o.append(i.matchFragment(o).fillBefore(g.empty, !0));
+  if (depth > newOpen) {
+    let match = parent.contentMatchAt(0);
+    let start = match.fillBefore(fragment).append(fragment);
+    fragment = start.append(match.matchFragment(start).fillBefore(Fragment.empty, true));
   }
-  return s;
+  return fragment;
 }
-function Te(s, e, t, r) {
-  if (!r.isInline && e == t && s.doc.resolve(e).parent.content.size) {
-    let n = be(s.doc, e, r.type);
-    n != null && (e = t = n);
+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;
   }
-  s.replaceRange(e, t, new w(g.from(r), 0, 0));
+  tr.replaceRange(from, to, new Slice(Fragment.from(node), 0, 0));
 }
-function Ee(s, e, t) {
-  let r = s.doc.resolve(e), n = s.doc.resolve(t), i = ne(r, n);
-  for (let o = 0; o < i.length; o++) {
-    let l = i[o], a = o == i.length - 1;
-    if (a && l == 0 || r.node(l).type.contentMatch.validEnd)
-      return s.delete(r.start(l), n.end(l));
-    if (l > 0 && (a || r.node(l - 1).canReplace(r.index(l - 1), n.indexAfter(l - 1))))
-      return s.delete(r.before(l), n.after(l));
-  }
-  for (let o = 1; o <= r.depth && o <= n.depth; o++)
-    if (e - r.start(o) == r.depth - o && t > r.end(o) && n.end(o) - t != n.depth - o && r.start(o - 1) == n.start(o - 1) && r.node(o - 1).canReplace(r.index(o - 1), n.index(o - 1)))
-      return s.delete(r.before(o), t);
-  s.delete(e, t);
+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 && $from.start(d - 1) == $to.start(d - 1) && $from.node(d - 1).canReplace($from.index(d - 1), $to.index(d - 1)))
+      return tr.delete($from.before(d), to);
+  }
+  tr.delete(from, to);
 }
-function ne(s, e) {
-  let t = [], r = Math.min(s.depth, e.depth);
-  for (let n = r; n >= 0; n--) {
-    let i = s.start(n);
-    if (i < s.pos - (s.depth - n) || e.end(n) > e.pos + (e.depth - n) || s.node(n).type.spec.isolating || e.node(n).type.spec.isolating)
+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;
-    (i == e.start(n) || n == s.depth && n == e.depth && s.parent.inlineContent && e.parent.inlineContent && n && e.start(n - 1) == i - 1) && t.push(n);
+    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 t;
+  return result;
 }
-class T extends k {
+class AttrStep extends Step {
   /**
   Construct an attribute step.
   */
-  constructor(e, t, r) {
-    super(), this.pos = e, this.attr = t, this.value = r;
-  }
-  apply(e) {
-    let t = e.nodeAt(this.pos);
-    if (!t)
-      return y.fail("No node at attribute step's position");
-    let r = /* @__PURE__ */ Object.create(null);
-    for (let i in t.attrs)
-      r[i] = t.attrs[i];
-    r[this.attr] = this.value;
-    let n = t.type.create(r, null, t.marks);
-    return y.fromReplace(e, this.pos, this.pos + 1, new w(g.from(n), 0, t.isLeaf ? 0 : 1));
+  constructor(pos, attr, 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 = /* @__PURE__ */ Object.create(null);
+    for (let name in node.attrs)
+      attrs[name] = node.attrs[name];
+    attrs[this.attr] = this.value;
+    let updated = node.type.create(attrs, null, node.marks);
+    return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
   }
   getMap() {
-    return S.empty;
+    return StepMap.empty;
   }
-  invert(e) {
-    return new T(this.pos, this.attr, e.nodeAt(this.pos).attrs[this.attr]);
+  invert(doc) {
+    return new AttrStep(this.pos, this.attr, doc.nodeAt(this.pos).attrs[this.attr]);
   }
-  map(e) {
-    let t = e.mapResult(this.pos, 1);
-    return t.deletedAfter ? null : new T(t.pos, this.attr, this.value);
+  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(e, t) {
-    if (typeof t.pos != "number" || typeof t.attr != "string")
+  static fromJSON(schema, json) {
+    if (typeof json.pos != "number" || typeof json.attr != "string")
       throw new RangeError("Invalid input for AttrStep.fromJSON");
-    return new T(t.pos, t.attr, t.value);
+    return new AttrStep(json.pos, json.attr, json.value);
   }
 }
-k.jsonID("attr", T);
-class z extends k {
+Step.jsonID("attr", AttrStep);
+class DocAttrStep extends Step {
   /**
   Construct an attribute step.
   */
-  constructor(e, t) {
-    super(), this.attr = e, this.value = t;
+  constructor(attr, value) {
+    super();
+    this.attr = attr;
+    this.value = value;
   }
-  apply(e) {
-    let t = /* @__PURE__ */ Object.create(null);
-    for (let n in e.attrs)
-      t[n] = e.attrs[n];
-    t[this.attr] = this.value;
-    let r = e.type.create(t, e.content, e.marks);
-    return y.ok(r);
+  apply(doc) {
+    let attrs = /* @__PURE__ */ 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 S.empty;
+    return StepMap.empty;
   }
-  invert(e) {
-    return new z(this.attr, e.attrs[this.attr]);
+  invert(doc) {
+    return new DocAttrStep(this.attr, doc.attrs[this.attr]);
   }
-  map(e) {
+  map(mapping) {
     return this;
   }
   toJSON() {
     return { stepType: "docAttr", attr: this.attr, value: this.value };
   }
-  static fromJSON(e, t) {
-    if (typeof t.attr != "string")
+  static fromJSON(schema, json) {
+    if (typeof json.attr != "string")
       throw new RangeError("Invalid input for DocAttrStep.fromJSON");
-    return new z(t.attr, t.value);
+    return new DocAttrStep(json.attr, json.value);
   }
 }
-k.jsonID("docAttr", z);
-let E = class extends Error {
+Step.jsonID("docAttr", DocAttrStep);
+let TransformError = class extends Error {
 };
-E = function s(e) {
-  let t = Error.call(this, e);
-  return t.__proto__ = s.prototype, t;
+TransformError = function TransformError2(message) {
+  let err = Error.call(this, message);
+  err.__proto__ = TransformError2.prototype;
+  return err;
 };
-E.prototype = Object.create(Error.prototype);
-E.prototype.constructor = E;
-E.prototype.name = "TransformError";
-class De {
+TransformError.prototype = Object.create(Error.prototype);
+TransformError.prototype.constructor = TransformError;
+TransformError.prototype.name = "TransformError";
+class Transform {
   /**
   Create a transform that starts with the given document.
   */
-  constructor(e) {
-    this.doc = e, this.steps = [], this.docs = [], this.mapping = new A();
+  constructor(doc) {
+    this.doc = doc;
+    this.steps = [];
+    this.docs = [];
+    this.mapping = new Mapping();
   }
   /**
   The starting document.
@@ -1284,19 +1576,21 @@ class De {
   Apply a new step in this transform, saving the result. Throws an
   error when the step fails.
   */
-  step(e) {
-    let t = this.maybeStep(e);
-    if (t.failed)
-      throw new E(t.failed);
+  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(e) {
-    let t = e.apply(this.doc);
-    return t.failed || this.addStep(e, t.doc), t;
+  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
@@ -1308,35 +1602,40 @@ class De {
   /**
   @internal
   */
-  addStep(e, t) {
-    this.docs.push(this.doc), this.steps.push(e), this.mapping.appendMap(e.getMap()), this.doc = t;
+  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(e, t = e, r = w.empty) {
-    let n = Me(this.doc, e, t, r);
-    return n && this.step(n), this;
+  replace(from, to = from, slice = 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(e, t, r) {
-    return this.replace(e, t, new w(g.from(r), 0, 0));
+  replaceWith(from, to, content) {
+    return this.replace(from, to, new Slice(Fragment.from(content), 0, 0));
   }
   /**
   Delete the content between the given positions.
   */
-  delete(e, t) {
-    return this.replace(e, t, w.empty);
+  delete(from, to) {
+    return this.replace(from, to, Slice.empty);
   }
   /**
   Insert the given content at the given position.
   */
-  insert(e, t) {
-    return this.replaceWith(e, e, t);
+  insert(pos, content) {
+    return this.replaceWith(pos, pos, content);
   }
   /**
   Replace a range of the document with a given slice, using
@@ -1357,8 +1656,9 @@ class De {
   range, and is useful in situations where you need more precise
   control over what happens.
   */
-  replaceRange(e, t, r) {
-    return Re(this, e, t, r), this;
+  replaceRange(from, to, slice) {
+    replaceRange(this, from, to, slice);
+    return this;
   }
   /**
   Replace the given range with a node, but use `from` and `to` as
@@ -1369,15 +1669,17 @@ class De {
   completely covers a parent node, this method may completely replace
   that parent node.
   */
-  replaceRangeWith(e, t, r) {
-    return Te(this, e, t, r), this;
+  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(e, t) {
-    return Ee(this, e, t), this;
+  deleteRange(from, to) {
+    deleteRange(this, from, to);
+    return this;
   }
   /**
   Split the content in the given range off from its parent, if there
@@ -1386,74 +1688,85 @@ class De {
   [`liftTarget`](https://prosemirror.net/docs/ref/#transform.liftTarget) to compute `target`, to make
   sure the lift is valid.
   */
-  lift(e, t) {
-    return de(this, e, t), this;
+  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(e, t = 1) {
-    return Se(this, e, t), this;
+  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(e, t) {
-    return we(this, e, t), this;
+  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(e, t = e, r, n = null) {
-    return ge(this, e, t, r, n), this;
+  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(e, t, r = null, n) {
-    return ke(this, e, t, r, n), this;
+  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.
   The `pos` addresses the document content. Use `setDocAttribute`
   to set attributes on the document itself.
   */
-  setNodeAttribute(e, t, r) {
-    return this.step(new T(e, t, r)), this;
+  setNodeAttribute(pos, attr, value) {
+    this.step(new AttrStep(pos, attr, value));
+    return this;
   }
   /**
   Set a single attribute on the document to a new value.
   */
-  setDocAttribute(e, t) {
-    return this.step(new z(e, t)), this;
+  setDocAttribute(attr, value) {
+    this.step(new DocAttrStep(attr, value));
+    return this;
   }
   /**
   Add a mark to the node at position `pos`.
   */
-  addNodeMark(e, t) {
-    return this.step(new N(e, t)), this;
+  addNodeMark(pos, mark) {
+    this.step(new AddNodeMarkStep(pos, mark));
+    return this;
   }
   /**
   Remove a mark (or all marks of the given type) from the node at
   position `pos`.
   */
-  removeNodeMark(e, t) {
-    let r = this.doc.nodeAt(e);
-    if (!r)
-      throw new RangeError("No node at position " + e);
-    if (t instanceof se)
-      t.isInSet(r.marks) && this.step(new R(e, t));
-    else {
-      let n = r.marks, i, o = [];
-      for (; i = t.isInSet(n); )
-        o.push(new R(e, i)), n = i.removeFromSet(n);
-      for (let l = o.length - 1; l >= 0; l--)
-        this.step(o[l]);
+  removeNodeMark(pos, mark) {
+    let node = this.doc.nodeAt(pos);
+    if (!node)
+      throw new RangeError("No node at position " + pos);
+    if (mark instanceof Mark) {
+      if (mark.isInSet(node.marks))
+        this.step(new RemoveNodeMarkStep(pos, mark));
+    } else {
+      let set = node.marks, found, steps = [];
+      while (found = mark.isInSet(set)) {
+        steps.push(new RemoveNodeMarkStep(pos, found));
+        set = found.removeFromSet(set);
+      }
+      for (let i = steps.length - 1; i >= 0; i--)
+        this.step(steps[i]);
     }
     return this;
   }
@@ -1464,14 +1777,16 @@ class De {
   This can be changed by passing an array of types and attributes to
   use after the split (with the outermost nodes coming first).
   */
-  split(e, t = 1, r) {
-    return ve(this, e, t, r), this;
+  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(e, t, r) {
-    return pe(this, e, t, r), this;
+  addMark(from, to, mark) {
+    addMark(this, from, to, mark);
+    return this;
   }
   /**
   Remove marks from inline nodes between `from` and `to`. When
@@ -1479,8 +1794,9 @@ class De {
   a mark type, remove all marks of that type. When it is null,
   remove all marks of any type.
   */
-  removeMark(e, t, r) {
-    return fe(this, e, t, r), this;
+  removeMark(from, to, mark) {
+    removeMark(this, from, to, mark);
+    return this;
   }
   /**
   Removes all marks and nodes from the content of the node at
@@ -1488,20 +1804,21 @@ class De {
   an optional starting [content match](https://prosemirror.net/docs/ref/#model.ContentMatch) as
   third argument.
   */
-  clearIncompatible(e, t, r) {
-    return $(this, e, t, r), this;
+  clearIncompatible(pos, parentType, match) {
+    clearIncompatible(this, pos, parentType, match);
+    return this;
   }
 }
 export {
-  A as M,
-  v as R,
-  De as T,
-  Je as a,
-  M as b,
-  Ae as c,
-  We as d,
-  ze as f,
-  Be as j,
-  Fe as l,
-  Me as r
+  Mapping as M,
+  ReplaceStep as R,
+  Transform as T,
+  canSplit as a,
+  ReplaceAroundStep as b,
+  canJoin as c,
+  dropPoint as d,
+  findWrapping as f,
+  joinPoint as j,
+  liftTarget as l,
+  replaceStep as r
 };