feat: add undo/redo to rich text editor

Add @milkdown/plugin-history to the Milkdown editor, enabling undo/redo
via Mod-z/Mod-Shift-z keyboard shortcuts. Also adds ↩/↪ toolbar buttons
visible only in rich mode.

milkdown-entry.js

···
 export { listener, listenerCtx } from '@milkdown/kit/plugin/listener';
 export { TooltipProvider, tooltipFactory } from '@milkdown/kit/plugin/tooltip';
 export { callCommand } from '@milkdown/kit/utils';
+export { history, undoCommand, redoCommand } from '@milkdown/plugin-history';

static/vendor/milkdown.js

···
   for (var name in all2)
     __defProp(target, name, { get: all2[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key3 of __getOwnPropNames(from))
+var __copyProps = (to, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key3 of __getOwnPropNames(from2))
       if (!__hasOwnProp.call(to, key3) && key3 !== except)
-        __defProp(to, key3, { get: () => from[key3], enumerable: !(desc = __getOwnPropDesc(from, key3)) || desc.enumerable });
+        __defProp(to, key3, { get: () => from2[key3], enumerable: !(desc = __getOwnPropDesc(from2, key3)) || desc.enumerable });
   }
   return to;
 };
···
 var Container = class {
   constructor() {
     this.sliceMap = /* @__PURE__ */ new Map();
-    this.get = (slice) => {
-      const context = typeof slice === "string" ? [...this.sliceMap.values()].find((x) => x.type.name === slice) : this.sliceMap.get(slice.id);
+    this.get = (slice2) => {
+      const context = typeof slice2 === "string" ? [...this.sliceMap.values()].find((x) => x.type.name === slice2) : this.sliceMap.get(slice2.id);
       if (!context) {
-        const name = typeof slice === "string" ? slice : slice.name;
+        const name = typeof slice2 === "string" ? slice2 : slice2.name;
         throw contextNotFound(name);
       }
       return context;
     };
-    this.remove = (slice) => {
-      const context = typeof slice === "string" ? [...this.sliceMap.values()].find((x) => x.type.name === slice) : this.sliceMap.get(slice.id);
+    this.remove = (slice2) => {
+      const context = typeof slice2 === "string" ? [...this.sliceMap.values()].find((x) => x.type.name === slice2) : this.sliceMap.get(slice2.id);
       if (!context) return;
       this.sliceMap.delete(context.type.id);
     };
-    this.has = (slice) => {
-      if (typeof slice === "string")
-        return [...this.sliceMap.values()].some((x) => x.type.name === slice);
-      return this.sliceMap.has(slice.id);
+    this.has = (slice2) => {
+      if (typeof slice2 === "string")
+        return [...this.sliceMap.values()].some((x) => x.type.name === slice2);
+      return this.sliceMap.has(slice2.id);
     };
   }
 };
···
     this.read = () => {
       return {
         metadata: this.#meta,
-        injectedSlices: [...this.#injectedSlices].map((slice) => ({
-          name: typeof slice === "string" ? slice : slice.name,
-          value: this.#getSlice(slice)
+        injectedSlices: [...this.#injectedSlices].map((slice2) => ({
+          name: typeof slice2 === "string" ? slice2 : slice2.name,
+          value: this.#getSlice(slice2)
         })),
-        consumedSlices: [...this.#consumedSlices].map((slice) => ({
-          name: typeof slice === "string" ? slice : slice.name,
-          value: this.#getSlice(slice)
+        consumedSlices: [...this.#consumedSlices].map((slice2) => ({
+          name: typeof slice2 === "string" ? slice2 : slice2.name,
+          value: this.#getSlice(slice2)
         })),
         recordedTimers: [...this.#recordedTimers].map(
           ([timer, { duration }]) => ({
···
       return this;
     };
     this.inject = (sliceType, value) => {
-      const slice = sliceType.create(this.#container.sliceMap);
-      if (value != null) slice.set(value);
+      const slice2 = sliceType.create(this.#container.sliceMap);
+      if (value != null) slice2.set(value);
       this.#inspector?.onInject(sliceType);
       return this;
     };
···
       this.#inspector?.onWait(timer, promise);
       return promise;
     };
-    this.waitTimers = async (slice) => {
-      await Promise.all(this.get(slice).map((x) => this.wait(x)));
+    this.waitTimers = async (slice2) => {
+      await Promise.all(this.get(slice2).map((x) => this.wait(x)));
     };
     this.#container = container;
     this.#clock = clock;
···
   // :: (union<Object, OrderedMap>) → OrderedMap
   // Create a new map by prepending the keys in this map that don't
   // appear in `map` before the keys in `map`.
-  prepend: function(map4) {
-    map4 = OrderedMap.from(map4);
-    if (!map4.size) return this;
-    return new OrderedMap(map4.content.concat(this.subtract(map4).content));
+  prepend: function(map5) {
+    map5 = OrderedMap.from(map5);
+    if (!map5.size) return this;
+    return new OrderedMap(map5.content.concat(this.subtract(map5).content));
   },
   // :: (union<Object, OrderedMap>) → OrderedMap
   // Create a new map by appending the keys in this map that don't
   // appear in `map` after the keys in `map`.
-  append: function(map4) {
-    map4 = OrderedMap.from(map4);
-    if (!map4.size) return this;
-    return new OrderedMap(this.subtract(map4).content.concat(map4.content));
+  append: function(map5) {
+    map5 = OrderedMap.from(map5);
+    if (!map5.size) return this;
+    return new OrderedMap(this.subtract(map5).content.concat(map5.content));
   },
   // :: (union<Object, OrderedMap>) → OrderedMap
   // Create a map containing all the keys in this map that don't
   // appear in `map`.
-  subtract: function(map4) {
+  subtract: function(map5) {
     var result = this;
-    map4 = OrderedMap.from(map4);
-    for (var i = 0; i < map4.content.length; i += 2)
-      result = result.remove(map4.content[i]);
+    map5 = OrderedMap.from(map5);
+    for (var i = 0; i < map5.content.length; i += 2)
+      result = result.remove(map5.content[i]);
     return result;
   },
   // :: () → Object
···
   positions (relative to start of this fragment). Doesn't descend
   into a node when the callback returns `false`.
   */
-  nodesBetween(from, to, f, nodeStart = 0, parent) {
+  nodesBetween(from2, to, f, nodeStart = 0, parent) {
     for (let i = 0, pos = 0; pos < to; i++) {
       let child = this.content[i], end = pos + child.nodeSize;
-      if (end > from && f(child, nodeStart + pos, parent || null, i) !== false && child.content.size) {
+      if (end > from2 && f(child, nodeStart + pos, parent || null, i) !== false && child.content.size) {
         let start = pos + 1;
-        child.nodesBetween(Math.max(0, from - start), Math.min(child.content.size, to - start), f, nodeStart + start);
+        child.nodesBetween(Math.max(0, from2 - start), Math.min(child.content.size, to - start), f, nodeStart + start);
       }
       pos = end;
     }
···
   Extract the text between `from` and `to`. See the same method on
   [`Node`](https://prosemirror.net/docs/ref/#model.Node.textBetween).
   */
-  textBetween(from, to, blockSeparator, leafText) {
+  textBetween(from2, to, blockSeparator, leafText) {
     let text4 = "", first = true;
-    this.nodesBetween(from, to, (node2, pos) => {
-      let nodeText = node2.isText ? node2.text.slice(Math.max(from, pos) - pos, to - pos) : !node2.isLeaf ? "" : leafText ? typeof leafText === "function" ? leafText(node2) : leafText : node2.type.spec.leafText ? node2.type.spec.leafText(node2) : "";
+    this.nodesBetween(from2, to, (node2, pos) => {
+      let nodeText = node2.isText ? node2.text.slice(Math.max(from2, pos) - pos, to - pos) : !node2.isLeaf ? "" : leafText ? typeof leafText === "function" ? leafText(node2) : leafText : node2.type.spec.leafText ? node2.type.spec.leafText(node2) : "";
       if (node2.isBlock && (node2.isLeaf && nodeText || node2.isTextblock) && blockSeparator) {
         if (first)
           first = false;
···
   /**
   Cut out the sub-fragment between the two given positions.
   */
-  cut(from, to = this.size) {
-    if (from == 0 && to == this.size)
+  cut(from2, to = this.size) {
+    if (from2 == 0 && to == this.size)
       return this;
     let result = [], size2 = 0;
-    if (to > from)
+    if (to > from2)
       for (let i = 0, pos = 0; pos < to; i++) {
         let child = this.content[i], end = pos + child.nodeSize;
-        if (end > from) {
-          if (pos < from || end > to) {
+        if (end > from2) {
+          if (pos < from2 || end > to) {
             if (child.isText)
-              child = child.cut(Math.max(0, from - pos), Math.min(child.text.length, to - pos));
+              child = child.cut(Math.max(0, from2 - pos), Math.min(child.text.length, to - pos));
             else
-              child = child.cut(Math.max(0, from - pos - 1), Math.min(child.content.size, to - pos - 1));
+              child = child.cut(Math.max(0, from2 - pos - 1), Math.min(child.content.size, to - pos - 1));
           }
           result.push(child);
           size2 += child.nodeSize;
···
   /**
   @internal
   */
-  cutByIndex(from, to) {
-    if (from == to)
+  cutByIndex(from2, to) {
+    if (from2 == to)
       return _Fragment.empty;
-    if (from == 0 && to == this.content.length)
+    if (from2 == 0 && to == this.content.length)
       return this;
-    return new _Fragment(this.content.slice(from, to));
+    return new _Fragment(this.content.slice(from2, to));
   }
   /**
   Create a new fragment in which the node at the given index is
···
   /**
   @internal
   */
-  removeBetween(from, to) {
-    return new _Slice(removeRange(this.content, from + this.openStart, to + this.openStart), this.openStart, this.openEnd);
+  removeBetween(from2, to) {
+    return new _Slice(removeRange(this.content, from2 + this.openStart, to + this.openStart), this.openStart, this.openEnd);
   }
   /**
   Tests whether this slice is equal to another slice.
···
   }
 };
 Slice2.empty = new Slice2(Fragment.empty, 0, 0);
-function removeRange(content3, from, to) {
-  let { index: index2, offset: offset3 } = content3.findIndex(from), child = content3.maybeChild(index2);
+function removeRange(content3, from2, to) {
+  let { index: index2, offset: offset3 } = content3.findIndex(from2), child = content3.maybeChild(index2);
   let { index: indexTo, offset: offsetTo } = content3.findIndex(to);
-  if (offset3 == from || child.isText) {
+  if (offset3 == from2 || child.isText) {
     if (offsetTo != to && !content3.child(indexTo).isText)
       throw new RangeError("Removing non-flat range");
-    return content3.cut(0, from).append(content3.cut(to));
+    return content3.cut(0, from2).append(content3.cut(to));
   }
   if (index2 != indexTo)
     throw new RangeError("Removing non-flat range");
-  return content3.replaceChild(index2, child.copy(removeRange(child.content, from - offset3 - 1, to - offset3 - 1)));
+  return content3.replaceChild(index2, child.copy(removeRange(child.content, from2 - offset3 - 1, to - offset3 - 1)));
 }
 function insertInto(content3, dist, insert, parent) {
   let { index: index2, offset: offset3 } = content3.findIndex(dist), child = content3.maybeChild(index2);
···
   let inner = insertInto(child.content, dist - offset3 - 1, insert, child);
   return inner && content3.replaceChild(index2, child.copy(inner));
 }
-function replace($from, $to, slice) {
-  if (slice.openStart > $from.depth)
+function replace($from, $to, slice2) {
+  if (slice2.openStart > $from.depth)
     throw new ReplaceError("Inserted content deeper than insertion position");
-  if ($from.depth - slice.openStart != $to.depth - slice.openEnd)
+  if ($from.depth - slice2.openStart != $to.depth - slice2.openEnd)
     throw new ReplaceError("Inconsistent open depths");
-  return replaceOuter($from, $to, slice, 0);
+  return replaceOuter($from, $to, slice2, 0);
 }
-function replaceOuter($from, $to, slice, depth) {
+function replaceOuter($from, $to, slice2, depth) {
   let index2 = $from.index(depth), node2 = $from.node(depth);
-  if (index2 == $to.index(depth) && depth < $from.depth - slice.openStart) {
-    let inner = replaceOuter($from, $to, slice, depth + 1);
+  if (index2 == $to.index(depth) && depth < $from.depth - slice2.openStart) {
+    let inner = replaceOuter($from, $to, slice2, depth + 1);
     return node2.copy(node2.content.replaceChild(index2, inner));
-  } else if (!slice.content.size) {
+  } else if (!slice2.content.size) {
     return close(node2, replaceTwoWay($from, $to, depth));
-  } else if (!slice.openStart && !slice.openEnd && $from.depth == depth && $to.depth == depth) {
+  } else if (!slice2.openStart && !slice2.openEnd && $from.depth == depth && $to.depth == depth) {
     let parent = $from.parent, content3 = parent.content;
-    return close(parent, content3.cut(0, $from.parentOffset).append(slice.content).append(content3.cut($to.parentOffset)));
+    return close(parent, content3.cut(0, $from.parentOffset).append(slice2.content).append(content3.cut($to.parentOffset)));
   } else {
-    let { start, end } = prepareSliceForReplace(slice, $from);
+    let { start, end } = prepareSliceForReplace(slice2, $from);
     return close(node2, replaceThreeWay($from, start, end, $to, depth));
   }
 }
···
   addRange($to, null, depth, content3);
   return new Fragment(content3);
 }
-function prepareSliceForReplace(slice, $along) {
-  let extra = $along.depth - slice.openStart, parent = $along.node(extra);
-  let node2 = parent.copy(slice.content);
+function prepareSliceForReplace(slice2, $along) {
+  let extra = $along.depth - slice2.openStart, parent = $along.node(extra);
+  let node2 = parent.copy(slice2.content);
   for (let i = extra - 1; i >= 0; i--)
     node2 = $along.node(i).copy(Fragment.from(node2));
   return {
-    start: node2.resolveNoCache(slice.openStart + extra),
-    end: node2.resolveNoCache(node2.content.size - slice.openEnd - extra)
+    start: node2.resolveNoCache(slice2.openStart + extra),
+    end: node2.resolveNoCache(node2.content.size - slice2.openEnd - extra)
   };
 }
 var ResolvedPos = class _ResolvedPos {
···
   recursed over. The last parameter can be used to specify a
   starting position to count from.
   */
-  nodesBetween(from, to, f, startPos = 0) {
-    this.content.nodesBetween(from, to, f, startPos, this);
+  nodesBetween(from2, to, f, startPos = 0) {
+    this.content.nodesBetween(from2, to, f, startPos, this);
   }
   /**
   Call the given callback for every descendant node. Doesn't
···
   inserted for every non-text leaf node encountered, otherwise
   [`leafText`](https://prosemirror.net/docs/ref/#model.NodeSpec.leafText) will be used.
   */
-  textBetween(from, to, blockSeparator, leafText) {
-    return this.content.textBetween(from, to, blockSeparator, leafText);
+  textBetween(from2, to, blockSeparator, leafText) {
+    return this.content.textBetween(from2, to, blockSeparator, leafText);
   }
   /**
   Returns this node's first child, or `null` if there are no
···
   given positions. If `to` is not given, it defaults to the end of
   the node.
   */
-  cut(from, to = this.content.size) {
-    if (from == 0 && to == this.content.size)
+  cut(from2, to = this.content.size) {
+    if (from2 == 0 && to == this.content.size)
       return this;
-    return this.copy(this.content.cut(from, to));
+    return this.copy(this.content.cut(from2, to));
   }
   /**
   Cut out the part of the document between the given positions, and
   return it as a `Slice` object.
   */
-  slice(from, to = this.content.size, includeParents = false) {
-    if (from == to)
+  slice(from2, to = this.content.size, includeParents = false) {
+    if (from2 == to)
       return Slice2.empty;
-    let $from = this.resolve(from), $to = this.resolve(to);
+    let $from = this.resolve(from2), $to = this.resolve(to);
     let depth = includeParents ? 0 : $from.sharedDepth(to);
     let start = $from.start(depth), node2 = $from.node(depth);
     let content3 = node2.content.cut($from.pos - start, $to.pos - start);
···
   into. If any of this is violated, an error of type
   [`ReplaceError`](https://prosemirror.net/docs/ref/#model.ReplaceError) is thrown.
   */
-  replace(from, to, slice) {
-    return replace(this.resolve(from), this.resolve(to), slice);
+  replace(from2, to, slice2) {
+    return replace(this.resolve(from2), this.resolve(to), slice2);
   }
   /**
   Find the node directly after the given position.
···
   Test whether a given mark or mark type occurs in this document
   between the two given positions.
   */
-  rangeHasMark(from, to, type) {
+  rangeHasMark(from2, to, type) {
     let found2 = false;
-    if (to > from)
-      this.nodesBetween(from, to, (node2) => {
+    if (to > from2)
+      this.nodesBetween(from2, to, (node2) => {
         if (type.isInSet(node2.marks))
           found2 = true;
         return !found2;
···
   can optionally pass `start` and `end` indices into the
   replacement fragment.
   */
-  canReplace(from, to, replacement = Fragment.empty, start = 0, end = replacement.childCount) {
-    let one2 = this.contentMatchAt(from).matchFragment(replacement, start, end);
+  canReplace(from2, to, replacement = Fragment.empty, start = 0, end = replacement.childCount) {
+    let one2 = this.contentMatchAt(from2).matchFragment(replacement, start, end);
     let two = one2 && one2.matchFragment(this.content, to);
     if (!two || !two.validEnd)
       return false;
···
   Test whether replacing the range `from` to `to` (by index) with
   a node of the given type would leave the node's content valid.
   */
-  canReplaceWith(from, to, type, marks) {
+  canReplaceWith(from2, to, type, marks) {
     if (marks && !this.type.allowsMarks(marks))
       return false;
-    let start = this.contentMatchAt(from).matchType(type);
+    let start = this.contentMatchAt(from2).matchType(type);
     let end = start && start.matchFragment(this.content, to);
     return end ? end.validEnd : false;
   }
···
   get textContent() {
     return this.text;
   }
-  textBetween(from, to) {
-    return this.text.slice(from, to);
+  textBetween(from2, to) {
+    return this.text.slice(from2, to);
   }
   get nodeSize() {
     return this.text.length;
···
       return this;
     return new _TextNode(this.type, this.attrs, text4, this.marks);
   }
-  cut(from = 0, to = this.text.length) {
-    if (from == 0 && to == this.text.length)
+  cut(from2 = 0, to = this.text.length) {
+    if (from2 == 0 && to == this.text.length)
       return this;
-    return this.withText(this.text.slice(from, to));
+    return this.withText(this.text.slice(from2, to));
   }
   eq(other) {
     return this.sameMarkup(other) && this.text == other.text;
···
   function node2() {
     return nfa2.push([]) - 1;
   }
-  function edge(from, to, term) {
+  function edge(from2, to, term) {
     let edge2 = { term, to };
-    nfa2[from].push(edge2);
+    nfa2[from2].push(edge2);
     return edge2;
   }
   function connect(edges, to) {
     edges.forEach((edge2) => edge2.to = to);
   }
-  function compile(expr2, from) {
+  function compile(expr2, from2) {
     if (expr2.type == "choice") {
-      return expr2.exprs.reduce((out, expr3) => out.concat(compile(expr3, from)), []);
+      return expr2.exprs.reduce((out, expr3) => out.concat(compile(expr3, from2)), []);
     } else if (expr2.type == "seq") {
       for (let i = 0; ; i++) {
-        let next = compile(expr2.exprs[i], from);
+        let next = compile(expr2.exprs[i], from2);
         if (i == expr2.exprs.length - 1)
           return next;
-        connect(next, from = node2());
+        connect(next, from2 = node2());
       }
     } else if (expr2.type == "star") {
       let loop = node2();
-      edge(from, loop);
+      edge(from2, loop);
       connect(compile(expr2.expr, loop), loop);
       return [edge(loop)];
     } else if (expr2.type == "plus") {
       let loop = node2();
-      connect(compile(expr2.expr, from), loop);
+      connect(compile(expr2.expr, from2), loop);
       connect(compile(expr2.expr, loop), loop);
       return [edge(loop)];
     } else if (expr2.type == "opt") {
-      return [edge(from)].concat(compile(expr2.expr, from));
+      return [edge(from2)].concat(compile(expr2.expr, from2));
     } else if (expr2.type == "range") {
-      let cur = from;
+      let cur = from2;
       for (let i = 0; i < expr2.min; i++) {
         let next = node2();
         connect(compile(expr2.expr, cur), next);
···
       }
       return [edge(cur)];
     } else if (expr2.type == "name") {
-      return [edge(from, void 0, expr2.value)];
+      return [edge(from2, void 0, expr2.value)];
     } else {
       throw new Error("Unknown expr type");
     }
···
   /**
   Create a new mapping with the given position maps.
   */
-  constructor(maps, mirror, from = 0, to = maps ? maps.length : 0) {
+  constructor(maps, mirror, from2 = 0, to = maps ? maps.length : 0) {
     this.mirror = mirror;
-    this.from = from;
+    this.from = from2;
     this.to = to;
     this._maps = maps || [];
     this.ownData = !(maps || mirror);
···
   /**
   Create a mapping that maps only through a part of this one.
   */
-  slice(from = 0, to = this.maps.length) {
-    return new _Mapping(this._maps, this.mirror, from, to);
+  slice(from2 = 0, to = this.maps.length) {
+    return new _Mapping(this._maps, this.mirror, from2, 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(map4, mirrors) {
+  appendMap(map5, mirrors) {
     if (!this.ownData) {
       this._maps = this._maps.slice();
       this.mirror = this.mirror && this.mirror.slice();
       this.ownData = true;
     }
-    this.to = this._maps.push(map4);
+    this.to = this._maps.push(map5);
     if (mirrors != null)
       this.setMirror(this._maps.length - 1, mirrors);
   }
···
   _map(pos, assoc, simple) {
     let delInfo = 0;
     for (let i = this.from; i < this.to; i++) {
-      let map4 = this._maps[i], result = map4.mapResult(pos, assoc);
+      let map5 = this._maps[i], result = map5.mapResult(pos, assoc);
       if (result.recover != null) {
         let corr = this.getMirror(i);
         if (corr != null && corr > i && corr < this.to) {
···
   arguments. Create a successful result if it succeeds, and a
   failed one if it throws a `ReplaceError`.
   */
-  static fromReplace(doc4, from, to, slice) {
+  static fromReplace(doc4, from2, to, slice2) {
     try {
-      return _StepResult.ok(doc4.replace(from, to, slice));
+      return _StepResult.ok(doc4.replace(from2, to, slice2));
     } catch (e) {
       if (e instanceof ReplaceError)
         return _StepResult.fail(e.message);
···
   /**
   Create a mark step.
   */
-  constructor(from, to, mark) {
+  constructor(from2, to, mark) {
     super();
-    this.from = from;
+    this.from = from2;
     this.to = to;
     this.mark = mark;
   }
   apply(doc4) {
     let oldSlice = doc4.slice(this.from, this.to), $from = doc4.resolve(this.from);
     let parent = $from.node($from.sharedDepth(this.to));
-    let slice = new Slice2(mapFragment(oldSlice.content, (node2, parent2) => {
+    let slice2 = new Slice2(mapFragment(oldSlice.content, (node2, parent2) => {
       if (!node2.isAtom || !parent2.type.allowsMarkType(this.mark.type))
         return node2;
       return node2.mark(this.mark.addToSet(node2.marks));
     }, parent), oldSlice.openStart, oldSlice.openEnd);
-    return StepResult.fromReplace(doc4, this.from, this.to, slice);
+    return StepResult.fromReplace(doc4, this.from, this.to, slice2);
   }
   invert() {
     return new RemoveMarkStep(this.from, this.to, this.mark);
   }
   map(mapping) {
-    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-    if (from.deleted && to.deleted || from.pos >= to.pos)
+    let from2 = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
+    if (from2.deleted && to.deleted || from2.pos >= to.pos)
       return null;
-    return new _AddMarkStep(from.pos, to.pos, this.mark);
+    return new _AddMarkStep(from2.pos, to.pos, this.mark);
   }
   merge(other) {
     if (other instanceof _AddMarkStep && other.mark.eq(this.mark) && this.from <= other.to && this.to >= other.from)
···
   /**
   Create a mark-removing step.
   */
-  constructor(from, to, mark) {
+  constructor(from2, to, mark) {
     super();
-    this.from = from;
+    this.from = from2;
     this.to = to;
     this.mark = mark;
   }
   apply(doc4) {
     let oldSlice = doc4.slice(this.from, this.to);
-    let slice = new Slice2(mapFragment(oldSlice.content, (node2) => {
+    let slice2 = new Slice2(mapFragment(oldSlice.content, (node2) => {
       return node2.mark(this.mark.removeFromSet(node2.marks));
     }, doc4), oldSlice.openStart, oldSlice.openEnd);
-    return StepResult.fromReplace(doc4, this.from, this.to, slice);
+    return StepResult.fromReplace(doc4, this.from, this.to, slice2);
   }
   invert() {
     return new AddMarkStep(this.from, this.to, this.mark);
   }
   map(mapping) {
-    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-    if (from.deleted && to.deleted || from.pos >= to.pos)
+    let from2 = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
+    if (from2.deleted && to.deleted || from2.pos >= to.pos)
       return null;
-    return new _RemoveMarkStep(from.pos, to.pos, this.mark);
+    return new _RemoveMarkStep(from2.pos, to.pos, this.mark);
   }
   merge(other) {
     if (other instanceof _RemoveMarkStep && other.mark.eq(this.mark) && this.from <= other.to && this.to >= other.from)
···
   tokens (this is to guard against rebased replace steps
   overwriting something they weren't supposed to).
   */
-  constructor(from, to, slice, structure = false) {
+  constructor(from2, to, slice2, structure = false) {
     super();
-    this.from = from;
+    this.from = from2;
     this.to = to;
-    this.slice = slice;
+    this.slice = slice2;
     this.structure = structure;
   }
   apply(doc4) {
···
     return new _ReplaceStep(this.from, this.from + this.slice.size, doc4.slice(this.from, this.to));
   }
   map(mapping) {
-    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-    if (from.deletedAcross && to.deletedAcross)
+    let from2 = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
+    if (from2.deletedAcross && to.deletedAcross)
       return null;
-    return new _ReplaceStep(from.pos, Math.max(from.pos, to.pos), this.slice, this.structure);
+    return new _ReplaceStep(from2.pos, Math.max(from2.pos, to.pos), this.slice, this.structure);
   }
   merge(other) {
     if (!(other instanceof _ReplaceStep) || other.structure || this.structure)
       return null;
     if (this.from + this.slice.size == other.from && !this.slice.openEnd && !other.slice.openStart) {
-      let slice = this.slice.size + other.slice.size == 0 ? Slice2.empty : new Slice2(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);
+      let slice2 = this.slice.size + other.slice.size == 0 ? Slice2.empty : new Slice2(this.slice.content.append(other.slice.content), this.slice.openStart, other.slice.openEnd);
+      return new _ReplaceStep(this.from, this.to + (other.to - other.from), slice2, this.structure);
     } else if (other.to == this.from && !this.slice.openStart && !other.slice.openEnd) {
-      let slice = this.slice.size + other.slice.size == 0 ? Slice2.empty : new Slice2(other.slice.content.append(this.slice.content), other.slice.openStart, this.slice.openEnd);
-      return new _ReplaceStep(other.from, this.to, slice, this.structure);
+      let slice2 = this.slice.size + other.slice.size == 0 ? Slice2.empty : new Slice2(other.slice.content.append(this.slice.content), other.slice.openStart, this.slice.openEnd);
+      return new _ReplaceStep(other.from, this.to, slice2, this.structure);
     } else {
       return null;
     }
···
   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(from, to, gapFrom, gapTo, slice, insert, structure = false) {
+  constructor(from2, to, gapFrom, gapTo, slice2, insert, structure = false) {
     super();
-    this.from = from;
+    this.from = from2;
     this.to = to;
     this.gapFrom = gapFrom;
     this.gapTo = gapTo;
-    this.slice = slice;
+    this.slice = slice2;
     this.insert = insert;
     this.structure = structure;
   }
···
     return new _ReplaceAroundStep(this.from, this.from + this.slice.size + gap, this.from + this.insert, this.from + this.insert + gap, doc4.slice(this.from, this.to).removeBetween(this.gapFrom - this.from, this.gapTo - this.from), this.gapFrom - this.from, this.structure);
   }
   map(mapping) {
-    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
-    let gapFrom = this.from == this.gapFrom ? from.pos : mapping.map(this.gapFrom, -1);
+    let from2 = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
+    let gapFrom = this.from == this.gapFrom ? from2.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)
+    if (from2.deletedAcross && to.deletedAcross || gapFrom < from2.pos || gapTo > to.pos)
       return null;
-    return new _ReplaceAroundStep(from.pos, to.pos, gapFrom, gapTo, this.slice, this.insert, this.structure);
+    return new _ReplaceAroundStep(from2.pos, to.pos, gapFrom, gapTo, this.slice, this.insert, this.structure);
   }
   toJSON() {
     let json = {
···
   }
 };
 Step.jsonID("replaceAround", ReplaceAroundStep);
-function contentBetween(doc4, from, to) {
-  let $from = doc4.resolve(from), dist = to - from, depth = $from.depth;
+function contentBetween(doc4, from2, to) {
+  let $from = doc4.resolve(from2), dist = to - from2, depth = $from.depth;
   while (dist > 0 && depth > 0 && $from.indexAfter(depth) == $from.node(depth).childCount) {
     depth--;
     dist--;
···
   }
   return false;
 }
-function addMark(tr, from, to, mark) {
+function addMark(tr, from2, to, mark) {
   let removed = [], added = [];
   let removing, adding;
-  tr.doc.nodesBetween(from, to, (node2, pos, parent) => {
+  tr.doc.nodesBetween(from2, to, (node2, pos, parent) => {
     if (!node2.isInline)
       return;
     let marks = node2.marks;
     if (!mark.isInSet(marks) && parent.type.allowsMarkType(mark.type)) {
-      let start = Math.max(pos, from), end = Math.min(pos + node2.nodeSize, to);
+      let start = Math.max(pos, from2), end = Math.min(pos + node2.nodeSize, to);
       let newSet = mark.addToSet(marks);
       for (let i = 0; i < marks.length; i++) {
         if (!marks[i].isInSet(newSet)) {
···
   removed.forEach((s) => tr.step(s));
   added.forEach((s) => tr.step(s));
 }
-function removeMark(tr, from, to, mark) {
+function removeMark(tr, from2, to, mark) {
   let matched = [], step = 0;
-  tr.doc.nodesBetween(from, to, (node2, pos) => {
+  tr.doc.nodesBetween(from2, to, (node2, pos) => {
     if (!node2.isInline)
       return;
     step++;
···
           found2.to = end;
           found2.step = step;
         } else {
-          matched.push({ style, from: Math.max(pos, from), to: end, step });
+          matched.push({ style, from: Math.max(pos, from2), to: end, step });
         }
       }
     }
···
         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;
+        let m, newline = /\r?\n|\r/g, slice2;
         while (m = newline.exec(child.text)) {
-          if (!slice)
-            slice = new Slice2(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));
+          if (!slice2)
+            slice2 = new Slice2(Fragment.from(parentType.schema.text(" ", parentType.allowedMarks(child.marks))), 0, 0);
+          replSteps.push(new ReplaceStep(cur + m.index, cur + m.index + m[0].length, slice2));
         }
       }
     }
···
   let start = range.start, end = range.end;
   tr.step(new ReplaceAroundStep(start, end, start, end, new Slice2(content3, 0, 0), wrappers.length, true));
 }
-function setBlockType(tr, from, to, type, attrs) {
+function setBlockType(tr, from2, to, type, attrs) {
   if (!type.isTextblock)
     throw new RangeError("Type given to setBlockType should be a textblock");
   let mapFrom = tr.steps.length;
-  tr.doc.nodesBetween(from, to, (node2, pos) => {
+  tr.doc.nodesBetween(from2, to, (node2, pos) => {
     let attrsHere = typeof attrs == "function" ? attrs(node2) : attrs;
     if (node2.isTextblock && !node2.hasMarkup(type, attrsHere) && canChangeType(tr.doc, tr.mapping.slice(mapFrom).map(pos), type)) {
       let convertNewlines = null;
···
     }
   return null;
 }
-function dropPoint(doc4, pos, slice) {
+function dropPoint(doc4, pos, slice2) {
   let $pos = doc4.resolve(pos);
-  if (!slice.content.size)
+  if (!slice2.content.size)
     return pos;
-  let content3 = slice.content;
-  for (let i = 0; i < slice.openStart; i++)
+  let content3 = slice2.content;
+  for (let i = 0; i < slice2.openStart; i++)
     content3 = content3.firstChild.content;
-  for (let pass = 1; pass <= (slice.openStart == 0 && slice.size ? 2 : 1); pass++) {
+  for (let pass = 1; pass <= (slice2.openStart == 0 && slice2.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);
···
   }
   return null;
 }
-function replaceStep(doc4, from, to = from, slice = Slice2.empty) {
-  if (from == to && !slice.size)
+function replaceStep(doc4, from2, to = from2, slice2 = Slice2.empty) {
+  if (from2 == to && !slice2.size)
     return null;
-  let $from = doc4.resolve(from), $to = doc4.resolve(to);
-  if (fitsTrivially($from, $to, slice))
-    return new ReplaceStep(from, to, slice);
-  return new Fitter($from, $to, slice).fit();
+  let $from = doc4.resolve(from2), $to = doc4.resolve(to);
+  if (fitsTrivially($from, $to, slice2))
+    return new ReplaceStep(from2, to, slice2);
+  return new Fitter($from, $to, slice2).fit();
 }
-function fitsTrivially($from, $to, slice) {
-  return !slice.openStart && !slice.openEnd && $from.start() == $to.start() && $from.parent.canReplace($from.index(), $to.index(), slice.content);
+function fitsTrivially($from, $to, slice2) {
+  return !slice2.openStart && !slice2.openEnd && $from.start() == $to.start() && $from.parent.canReplace($from.index(), $to.index(), slice2.content);
 }
 var Fitter = class {
   constructor($from, $to, unplaced) {
···
       openStart--;
       openEnd--;
     }
-    let slice = new Slice2(content3, openStart, openEnd);
+    let slice2 = new Slice2(content3, 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 new ReplaceAroundStep($from.pos, moveInline, this.$to.pos, this.$to.end(), slice2, placedSize);
+    if (slice2.size || $from.pos != this.$to.pos)
+      return new ReplaceStep($from.pos, $to.pos, slice2);
     return null;
   }
   // Find a position on the start spine of `this.unplaced` that has
···
     if (wrap3)
       for (let i = 0; i < wrap3.length; i++)
         this.openFrontierNode(wrap3[i]);
-    let slice = this.unplaced, fragment = parent ? parent.content : slice.content;
-    let openStart = slice.openStart - sliceDepth;
+    let slice2 = this.unplaced, fragment = parent ? parent.content : slice2.content;
+    let openStart = slice2.openStart - sliceDepth;
     let taken = 0, add = [];
     let { match, type } = this.frontier[frontierDepth];
     if (inject) {
···
         add.push(inject.child(i));
       match = match.matchFragment(inject);
     }
-    let openEndCount = fragment.size + sliceDepth - (slice.content.size - slice.openEnd);
+    let openEndCount = fragment.size + sliceDepth - (slice2.content.size - slice2.openEnd);
     while (taken < fragment.childCount) {
       let next = fragment.child(taken), matches2 = match.matchType(next.type);
       if (!matches2)
···
       this.frontier.push({ type: node2.type, match: node2.contentMatchAt(node2.childCount) });
       cur = node2.content;
     }
-    this.unplaced = !toEnd ? new Slice2(dropFromFragment(slice.content, sliceDepth, taken), slice.openStart, slice.openEnd) : sliceDepth == 0 ? Slice2.empty : new Slice2(dropFromFragment(slice.content, sliceDepth - 1, 1), sliceDepth - 1, openEndCount < 0 ? slice.openEnd : sliceDepth - 1);
+    this.unplaced = !toEnd ? new Slice2(dropFromFragment(slice2.content, sliceDepth, taken), slice2.openStart, slice2.openEnd) : sliceDepth == 0 ? Slice2.empty : new Slice2(dropFromFragment(slice2.content, sliceDepth - 1, 1), sliceDepth - 1, openEndCount < 0 ? slice2.openEnd : sliceDepth - 1);
   }
   mustMoveInline() {
     if (!this.$to.parent.isTextblock)
···
 function definesContent(type) {
   return type.spec.defining || type.spec.definingForContent;
 }
-function replaceRange(tr, from, to, slice) {
-  if (!slice.size)
-    return tr.deleteRange(from, to);
-  let $from = tr.doc.resolve(from), $to = tr.doc.resolve(to);
-  if (fitsTrivially($from, $to, slice))
-    return tr.step(new ReplaceStep(from, to, slice));
+function replaceRange(tr, from2, to, slice2) {
+  if (!slice2.size)
+    return tr.deleteRange(from2, to);
+  let $from = tr.doc.resolve(from2), $to = tr.doc.resolve(to);
+  if (fitsTrivially($from, $to, slice2))
+    return tr.step(new ReplaceStep(from2, to, slice2));
   let targetDepths = coveredDepths($from, $to);
   if (targetDepths[targetDepths.length - 1] == 0)
     targetDepths.pop();
···
       targetDepths.splice(1, 0, -d);
   }
   let preferredTargetIndex = targetDepths.indexOf(preferredTarget);
-  let leftNodes = [], preferredDepth = slice.openStart;
-  for (let content3 = slice.content, i = 0; ; i++) {
+  let leftNodes = [], preferredDepth = slice2.openStart;
+  for (let content3 = slice2.content, i = 0; ; i++) {
     let node2 = content3.firstChild;
     leftNodes.push(node2);
-    if (i == slice.openStart)
+    if (i == slice2.openStart)
       break;
     content3 = node2.content;
   }
···
     else if (def || !leftNode.type.isTextblock)
       break;
   }
-  for (let j = slice.openStart; j >= 0; j--) {
-    let openDepth = (j + preferredDepth + 1) % (slice.openStart + 1);
+  for (let j = slice2.openStart; j >= 0; j--) {
+    let openDepth = (j + preferredDepth + 1) % (slice2.openStart + 1);
     let insert = leftNodes[openDepth];
     if (!insert)
       continue;
···
       }
       let parent = $from.node(targetDepth - 1), index2 = $from.index(targetDepth - 1);
       if (parent.canReplaceWith(index2, index2, insert.type, insert.marks))
-        return tr.replace($from.before(targetDepth), expand ? $to.after(targetDepth) : to, new Slice2(closeFragment(slice.content, 0, slice.openStart, openDepth), openDepth, slice.openEnd));
+        return tr.replace($from.before(targetDepth), expand ? $to.after(targetDepth) : to, new Slice2(closeFragment(slice2.content, 0, slice2.openStart, openDepth), openDepth, slice2.openEnd));
     }
   }
   let startSteps = tr.steps.length;
   for (let i = targetDepths.length - 1; i >= 0; i--) {
-    tr.replace(from, to, slice);
+    tr.replace(from2, to, slice2);
     if (tr.steps.length > startSteps)
       break;
     let depth = targetDepths[i];
     if (depth < 0)
       continue;
-    from = $from.before(depth);
+    from2 = $from.before(depth);
     to = $to.after(depth);
   }
 }
···
   }
   return fragment;
 }
-function replaceRangeWith(tr, from, to, node2) {
-  if (!node2.isInline && from == to && tr.doc.resolve(from).parent.content.size) {
-    let point3 = insertPoint(tr.doc, from, node2.type);
+function replaceRangeWith(tr, from2, to, node2) {
+  if (!node2.isInline && from2 == to && tr.doc.resolve(from2).parent.content.size) {
+    let point3 = insertPoint(tr.doc, from2, node2.type);
     if (point3 != null)
-      from = to = point3;
+      from2 = to = point3;
   }
-  tr.replaceRange(from, to, new Slice2(Fragment.from(node2), 0, 0));
+  tr.replaceRange(from2, to, new Slice2(Fragment.from(node2), 0, 0));
 }
-function deleteRange(tr, from, to) {
-  let $from = tr.doc.resolve(from), $to = tr.doc.resolve(to);
+function deleteRange(tr, from2, to) {
+  let $from = tr.doc.resolve(from2), $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;
···
       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)))
+    if (from2 - $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);
+  tr.delete(from2, to);
 }
 function coveredDepths($from, $to) {
   let result = [], minDepth = Math.min($from.depth, $to.depth);
···
   that add/remove marks without replacing the underlying content.
   */
   changedRange() {
-    let from = 1e9, to = -1e9;
+    let from2 = 1e9, to = -1e9;
     for (let i = 0; i < this.mapping.maps.length; i++) {
-      let map4 = this.mapping.maps[i];
+      let map5 = this.mapping.maps[i];
       if (i) {
-        from = map4.map(from, 1);
-        to = map4.map(to, -1);
+        from2 = map5.map(from2, 1);
+        to = map5.map(to, -1);
       }
-      map4.forEach((_f, _t, fromB, toB) => {
-        from = Math.min(from, fromB);
+      map5.forEach((_f, _t, fromB, toB) => {
+        from2 = Math.min(from2, fromB);
         to = Math.max(to, toB);
       });
     }
-    return from == 1e9 ? null : { from, to };
+    return from2 == 1e9 ? null : { from: from2, to };
   }
   /**
   @internal
···
   Replace the part of the document between `from` and `to` with the
   given `slice`.
   */
-  replace(from, to = from, slice = Slice2.empty) {
-    let step = replaceStep(this.doc, from, to, slice);
+  replace(from2, to = from2, slice2 = Slice2.empty) {
+    let step = replaceStep(this.doc, from2, to, slice2);
     if (step)
       this.step(step);
     return this;
···
   Replace the given range with the given content, which may be a
   fragment, node, or array of nodes.
   */
-  replaceWith(from, to, content3) {
-    return this.replace(from, to, new Slice2(Fragment.from(content3), 0, 0));
+  replaceWith(from2, to, content3) {
+    return this.replace(from2, to, new Slice2(Fragment.from(content3), 0, 0));
   }
   /**
   Delete the content between the given positions.
   */
-  delete(from, to) {
-    return this.replace(from, to, Slice2.empty);
+  delete(from2, to) {
+    return this.replace(from2, to, Slice2.empty);
   }
   /**
   Insert the given content at the given position.
···
   range, and is useful in situations where you need more precise
   control over what happens.
   */
-  replaceRange(from, to, slice) {
-    replaceRange(this, from, to, slice);
+  replaceRange(from2, to, slice2) {
+    replaceRange(this, from2, to, slice2);
     return this;
   }
   /**
···
   completely covers a parent node, this method may completely replace
   that parent node.
   */
-  replaceRangeWith(from, to, node2) {
-    replaceRangeWith(this, from, to, node2);
+  replaceRangeWith(from2, to, node2) {
+    replaceRangeWith(this, from2, to, node2);
     return this;
   }
   /**
   Delete the given range, expanding it to cover fully covered
   parent nodes until a valid replace is found.
   */
-  deleteRange(from, to) {
-    deleteRange(this, from, to);
+  deleteRange(from2, to) {
+    deleteRange(this, from2, to);
     return this;
   }
   /**
···
   Set the type of all textblocks (partly) between `from` and `to` to
   the given node type with the given attributes.
   */
-  setBlockType(from, to = from, type, attrs = null) {
-    setBlockType(this, from, to, type, attrs);
+  setBlockType(from2, to = from2, type, attrs = null) {
+    setBlockType(this, from2, to, type, attrs);
     return this;
   }
   /**
···
   /**
   Add the given mark to the inline content between `from` and `to`.
   */
-  addMark(from, to, mark) {
-    addMark(this, from, to, mark);
+  addMark(from2, to, mark) {
+    addMark(this, from2, to, mark);
     return this;
   }
   /**
···
   a mark type, remove all marks of that type. When it is null,
   remove all marks of any type.
   */
-  removeMark(from, to, mark) {
-    removeMark(this, from, to, mark);
+  removeMark(from2, to, mark) {
+    removeMark(this, from2, to, mark);
     return this;
   }
   /**
···
     let mapFrom = tr.steps.length, ranges = this.ranges;
     for (let i = 0; i < ranges.length; i++) {
       let { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);
-      let from = mapping.map($from.pos), to = mapping.map($to.pos);
+      let from2 = mapping.map($from.pos), to = mapping.map($to.pos);
       if (i) {
-        tr.deleteRange(from, to);
+        tr.deleteRange(from2, to);
       } else {
-        tr.replaceRangeWith(from, to, node2);
+        tr.replaceRangeWith(from2, to, node2);
         selectionToInsertionEnd(tr, mapFrom, node2.isInline ? -1 : 1);
       }
     }
···
   /**
   Create a node selection from non-resolved positions.
   */
-  static create(doc4, from) {
-    return new _NodeSelection(doc4.resolve(from));
+  static create(doc4, from2) {
+    return new _NodeSelection(doc4.resolve(from2));
   }
   /**
   Determines whether the given node may be selected as a node
···
   let step = tr.steps[last];
   if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep))
     return;
-  let map4 = tr.mapping.maps[last], end;
-  map4.forEach((_from, _to, _newFrom, newTo) => {
+  let map5 = tr.mapping.maps[last], end;
+  map5.forEach((_from, _to, _newFrom, newTo) => {
     if (end == null)
       end = newTo;
   });
···
   /**
   Replace the current selection with the given slice.
   */
-  replaceSelection(slice) {
-    this.selection.replace(this, slice);
+  replaceSelection(slice2) {
+    this.selection.replace(this, slice2);
     return this;
   }
   /**
···
   Replace the given range, or the selection if no range is given,
   with a text node containing the given string.
   */
-  insertText(text4, from, to) {
+  insertText(text4, from2, to) {
     let schema3 = this.doc.type.schema;
-    if (from == null) {
+    if (from2 == null) {
       if (!text4)
         return this.deleteSelection();
       return this.replaceSelectionWith(schema3.text(text4), true);
     } else {
       if (to == null)
-        to = from;
+        to = from2;
       if (!text4)
-        return this.deleteRange(from, to);
+        return this.deleteRange(from2, to);
       let marks = this.storedMarks;
       if (!marks) {
-        let $from = this.doc.resolve(from);
-        marks = to == from ? $from.marks() : $from.marksAcross(this.doc.resolve(to));
+        let $from = this.doc.resolve(from2);
+        marks = to == from2 ? $from.marks() : $from.marksAcross(this.doc.resolve(to));
       }
-      this.replaceRangeWith(from, to, schema3.text(text4, marks));
-      if (!this.selection.empty && this.selection.to == from + text4.length)
+      this.replaceRangeWith(from2, to, schema3.text(text4, marks));
+      if (!this.selection.empty && this.selection.to == from2 + text4.length)
         this.setSelection(Selection.near(this.selection.$to));
       return this;
     }
···
   return function(state, dispatch) {
     let applicable = false;
     for (let i = 0; i < state.selection.ranges.length && !applicable; i++) {
-      let { $from: { pos: from }, $to: { pos: to } } = state.selection.ranges[i];
-      state.doc.nodesBetween(from, to, (node2, pos) => {
+      let { $from: { pos: from2 }, $to: { pos: to } } = state.selection.ranges[i];
+      state.doc.nodesBetween(from2, to, (node2, pos) => {
         if (applicable)
           return false;
         if (!node2.isTextblock || node2.hasMarkup(nodeType, attrs))
···
     if (dispatch) {
       let tr = state.tr;
       for (let i = 0; i < state.selection.ranges.length; i++) {
-        let { $from: { pos: from }, $to: { pos: to } } = state.selection.ranges[i];
-        tr.setBlockType(from, to, nodeType, attrs);
+        let { $from: { pos: from2 }, $to: { pos: to } } = state.selection.ranges[i];
+        tr.setBlockType(from2, to, nodeType, attrs);
       }
       dispatch(tr.scrollIntoView());
     }
···
           if (!add) {
             tr.removeMark($from.pos, $to.pos, markType);
           } else {
-            let from = $from.pos, to = $to.pos, start = $from.nodeAfter, end = $to.nodeBefore;
+            let from2 = $from.pos, to = $to.pos, start = $from.nodeAfter, end = $to.nodeBefore;
             let spaceStart = dropSpace && start && start.isText ? /^\s*/.exec(start.text)[0].length : 0;
             let spaceEnd = dropSpace && end && end.isText ? /\s*$/.exec(end.text)[0].length : 0;
-            if (from + spaceStart < to) {
-              from += spaceStart;
+            if (from2 + spaceStart < to) {
+              from2 += spaceStart;
               to -= spaceEnd;
             }
-            tr.addMark(from, to, markType.create(attrs));
+            tr.addMark(from2, to, markType.create(attrs));
           }
         }
         dispatch(tr.scrollIntoView());
···
   }
   index2 = breaks.length;
   while (index2--) {
-    const slice = childEvents.slice(breaks[index2], breaks[index2 + 1]);
+    const slice2 = childEvents.slice(breaks[index2], breaks[index2 + 1]);
     const start2 = startPositions.pop();
-    jumps.push([start2, start2 + slice.length - 1]);
-    events.splice(start2, 2, slice);
+    jumps.push([start2, start2 + slice2.length - 1]);
+    events.splice(start2, 2, slice2);
   }
   jumps.reverse();
   index2 = -1;
···
 };
 
 // node_modules/micromark/lib/create-tokenizer.js
-function createTokenizer(parser2, initialize, from) {
+function createTokenizer(parser2, initialize, from2) {
   let point3 = {
     _bufferIndex: -1,
     _index: 0,
-    line: from && from.line || 1,
-    column: from && from.column || 1,
-    offset: from && from.offset || 0
+    line: from2 && from2.line || 1,
+    column: from2 && from2.column || 1,
+    offset: from2 && from2.offset || 0
   };
   const columnStart = {};
   const resolveAllConstructs = [];
···
     resolveAllConstructs.push(initialize);
   }
   return context;
-  function write(slice) {
-    chunks = push(chunks, slice);
+  function write(slice2) {
+    chunks = push(chunks, slice2);
     main();
     if (chunks[chunks.length - 1] !== null) {
       return [];
···
           constructs2
         ])
       ) : handleMapOfConstructs(constructs2);
-      function handleMapOfConstructs(map4) {
+      function handleMapOfConstructs(map5) {
         return start;
         function start(code2) {
-          const left = code2 !== null && map4[code2];
-          const all2 = code2 !== null && map4.null;
+          const left = code2 !== null && map5[code2];
+          const all2 = code2 !== null && map5.null;
           const list4 = [
             // To do: add more extension tests.
             /* c8 ignore next 2 */
···
       }
     }
   }
-  function addResult(construct, from2) {
+  function addResult(construct, from3) {
     if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {
       resolveAllConstructs.push(construct);
     }
     if (construct.resolve) {
-      splice(context.events, from2, context.events.length - from2, construct.resolve(context.events.slice(from2), context));
+      splice(context.events, from3, context.events.length - from3, construct.resolve(context.events.slice(from3), context));
     }
     if (construct.resolveTo) {
       context.events = construct.resolveTo(context.events, context);
···
   return parser2;
   function create(initial) {
     return creator;
-    function creator(from) {
-      return createTokenizer(parser2, initial, from);
+    function creator(from2) {
+      return createTokenizer(parser2, initial, from2);
     }
   }
 }
···
   const exit2 = state.enter("listItem");
   const value = state.indentLines(
     state.containerFlow(node2, tracker.current()),
-    map4
+    map5
   );
   exit2();
   return value;
-  function map4(line, index2, blank) {
+  function map5(line, index2, blank) {
     if (index2) {
       return (blank ? "" : " ".repeat(size2)) + line;
     }
···
 
 // node_modules/mdast-util-to-markdown/lib/util/indent-lines.js
 var eol = /\r?\n|\r/g;
-function indentLines(value, map4) {
+function indentLines(value, map5) {
   const result = [];
   let start = 0;
   let line = 0;
···
   one2(value.slice(start));
   return result.join("");
   function one2(value2) {
-    result.push(map4(value2, line, !value2));
+    result.push(map5(value2, line, !value2));
   }
 }
 
···
 var android = /Android \d/.test(agent);
 var webkit = !!doc2 && "webkitFontSmoothing" in doc2.documentElement.style;
 var webkit_version = webkit ? +(/\bAppleWebKit\/(\d+)/.exec(navigator.userAgent) || [0, 0])[1] : 0;
-function run(view, from, to, text4, rules, plugin) {
+function run(view, from2, to, text4, rules, plugin) {
   if (view.composing) return false;
   const state = view.state;
-  const $from = state.doc.resolve(from);
+  const $from = state.doc.resolve(from2);
   if ($from.parent.type.spec.code) return false;
   const textBefore = $from.parent.textBetween(
     Math.max(0, $from.parentOffset - 500),
···
   for (let _matcher of rules) {
     const matcher = _matcher;
     const match = matcher.match.exec(textBefore);
-    const tr = match && match[0] && matcher.handler(state, match, from - (match[0].length - text4.length), to);
+    const tr = match && match[0] && matcher.handler(state, match, from2 - (match[0].length - text4.length), to);
     if (!tr) continue;
     if (matcher.undoable !== false)
-      tr.setMeta(plugin, { transform: tr, from, to, text: text4 });
+      tr.setMeta(plugin, { transform: tr, from: from2, to, text: text4 });
     view.dispatch(tr);
     return true;
   }
···
       }
     },
     props: {
-      handleTextInput(view, from, to, text4) {
-        return run(view, from, to, text4, rules, plugin);
+      handleTextInput(view, from2, to, text4) {
+        return run(view, from2, to, text4, rules, plugin);
       },
       handleDOMEvents: {
         compositionend: (view) => {
···
 function minMax(value = 0, min2 = 0, max2 = 0) {
   return Math.min(Math.max(value, min2), max2);
 }
-function posToDOMRect(view, from, to) {
+function posToDOMRect(view, from2, to) {
   const minPos = 0;
   const maxPos = view.state.doc.content.size;
-  const resolvedFrom = minMax(from, minPos, maxPos);
+  const resolvedFrom = minMax(from2, minPos, maxPos);
   const resolvedEnd = minMax(to, minPos, maxPos);
   const start = view.coordsAtPos(resolvedFrom);
   const end = view.coordsAtPos(resolvedEnd, -1);
···
       target: selection.node
     };
   }
-  const { from, to } = selection;
+  const { from: from2, to } = selection;
   let hasNode = false;
   let pos = -1;
   let target = null;
-  doc4.nodesBetween(from, to, (n, p) => {
+  doc4.nodesBetween(from2, to, (n, p) => {
     if (target) return false;
     if (n.type === node2) {
       hasNode = true;
···
     result = "Shift-" + result;
   return result;
 }
-function normalize2(map4) {
+function normalize2(map5) {
   let copy2 = /* @__PURE__ */ Object.create(null);
-  for (let prop in map4)
-    copy2[normalizeKeyName(prop)] = map4[prop];
+  for (let prop in map5)
+    copy2[normalizeKeyName(prop)] = map5[prop];
   return copy2;
 }
 function modifiers(name, event, shift4 = true) {
···
   return new Plugin({ props: { handleKeyDown: keydownHandler(bindings) } });
 }
 function keydownHandler(bindings) {
-  let map4 = normalize2(bindings);
+  let map5 = normalize2(bindings);
   return function(view, event) {
-    let name = keyName(event), baseName, direct = map4[modifiers(name, event)];
+    let name = keyName(event), baseName, direct = map5[modifiers(name, event)];
     if (direct && direct(view.state, view.dispatch, view))
       return true;
     if (name.length == 1 && name != " ") {
       if (event.shiftKey) {
-        let noShift = map4[modifiers(name, event, false)];
+        let noShift = map5[modifiers(name, event, false)];
         if (noShift && noShift(view.state, view.dispatch, view))
           return true;
       }
       if ((event.altKey || event.metaKey || event.ctrlKey) && // Ctrl-Alt may be used for AltGr on Windows
       !(windows && event.ctrlKey && event.altKey) && (baseName = base[event.keyCode]) && baseName != name) {
-        let fromCode = map4[modifiers(baseName, event)];
+        let fromCode = map5[modifiers(baseName, event)];
         if (fromCode && fromCode(view.state, view.dispatch, view))
           return true;
       }
···
   return parent && parent.nodeType == 11 ? parent.host : parent;
 };
 var reusedRange = null;
-var textRange = function(node2, from, to) {
+var textRange = function(node2, from2, to) {
   let range = reusedRange || (reusedRange = document.createRange());
   range.setEnd(node2, to == null ? node2.nodeValue.length : to);
-  range.setStart(node2, from || 0);
+  range.setStart(node2, from2 || 0);
   return range;
 };
 var clearReusedRange = function() {
···
       }
       return rect;
     } else {
-      let from = offset3, to = offset3, takeSide = side < 0 ? 1 : -1;
+      let from2 = offset3, to = offset3, takeSide = side < 0 ? 1 : -1;
       if (side < 0 && !offset3) {
         to++;
         takeSide = -1;
       } else if (side >= 0 && offset3 == node2.nodeValue.length) {
-        from--;
+        from2--;
         takeSide = 1;
       } else if (side < 0) {
-        from--;
+        from2--;
       } else {
         to++;
       }
-      return flattenV(singleRect(textRange(node2, from, to), takeSide), takeSide < 0);
+      return flattenV(singleRect(textRange(node2, from2, to), takeSide), takeSide < 0);
     }
   }
   let $dom = view.state.doc.resolve(pos - (atom || 0));
···
   }
   // Used to find a DOM range in a single parent for a given changed
   // range.
-  parseRange(from, to, base2 = 0) {
+  parseRange(from2, to, base2 = 0) {
     if (this.children.length == 0)
-      return { node: this.contentDOM, from, to, fromOffset: 0, toOffset: this.contentDOM.childNodes.length };
+      return { node: this.contentDOM, from: from2, to, fromOffset: 0, toOffset: this.contentDOM.childNodes.length };
     let fromOffset = -1, toOffset = -1;
     for (let offset3 = base2, i = 0; ; i++) {
       let child = this.children[i], end = offset3 + child.size;
-      if (fromOffset == -1 && from <= end) {
+      if (fromOffset == -1 && from2 <= end) {
         let childBase = offset3 + child.border;
-        if (from >= childBase && to <= end - child.border && child.node && child.contentDOM && this.contentDOM.contains(child.contentDOM))
-          return child.parseRange(from, to, childBase);
-        from = offset3;
+        if (from2 >= childBase && to <= end - child.border && child.node && child.contentDOM && this.contentDOM.contains(child.contentDOM))
+          return child.parseRange(from2, to, childBase);
+        from2 = offset3;
         for (let j = i; j > 0; j--) {
           let prev = this.children[j - 1];
           if (prev.size && prev.dom.parentNode == this.contentDOM && !prev.emptyChildAt(1)) {
             fromOffset = domIndex(prev.dom) + 1;
             break;
           }
-          from -= prev.size;
+          from2 -= prev.size;
         }
         if (fromOffset == -1)
           fromOffset = 0;
···
       }
       offset3 = end;
     }
-    return { node: this.contentDOM, from, to, fromOffset, toOffset };
+    return { node: this.contentDOM, from: from2, to, fromOffset, toOffset };
   }
   emptyChildAt(side) {
     if (this.border || !this.contentDOM || !this.children.length)
···
   // a selection starts in such a node and ends in another, in which
   // case we just use whatever domFromPos produces as a best effort.
   setSelection(anchor, head, view, force = false) {
-    let from = Math.min(anchor, head), to = Math.max(anchor, head);
+    let from2 = Math.min(anchor, head), to = Math.max(anchor, head);
     for (let i = 0, offset3 = 0; i < this.children.length; i++) {
       let child = this.children[i], end = offset3 + child.size;
-      if (from > offset3 && to < end)
+      if (from2 > offset3 && to < end)
         return child.setSelection(anchor - offset3 - child.border, head - offset3 - child.border, view, force);
       offset3 = end;
     }
···
   }
   // Remove a subtree of the element tree that has been touched
   // by a DOM change, so that the next update will redraw it.
-  markDirty(from, to) {
+  markDirty(from2, to) {
     for (let offset3 = 0, i = 0; i < this.children.length; i++) {
       let child = this.children[i], end = offset3 + child.size;
-      if (offset3 == end ? from <= end && to >= offset3 : from < end && to > offset3) {
+      if (offset3 == end ? from2 <= end && to >= offset3 : from2 < end && to > offset3) {
         let startInside = offset3 + child.border, endInside = end - child.border;
-        if (from >= startInside && to <= endInside) {
-          this.dirty = from == offset3 || to == end ? CONTENT_DIRTY : CHILD_DIRTY;
-          if (from == startInside && to == endInside && (child.contentLost || child.dom.parentNode != this.contentDOM))
+        if (from2 >= startInside && to <= endInside) {
+          this.dirty = from2 == offset3 || to == end ? CONTENT_DIRTY : CHILD_DIRTY;
+          if (from2 == startInside && to == endInside && (child.contentLost || child.dom.parentNode != this.contentDOM))
             child.dirty = NODE_DIRTY;
           else
-            child.markDirty(from - startInside, to - startInside);
+            child.markDirty(from2 - startInside, to - startInside);
           return;
         } else {
           child.dirty = child.dom == child.contentDOM && child.dom.parentNode == this.contentDOM && !child.children.length ? CONTENT_DIRTY : NODE_DIRTY;
···
   matchesMark(mark) {
     return this.dirty != NODE_DIRTY && this.mark.eq(mark);
   }
-  markDirty(from, to) {
-    super.markDirty(from, to);
+  markDirty(from2, to) {
+    super.markDirty(from2, to);
     if (this.dirty != NOT_DIRTY) {
       let parent = this.parent;
       while (!parent.node)
···
       this.dirty = NOT_DIRTY;
     }
   }
-  slice(from, to, view) {
+  slice(from2, to, view) {
     let copy2 = _MarkViewDesc.create(this.parent, this.mark, true, view);
     let nodes = this.children, size2 = this.size;
     if (to < size2)
       nodes = replaceNodes(nodes, to, size2, view);
-    if (from > 0)
-      nodes = replaceNodes(nodes, 0, from, view);
+    if (from2 > 0)
+      nodes = replaceNodes(nodes, 0, from2, view);
     for (let i = 0; i < nodes.length; i++)
       nodes[i].parent = copy2;
     copy2.children = nodes;
···
     }
   }
   localCompositionInfo(view, pos) {
-    let { from, to } = view.state.selection;
-    if (!(view.state.selection instanceof TextSelection) || from < pos || to > pos + this.node.content.size)
+    let { from: from2, to } = view.state.selection;
+    if (!(view.state.selection instanceof TextSelection) || from2 < pos || to > pos + this.node.content.size)
       return null;
     let textNode = view.input.compositionNode;
     if (!textNode || !this.dom.contains(textNode.parentNode))
       return null;
     if (this.node.inlineContent) {
       let text4 = textNode.nodeValue;
-      let textPos = findTextInFragment(this.node.content, text4, from - pos, to - pos);
+      let textPos = findTextInFragment(this.node.content, text4, from2 - pos, to - pos);
       return textPos < 0 ? null : { node: textNode, pos: textPos, text: text4 };
     } else {
       return { node: textNode, pos: -1, text: "" };
···
   ignoreMutation(mutation) {
     return mutation.type != "characterData" && mutation.type != "selection";
   }
-  slice(from, to, view) {
-    let node2 = this.node.cut(from, to), dom = document.createTextNode(node2.text);
+  slice(from2, to, view) {
+    let node2 = this.node.cut(from2, to), dom = document.createTextNode(node2.text);
     return new _TextViewDesc(this.parent, node2, this.outerDeco, this.innerDeco, dom, dom, view);
   }
-  markDirty(from, to) {
-    super.markDirty(from, to);
-    if (this.dom != this.nodeDOM && (from == 0 || to == this.nodeDOM.nodeValue.length))
+  markDirty(from2, to) {
+    super.markDirty(from2, to);
+    if (this.dom != this.nodeDOM && (from2 == 0 || to == this.nodeDOM.nodeValue.length))
       this.dirty = NODE_DIRTY;
   }
   get domAtom() {
···
     dom.style.cssText = oldCSS;
   }
 }
-function findTextInFragment(frag, text4, from, to) {
+function findTextInFragment(frag, text4, from2, to) {
   for (let i = 0, pos = 0; i < frag.childCount && pos <= to; ) {
     let child = frag.child(i++), childStart = pos;
     pos += child.nodeSize;
···
         break;
       str += next.text;
     }
-    if (pos >= from) {
+    if (pos >= from2) {
       if (pos >= to && str.slice(to - text4.length - childStart, to - childStart) == text4)
         return to - text4.length;
       let found2 = childStart < to ? str.lastIndexOf(text4, to - childStart - 1) : -1;
-      if (found2 >= 0 && found2 + text4.length + childStart >= from)
+      if (found2 >= 0 && found2 + text4.length + childStart >= from2)
         return childStart + found2;
-      if (from == to && str.length >= to + text4.length - childStart && str.slice(to - childStart, to - childStart + text4.length) == text4)
+      if (from2 == to && str.length >= to + text4.length - childStart && str.slice(to - childStart, to - childStart + text4.length) == text4)
         return to;
     }
   }
   return -1;
 }
-function replaceNodes(nodes, from, to, view, replacement) {
+function replaceNodes(nodes, from2, to, view, replacement) {
   let result = [];
   for (let i = 0, off = 0; i < nodes.length; i++) {
     let child = nodes[i], start = off, end = off += child.size;
-    if (start >= to || end <= from) {
+    if (start >= to || end <= from2) {
       result.push(child);
     } else {
-      if (start < from)
-        result.push(child.slice(0, from - start, view));
+      if (start < from2)
+        result.push(child.slice(0, from2 - start, view));
       if (replacement) {
         result.push(replacement);
         replacement = void 0;
···
   }
   return false;
 }
-function serializeForClipboard(view, slice) {
+function serializeForClipboard(view, slice2) {
   view.someProp("transformCopied", (f) => {
-    slice = f(slice, view);
+    slice2 = f(slice2, view);
   });
-  let context = [], { content: content3, openStart, openEnd } = slice;
+  let context = [], { content: content3, openStart, openEnd } = slice2;
   while (openStart > 1 && openEnd > 1 && content3.childCount == 1 && content3.firstChild.childCount == 1) {
     openStart--;
     openEnd--;
···
   }
   if (firstChild && firstChild.nodeType == 1)
     firstChild.setAttribute("data-pm-slice", `${openStart} ${openEnd}${wrappers ? ` -${wrappers}` : ""} ${JSON.stringify(context)}`);
-  let text4 = view.someProp("clipboardTextSerializer", (f) => f(slice, view)) || slice.content.textBetween(0, slice.content.size, "\n\n");
-  return { dom: wrap3, text: text4, slice };
+  let text4 = view.someProp("clipboardTextSerializer", (f) => f(slice2, view)) || slice2.content.textBetween(0, slice2.content.size, "\n\n");
+  return { dom: wrap3, text: text4, slice: slice2 };
 }
 function parseFromClipboard(view, text4, html2, plainText, $context) {
   let inCode = $context.parent.type.spec.code;
-  let dom, slice;
+  let dom, slice2;
   if (!html2 && !text4)
     return null;
   let asText = !!text4 && (plainText || inCode || !html2);
···
       text4 = f(text4, inCode || plainText, view);
     });
     if (inCode) {
-      slice = new Slice2(Fragment.from(view.state.schema.text(text4.replace(/\r\n?/g, "\n"))), 0, 0);
+      slice2 = new Slice2(Fragment.from(view.state.schema.text(text4.replace(/\r\n?/g, "\n"))), 0, 0);
       view.someProp("transformPasted", (f) => {
-        slice = f(slice, view, true);
+        slice2 = f(slice2, view, true);
       });
-      return slice;
+      return slice2;
     }
     let parsed = view.someProp("clipboardTextParser", (f) => f(text4, $context, plainText, view));
     if (parsed) {
-      slice = parsed;
+      slice2 = parsed;
     } else {
       let marks = $context.marks();
       let { schema: schema3 } = view.state, serializer2 = DOMSerializer.fromSchema(schema3);
···
         break;
       dom = child;
     }
-  if (!slice) {
+  if (!slice2) {
     let parser2 = view.someProp("clipboardParser") || view.someProp("domParser") || DOMParser.fromSchema(view.state.schema);
-    slice = parser2.parseSlice(dom, {
+    slice2 = parser2.parseSlice(dom, {
       preserveWhitespace: !!(asText || sliceData),
       context: $context,
       ruleFromNode(dom2) {
···
     });
   }
   if (sliceData) {
-    slice = addContext(closeSlice(slice, +sliceData[1], +sliceData[2]), sliceData[4]);
+    slice2 = addContext(closeSlice(slice2, +sliceData[1], +sliceData[2]), sliceData[4]);
   } else {
-    slice = Slice2.maxOpen(normalizeSiblings(slice.content, $context), true);
-    if (slice.openStart || slice.openEnd) {
+    slice2 = Slice2.maxOpen(normalizeSiblings(slice2.content, $context), true);
+    if (slice2.openStart || slice2.openEnd) {
       let openStart = 0, openEnd = 0;
-      for (let node2 = slice.content.firstChild; openStart < slice.openStart && !node2.type.spec.isolating; openStart++, node2 = node2.firstChild) {
+      for (let node2 = slice2.content.firstChild; openStart < slice2.openStart && !node2.type.spec.isolating; openStart++, node2 = node2.firstChild) {
       }
-      for (let node2 = slice.content.lastChild; openEnd < slice.openEnd && !node2.type.spec.isolating; openEnd++, node2 = node2.lastChild) {
+      for (let node2 = slice2.content.lastChild; openEnd < slice2.openEnd && !node2.type.spec.isolating; openEnd++, node2 = node2.lastChild) {
       }
-      slice = closeSlice(slice, openStart, openEnd);
+      slice2 = closeSlice(slice2, openStart, openEnd);
     }
   }
   view.someProp("transformPasted", (f) => {
-    slice = f(slice, view, asText);
+    slice2 = f(slice2, view, asText);
   });
-  return slice;
+  return slice2;
 }
 var inlineParents = /^(a|abbr|acronym|b|cite|code|del|em|i|ins|kbd|label|output|q|ruby|s|samp|span|strong|sub|sup|time|u|tt|var)$/i;
 function normalizeSiblings(fragment, $context) {
···
   }
   return fragment;
 }
-function withWrappers(node2, wrap3, from = 0) {
-  for (let i = wrap3.length - 1; i >= from; i--)
+function withWrappers(node2, wrap3, from2 = 0) {
+  for (let i = wrap3.length - 1; i >= from2; i--)
     node2 = wrap3[i].create(null, Fragment.from(node2));
   return node2;
 }
···
   let fill = node2.contentMatchAt(node2.childCount).fillBefore(Fragment.empty, true);
   return node2.copy(fragment.append(fill));
 }
-function closeRange(fragment, side, from, to, depth, openEnd) {
+function closeRange(fragment, side, from2, to, depth, openEnd) {
   let node2 = side < 0 ? fragment.firstChild : fragment.lastChild, inner = node2.content;
   if (fragment.childCount > 1)
     openEnd = 0;
   if (depth < to - 1)
-    inner = closeRange(inner, side, from, to, depth + 1, openEnd);
-  if (depth >= from)
+    inner = closeRange(inner, side, from2, to, depth + 1, openEnd);
+  if (depth >= from2)
     inner = side < 0 ? node2.contentMatchAt(0).fillBefore(inner, openEnd <= depth).append(inner) : inner.append(node2.contentMatchAt(node2.childCount).fillBefore(Fragment.empty, true));
   return fragment.replaceChild(side < 0 ? 0 : fragment.childCount - 1, node2.copy(inner));
 }
-function closeSlice(slice, openStart, openEnd) {
-  if (openStart < slice.openStart)
-    slice = new Slice2(closeRange(slice.content, -1, openStart, slice.openStart, 0, slice.openEnd), openStart, slice.openEnd);
-  if (openEnd < slice.openEnd)
-    slice = new Slice2(closeRange(slice.content, 1, openEnd, slice.openEnd, 0, 0), slice.openStart, openEnd);
-  return slice;
+function closeSlice(slice2, openStart, openEnd) {
+  if (openStart < slice2.openStart)
+    slice2 = new Slice2(closeRange(slice2.content, -1, openStart, slice2.openStart, 0, slice2.openEnd), openStart, slice2.openEnd);
+  if (openEnd < slice2.openEnd)
+    slice2 = new Slice2(closeRange(slice2.content, 1, openEnd, slice2.openEnd, 0, 0), slice2.openStart, openEnd);
+  return slice2;
 }
 var wrapMap = {
   thead: ["table"],
···
       node2.parentNode.replaceChild(dom.ownerDocument.createTextNode(" "), node2);
   }
 }
-function addContext(slice, context) {
-  if (!slice.size)
-    return slice;
-  let schema3 = slice.content.firstChild.type.schema, array;
+function addContext(slice2, context) {
+  if (!slice2.size)
+    return slice2;
+  let schema3 = slice2.content.firstChild.type.schema, array;
   try {
     array = JSON.parse(context);
   } catch (e) {
-    return slice;
+    return slice2;
   }
-  let { content: content3, openStart, openEnd } = slice;
+  let { content: content3, openStart, openEnd } = slice2;
   for (let i = array.length - 2; i >= 0; i -= 2) {
     let type = schema3.nodes[array[i]];
     if (!type || type.hasRequiredAttrs())
···
   if (sel.empty)
     return;
   let data = brokenClipboardAPI ? null : event.clipboardData;
-  let slice = sel.content(), { dom, text: text4 } = serializeForClipboard(view, slice);
+  let slice2 = sel.content(), { dom, text: text4 } = serializeForClipboard(view, slice2);
   if (data) {
     event.preventDefault();
     data.clearData();
···
   if (cut)
     view.dispatch(view.state.tr.deleteSelection().scrollIntoView().setMeta("uiEvent", "cut"));
 };
-function sliceSingleNode(slice) {
-  return slice.openStart == 0 && slice.openEnd == 0 && slice.content.childCount == 1 ? slice.content.firstChild : null;
+function sliceSingleNode(slice2) {
+  return slice2.openStart == 0 && slice2.openEnd == 0 && slice2.content.childCount == 1 ? slice2.content.firstChild : null;
 }
 function capturePaste(view, event) {
   if (!view.dom.parentNode)
···
   }, 50);
 }
 function doPaste(view, text4, html2, preferPlain, event) {
-  let slice = parseFromClipboard(view, text4, html2, preferPlain, view.state.selection.$from);
-  if (view.someProp("handlePaste", (f) => f(view, event, slice || Slice2.empty)))
+  let slice2 = parseFromClipboard(view, text4, html2, preferPlain, view.state.selection.$from);
+  if (view.someProp("handlePaste", (f) => f(view, event, slice2 || Slice2.empty)))
     return true;
-  if (!slice)
+  if (!slice2)
     return false;
-  let singleNode = sliceSingleNode(slice);
-  let tr = singleNode ? view.state.tr.replaceSelectionWith(singleNode, preferPlain) : view.state.tr.replaceSelection(slice);
+  let singleNode = sliceSingleNode(slice2);
+  let tr = singleNode ? view.state.tr.replaceSelectionWith(singleNode, preferPlain) : view.state.tr.replaceSelection(slice2);
   view.dispatch(tr.scrollIntoView().setMeta("paste", true).setMeta("uiEvent", "paste"));
   return true;
 }
···
     capturePaste(view, event);
 };
 var Dragging = class {
-  constructor(slice, move, node2) {
-    this.slice = slice;
+  constructor(slice2, move, node2) {
+    this.slice = slice2;
     this.move = move;
     this.node = node2;
   }
···
       node2 = NodeSelection.create(view.state.doc, desc.posBefore);
   }
   let draggedSlice = (node2 || view.state.selection).content();
-  let { dom, text: text4, slice } = serializeForClipboard(view, draggedSlice);
+  let { dom, text: text4, slice: slice2 } = serializeForClipboard(view, draggedSlice);
   if (!event.dataTransfer.files.length || !chrome || chrome_version2 > 120)
     event.dataTransfer.clearData();
   event.dataTransfer.setData(brokenClipboardAPI ? "Text" : "text/html", dom.innerHTML);
   event.dataTransfer.effectAllowed = "copyMove";
   if (!brokenClipboardAPI)
     event.dataTransfer.setData("text/plain", text4);
-  view.dragging = new Dragging(slice, dragMoves(view, event), node2);
+  view.dragging = new Dragging(slice2, dragMoves(view, event), node2);
 };
 handlers.dragend = (view) => {
   let dragging = view.dragging;
···
   if (!eventPos)
     return;
   let $mouse = view.state.doc.resolve(eventPos.pos);
-  let slice = dragging && dragging.slice;
-  if (slice) {
+  let slice2 = dragging && dragging.slice;
+  if (slice2) {
     view.someProp("transformPasted", (f) => {
-      slice = f(slice, view, false);
+      slice2 = f(slice2, view, false);
     });
   } else {
-    slice = parseFromClipboard(view, getText(event.dataTransfer), brokenClipboardAPI ? null : event.dataTransfer.getData("text/html"), false, $mouse);
+    slice2 = parseFromClipboard(view, getText(event.dataTransfer), brokenClipboardAPI ? null : event.dataTransfer.getData("text/html"), false, $mouse);
   }
   let move = !!(dragging && dragMoves(view, event));
-  if (view.someProp("handleDrop", (f) => f(view, event, slice || Slice2.empty, move))) {
+  if (view.someProp("handleDrop", (f) => f(view, event, slice2 || Slice2.empty, move))) {
     event.preventDefault();
     return;
   }
-  if (!slice)
+  if (!slice2)
     return;
   event.preventDefault();
-  let insertPos = slice ? dropPoint(view.state.doc, $mouse.pos, slice) : $mouse.pos;
+  let insertPos = slice2 ? dropPoint(view.state.doc, $mouse.pos, slice2) : $mouse.pos;
   if (insertPos == null)
     insertPos = $mouse.pos;
   let tr = view.state.tr;
···
       tr.deleteSelection();
   }
   let pos = tr.mapping.map(insertPos);
-  let isNode2 = slice.openStart == 0 && slice.openEnd == 0 && slice.content.childCount == 1;
+  let isNode2 = slice2.openStart == 0 && slice2.openEnd == 0 && slice2.content.childCount == 1;
   let beforeInsert = tr.doc;
   if (isNode2)
-    tr.replaceRangeWith(pos, pos, slice.content.firstChild);
+    tr.replaceRangeWith(pos, pos, slice2.content.firstChild);
   else
-    tr.replaceRange(pos, pos, slice);
+    tr.replaceRange(pos, pos, slice2);
   if (tr.doc.eq(beforeInsert))
     return;
   let $pos = tr.doc.resolve(pos);
-  if (isNode2 && NodeSelection.isSelectable(slice.content.firstChild) && $pos.nodeAfter && $pos.nodeAfter.sameMarkup(slice.content.firstChild)) {
+  if (isNode2 && NodeSelection.isSelectable(slice2.content.firstChild) && $pos.nodeAfter && $pos.nodeAfter.sameMarkup(slice2.content.firstChild)) {
     tr.setSelection(new NodeSelection($pos));
   } else {
     let end = tr.mapping.map(insertPos);
···
     this.spec = spec || noSpec;
   }
   map(mapping, span, offset3, oldOffset) {
-    let from = mapping.map(span.from + oldOffset, this.spec.inclusiveStart ? -1 : 1) - offset3;
+    let from2 = mapping.map(span.from + oldOffset, this.spec.inclusiveStart ? -1 : 1) - offset3;
     let to = mapping.map(span.to + oldOffset, this.spec.inclusiveEnd ? 1 : -1) - offset3;
-    return from >= to ? null : new Decoration(from, to, this);
+    return from2 >= to ? null : new Decoration(from2, to, this);
   }
   valid(_, span) {
     return span.from < span.to;
···
     this.spec = spec || noSpec;
   }
   map(mapping, span, offset3, oldOffset) {
-    let from = mapping.mapResult(span.from + oldOffset, 1);
-    if (from.deleted)
+    let from2 = mapping.mapResult(span.from + oldOffset, 1);
+    if (from2.deleted)
       return null;
     let to = mapping.mapResult(span.to + oldOffset, -1);
-    if (to.deleted || to.pos <= from.pos)
+    if (to.deleted || to.pos <= from2.pos)
       return null;
-    return new Decoration(from.pos - offset3, to.pos - offset3, this);
+    return new Decoration(from2.pos - offset3, to.pos - offset3, this);
   }
   valid(node2, span) {
     let { index: index2, offset: offset3 } = node2.content.findIndex(span.from), child;
···
   /**
   @internal
   */
-  constructor(from, to, type) {
-    this.from = from;
+  constructor(from2, to, type) {
+    this.from = from2;
     this.to = to;
     this.type = type;
   }
   /**
   @internal
   */
-  copy(from, to) {
-    return new _Decoration(from, to, this.type);
+  copy(from2, to) {
+    return new _Decoration(from2, to, this.type);
   }
   /**
   @internal
···
   Creates an inline decoration, which adds the given attributes to
   each inline node between `from` and `to`.
   */
-  static inline(from, to, attrs, spec) {
-    return new _Decoration(from, to, new InlineType(attrs, spec));
+  static inline(from2, to, attrs, spec) {
+    return new _Decoration(from2, to, new InlineType(attrs, spec));
   }
   /**
   Creates a node decoration. `from` and `to` should point precisely
   before and after a node in the document. That node, and only that
   node, will receive the given attributes.
   */
-  static node(from, to, attrs, spec) {
-    return new _Decoration(from, to, new NodeType2(attrs, spec));
+  static node(from2, to, attrs, spec) {
+    return new _Decoration(from2, to, new NodeType2(attrs, spec));
   }
   /**
   The spec provided when creating this decoration. Can be useful
···
     let children = this.children, local = this.local;
     for (let i = 0; i < children.length; i += 3) {
       let found2;
-      let from = children[i] + offset3, to = children[i + 1] + offset3;
+      let from2 = children[i] + offset3, to = children[i + 1] + offset3;
       for (let j = 0, span; j < decorations.length; j++)
         if (span = decorations[j]) {
-          if (span.from > from && span.to < to) {
+          if (span.from > from2 && span.to < to) {
             decorations[j] = null;
             (found2 || (found2 = [])).push(span);
           }
···
         continue;
       if (children == this.children)
         children = this.children.slice();
-      let removed = children[i + 2].removeInner(found2, from + 1);
+      let removed = children[i + 2].removeInner(found2, from2 + 1);
       if (removed != empty2) {
         children[i + 2] = removed;
       } else {
···
     for (let i = 0; i < this.local.length; i++) {
       let dec = this.local[i];
       if (dec.from < end && dec.to > start && dec.type instanceof InlineType) {
-        let from = Math.max(start, dec.from) - start, to = Math.min(end, dec.to) - start;
-        if (from < to)
-          (local || (local = [])).push(dec.copy(from, to));
+        let from2 = Math.max(start, dec.from) - start, to = Math.min(end, dec.to) - start;
+        if (from2 < to)
+          (local || (local = [])).push(dec.copy(from2, to));
       }
     }
     if (local) {
···
         children[i + 1] = -1;
         continue;
       }
-      let from = mapping.map(oldChildren[i] + oldOffset), fromLocal = from - offset3;
+      let from2 = mapping.map(oldChildren[i] + oldOffset), fromLocal = from2 - offset3;
       if (fromLocal < 0 || fromLocal >= node2.content.size) {
         mustRebuild = true;
         continue;
···
       let { index: index2, offset: childOffset } = node2.content.findIndex(fromLocal);
       let childNode = node2.maybeChild(index2);
       if (childNode && childOffset == fromLocal && childOffset + childNode.nodeSize == toLocal) {
-        let mapped = children[i + 2].mapInner(mapping, childNode, from + 1, oldChildren[i] + oldOffset + 1, options);
+        let mapped = children[i + 2].mapInner(mapping, childNode, from2 + 1, oldChildren[i] + oldOffset + 1, options);
         if (mapped != empty2) {
           children[i] = fromLocal;
           children[i + 1] = toLocal;
···
         i -= 3;
       }
     for (let i = 0, j = 0; i < built.children.length; i += 3) {
-      let from = built.children[i];
-      while (j < children.length && children[j] < from)
+      let from2 = built.children[i];
+      while (j < children.length && children[j] < from2)
         j += 3;
       children.splice(j, 0, built.children[i], built.children[i + 1], built.children[i + 2]);
     }
···
       this.queue = [];
     let sel = view.domSelectionRange();
     let newSel = !this.suppressingSelectionUpdates && !this.currentSelection.eq(sel) && hasFocusAndSelection(view) && !this.ignoreSelectionChange(sel);
-    let from = -1, to = -1, typeOver = false, added = [];
+    let from2 = -1, to = -1, typeOver = false, added = [];
     if (view.editable) {
       for (let i = 0; i < mutations.length; i++) {
         let result = this.registerMutation(mutations[i], added);
         if (result) {
-          from = from < 0 ? result.from : Math.min(result.from, from);
+          from2 = from2 < 0 ? result.from : Math.min(result.from, from2);
           to = to < 0 ? result.to : Math.max(result.to, to);
           if (result.typeOver)
             typeOver = true;
···
       }
     }
     let readSel = null;
-    if (from < 0 && newSel && view.input.lastFocus > Date.now() - 200 && Math.max(view.input.lastTouch, view.input.lastClick.time) < Date.now() - 300 && selectionCollapsed(sel) && (readSel = selectionFromDOM(view)) && readSel.eq(Selection.near(view.state.doc.resolve(0), 1))) {
+    if (from2 < 0 && newSel && view.input.lastFocus > Date.now() - 200 && Math.max(view.input.lastTouch, view.input.lastClick.time) < Date.now() - 300 && selectionCollapsed(sel) && (readSel = selectionFromDOM(view)) && readSel.eq(Selection.near(view.state.doc.resolve(0), 1))) {
       view.input.lastFocus = 0;
       selectionToDOM(view);
       this.currentSelection.set(sel);
       view.scrollToSelection();
-    } else if (from > -1 || newSel) {
-      if (from > -1) {
-        view.docView.markDirty(from, to);
+    } else if (from2 > -1 || newSel) {
+      if (from2 > -1) {
+        view.docView.markDirty(from2, to);
         checkCSS(view);
       }
       if (view.input.badSafariComposition) {
         view.input.badSafariComposition = false;
         fixUpBadSafariComposition(view, added);
       }
-      this.handleDOMChange(from, to, typeOver, added);
+      this.handleDOMChange(from2, to, typeOver, added);
       if (view.docView && view.docView.dirty)
         view.updateState(view.state);
       else if (!this.currentSelection.eq(sel))
···
         }
       }
       let fromOffset = prev && prev.parentNode == mut.target ? domIndex(prev) + 1 : 0;
-      let from = desc.localPosFromDOM(mut.target, fromOffset, -1);
+      let from2 = desc.localPosFromDOM(mut.target, fromOffset, -1);
       let toOffset = next && next.parentNode == mut.target ? domIndex(next) : mut.target.childNodes.length;
       let to = desc.localPosFromDOM(mut.target, toOffset, 1);
-      return { from, to };
+      return { from: from2, to };
     } else if (mut.type == "attributes") {
       return { from: desc.posAtStart - desc.border, to: desc.posAtEnd + desc.border };
     } else {
···
   }
 }
 function parseBetween(view, from_, to_) {
-  let { node: parent, fromOffset, toOffset, from, to } = view.docView.parseRange(from_, to_);
+  let { node: parent, fromOffset, toOffset, from: from2, to } = view.docView.parseRange(from_, to_);
   let domSel = view.domSelectionRange();
   let find;
   let anchor = domSel.anchorNode;
···
   }
   let startDoc = view.state.doc;
   let parser2 = view.someProp("domParser") || DOMParser.fromSchema(view.state.schema);
-  let $from = startDoc.resolve(from);
+  let $from = startDoc.resolve(from2);
   let sel = null, doc4 = parser2.parse(parent, {
     topNode: $from.parent,
     topMatch: $from.parent.contentMatchAt($from.index()),
···
     let anchor2 = find[0].pos, head = find[1] && find[1].pos;
     if (head == null)
       head = anchor2;
-    sel = { anchor: anchor2 + from, head: head + from };
+    sel = { anchor: anchor2 + from2, head: head + from2 };
   }
-  return { doc: doc4, sel, from, to };
+  return { doc: doc4, sel, from: from2, to };
 }
 function ruleFromNode(dom) {
   let desc = dom.pmViewDesc;
···
   return null;
 }
 var isInline = /^(a|abbr|acronym|b|bd[io]|big|br|button|cite|code|data(list)?|del|dfn|em|i|img|ins|kbd|label|map|mark|meter|output|q|ruby|s|samp|small|span|strong|su[bp]|time|u|tt|var)$/i;
-function readDOMChange(view, from, to, typeOver, addedNodes) {
+function readDOMChange(view, from2, to, typeOver, addedNodes) {
   let compositionID = view.input.compositionPendingChanges || (view.composing ? view.input.compositionID : 0);
   view.input.compositionPendingChanges = 0;
-  if (from < 0) {
+  if (from2 < 0) {
     let origin = view.input.lastSelectionTime > Date.now() - 50 ? view.input.lastSelectionOrigin : null;
     let newSel = selectionFromDOM(view, origin);
     if (newSel && !view.state.selection.eq(newSel)) {
···
     }
     return;
   }
-  let $before = view.state.doc.resolve(from);
+  let $before = view.state.doc.resolve(from2);
   let shared = $before.sharedDepth(to);
-  from = $before.before(shared + 1);
+  from2 = $before.before(shared + 1);
   to = view.state.doc.resolve(to).after(shared + 1);
   let sel = view.state.selection;
-  let parse2 = parseBetween(view, from, to);
+  let parse2 = parseBetween(view, from2, to);
   let doc4 = view.state.doc, compare = doc4.slice(parse2.from, parse2.to);
   let preferredPos, preferredSide;
   if (view.input.lastKeyCode === 8 && Date.now() - 100 < view.input.lastKeyCodeTime) {
···
     updateCursorWrapper(this);
     this.nodeViews = buildNodeViews(this);
     this.docView = docViewDesc(this.state.doc, computeDocDeco(this), viewDecorations(this), this.dom, this);
-    this.domObserver = new DOMObserver(this, (from, to, typeOver, added) => readDOMChange(this, from, to, typeOver, added));
+    this.domObserver = new DOMObserver(this, (from2, to, typeOver, added) => readDOMChange(this, from2, to, typeOver, added));
     this.domObserver.start();
     initInput(this);
     this.updatePluginViews();
···
   different from the given input due to hooks like
   [`transformCopied`](https://prosemirror.net/docs/ref/#view.EditorProps.transformCopied)).
   */
-  serializeForClipboard(slice) {
-    return serializeForClipboard(this, slice);
+  serializeForClipboard(slice2) {
+    return serializeForClipboard(this, slice2);
   }
   /**
   Removes the editor from the DOM and destroys all [node
···
       if (this.#ctx == null) throw callCommandBeforeEditorView();
       const ctx = this.#ctx;
       const commands22 = [];
-      const get = this.get.bind(this);
+      const get2 = this.get.bind(this);
       const chains = {
         run: () => {
           const chained = chainCommands(...commands22);
···
         },
         pipe: pipe.bind(this)
       };
-      function pipe(slice, payload) {
-        const cmd = get(slice);
+      function pipe(slice2, payload) {
+        const cmd = get2(slice2);
         commands22.push(cmd(payload));
         return chains;
       }
···
   }
   /// Register a command into the manager.
   create(meta, value) {
-    const slice = meta.create(this.#container.sliceMap);
-    slice.set(value);
-    return slice;
+    const slice2 = meta.create(this.#container.sliceMap);
+    slice2.set(value);
+    return slice2;
   }
-  get(slice) {
-    return this.#container.get(slice).get();
+  get(slice2) {
+    return this.#container.get(slice2).get();
   }
-  remove(slice) {
-    return this.#container.remove(slice);
+  remove(slice2) {
+    return this.#container.remove(slice2);
   }
-  call(slice, payload) {
+  call(slice2, payload) {
     if (this.#ctx == null) throw callCommandBeforeEditorView();
-    const cmd = this.get(slice);
+    const cmd = this.get(slice2);
     const command = cmd(payload);
     const view = this.#ctx.get(editorViewCtx);
     return command(view.state, view.dispatch, view);
···
       state,
       nodeViews,
       markViews,
-      transformPasted: (slice, view2, isPlainText) => {
+      transformPasted: (slice2, view2, isPlainText) => {
         ctx.get(pasteRulesCtx).sort((a, b) => (b.priority ?? 50) - (a.priority ?? 50)).map((rule) => rule.run).forEach((runner) => {
-          slice = runner(slice, view2, isPlainText);
+          slice2 = runner(slice2, view2, isPlainText);
         });
-        return slice;
+        return slice2;
       },
       ...options
     });
···
   return plugin;
 }
 function $ctx(value, name) {
-  const slice = createSlice(value, name);
+  const slice2 = createSlice(value, name);
   const plugin = (ctx) => {
-    ctx.inject(slice);
+    ctx.inject(slice2);
     return () => {
       return () => {
-        ctx.remove(slice);
+        ctx.remove(slice2);
       };
     };
   };
-  plugin.key = slice;
+  plugin.key = slice2;
   return plugin;
 }
 function $nodeSchema(id, schema3) {
···
   result.options = options;
   return result;
 }
-function callCommand(slice, payload) {
+function callCommand(slice2, payload) {
   return (ctx) => {
-    return ctx.get(commandsCtx).call(slice, payload);
+    return ctx.get(commandsCtx).call(slice2, payload);
   };
 }
 
···
     if (dispatch) {
       let nestedBefore = nodeBefore.lastChild && nodeBefore.lastChild.type == parent.type;
       let inner = Fragment.from(nestedBefore ? itemType.create() : null);
-      let slice = new Slice2(Fragment.from(itemType.create(null, Fragment.from(parent.type.create(null, inner)))), nestedBefore ? 3 : 1, 0);
+      let slice2 = new Slice2(Fragment.from(itemType.create(null, Fragment.from(parent.type.create(null, inner)))), nestedBefore ? 3 : 1, 0);
       let before = range.start, after = range.end;
-      dispatch(state.tr.step(new ReplaceAroundStep(before - (nestedBefore ? 3 : 1), after, before, after, slice, 1, true)).scrollIntoView());
+      dispatch(state.tr.step(new ReplaceAroundStep(before - (nestedBefore ? 3 : 1), after, before, after, slice2, 1, true)).scrollIntoView());
     }
     return true;
   };
···
   (ctx) => () => (state, dispatch) => {
     const { selection, tr } = state;
     if (selection.empty) return false;
-    const { from, to } = selection;
-    const has = state.doc.rangeHasMark(from, to, inlineCodeSchema.type(ctx));
+    const { from: from2, to } = selection;
+    const has = state.doc.rangeHasMark(from2, to, inlineCodeSchema.type(ctx));
     if (has) {
-      dispatch?.(tr.removeMark(from, to, inlineCodeSchema.type(ctx)));
+      dispatch?.(tr.removeMark(from2, to, inlineCodeSchema.type(ctx)));
       return true;
     }
     const restMarksName = Object.keys(state.schema.marks).filter(
       (x) => x !== inlineCodeSchema.type.name
     );
     restMarksName.map((name) => state.schema.marks[name]).forEach((t) => {
-      tr.removeMark(from, to, t);
+      tr.removeMark(from2, to, t);
     });
-    dispatch?.(tr.addMark(from, to, inlineCodeSchema.type(ctx).create()));
+    dispatch?.(tr.addMark(from2, to, inlineCodeSchema.type(ctx).create()));
     return true;
   }
 );
···
     let node2;
     let pos = -1;
     const { selection } = state;
-    const { from, to } = selection;
-    state.doc.nodesBetween(from, from === to ? to + 1 : to, (n, p) => {
+    const { from: from2, to } = selection;
+    state.doc.nodesBetween(from2, from2 === to ? to + 1 : to, (n, p) => {
       if (linkSchema.type(ctx).isInSet(n.marks)) {
         node2 = n;
         pos = p;
···
     if (!dispatch) return true;
     const paragraph2 = paragraphSchema.node.type(ctx).create();
     const { tr, selection } = state;
-    const { from } = selection;
+    const { from: from2 } = selection;
     const node2 = hrSchema.type(ctx).create();
     if (!node2) return true;
-    const _tr = tr.replaceSelectionWith(node2).insert(from, paragraph2);
-    const sel = Selection.findFrom(_tr.doc.resolve(from), 1, true);
+    const _tr = tr.replaceSelectionWith(node2).insert(from2, paragraph2);
+    const sel = Selection.findFrom(_tr.doc.resolve(from2), 1, true);
     if (!sel) return true;
     dispatch(_tr.setSelection(sel).scrollIntoView());
     return true;
···
   () => () => (state, dispatch) => {
     let tr = state.tr;
     const { $from, $to } = tr.selection;
-    const { pos: from } = $from;
+    const { pos: from2 } = $from;
     const { pos: right } = $to;
-    const left = from - $from.node().content.size;
+    const left = from2 - $from.node().content.size;
     if (left < 0) return false;
     tr = tr.deleteRange(left, right);
     dispatch?.(tr);
···
     const { nodeType, attrs = null } = payload ?? {};
     if (!nodeType) return false;
     const tr = state.tr;
-    const { from, to } = tr.selection;
+    const { from: from2, to } = tr.selection;
     try {
-      tr.setBlockType(from, to, nodeType, attrs);
+      tr.setBlockType(from2, to, nodeType, attrs);
     } catch {
       return false;
     }
···
             requestAnimationFrame(() => {
               const active = inlineNodesCursorPlugin2.getState(view.state);
               if (active) {
-                const from = view.state.selection.from;
+                const from2 = view.state.selection.from;
                 e.preventDefault();
-                view.dispatch(view.state.tr.insertText(e.data || "", from));
+                view.dispatch(view.state.tr.insertText(e.data || "", from2));
               }
             });
             return true;
···
         beforeinput: (view, e) => {
           const active = inlineNodesCursorPlugin2.getState(view.state);
           if (active && e instanceof InputEvent && e.data && !lock) {
-            const from = view.state.selection.from;
+            const from2 = view.state.selection.from;
             e.preventDefault();
-            view.dispatch(view.state.tr.insertText(e.data || "", from));
+            view.dispatch(view.state.tr.insertText(e.data || "", from2));
             return true;
           }
           return false;
···
       const isInsertHr = tr.getMeta("hardbreak");
       if (isInsertHr) {
         if (!(step instanceof ReplaceStep)) return;
-        const { from } = step;
+        const { from: from2 } = step;
         return newState.tr.setNodeMarkup(
-          from,
+          from2,
           hardbreakSchema.type(ctx),
           void 0,
           []
···
       const isAddMarkStep = step instanceof AddMarkStep;
       if (isAddMarkStep) {
         let _tr = newState.tr;
-        const { from, to } = step;
-        newState.doc.nodesBetween(from, to, (node2, pos) => {
+        const { from: from2, to } = step;
+        newState.doc.nodesBetween(from2, to, (node2, pos) => {
           if (node2.type === hardbreakSchema.type(ctx))
             _tr = _tr.setNodeMarkup(
               pos,
···
       const isInsertHr = tr.getMeta("hardbreak");
       const [step] = tr.steps;
       if (isInsertHr && step) {
-        const { from } = step;
-        const $from = state.doc.resolve(from);
+        const { from: from2 } = step;
+        const $from = state.doc.resolve(from2);
         let curDepth = $from.depth;
         let canApply = true;
         while (curDepth > 0) {
···
       const { state, composing } = view;
       const { selection, doc: doc4 } = state;
       const { ranges } = selection;
-      const from = Math.min(...ranges.map((range) => range.$from.pos));
+      const from2 = Math.min(...ranges.map((range) => range.$from.pos));
       const to = Math.max(...ranges.map((range) => range.$to.pos));
       const isSame = prevState && prevState.doc.eq(doc4) && prevState.selection.eq(selection);
       if (!this.#initialized) {
···
         return;
       }
       const virtualEl = {
-        getBoundingClientRect: () => posToDOMRect(view, from, to),
+        getBoundingClientRect: () => posToDOMRect(view, from2, to),
         contextElement: view.dom
       };
       if (this.#shouldAutoUpdate(view)) {
···
   /// @internal
   #_shouldShow(view) {
     const { doc: doc4, selection } = view.state;
-    const { empty: empty3, from, to } = selection;
-    const isEmptyTextBlock = !doc4.textBetween(from, to).length && view.state.selection instanceof TextSelection;
+    const { empty: empty3, from: from2, to } = selection;
+    const isEmptyTextBlock = !doc4.textBetween(from2, to).length && view.state.selection instanceof TextSelection;
     const isTooltipChildren = this.element.contains(document.activeElement);
     const notHasFocus = !view.hasFocus() && !isTooltipChildren;
     const isReadonly = !view.editable;
···
   };
   return result;
 }
+
+// node_modules/rope-sequence/dist/index.js
+var GOOD_LEAF_SIZE = 200;
+var RopeSequence = function RopeSequence2() {
+};
+RopeSequence.prototype.append = function append(other) {
+  if (!other.length) {
+    return this;
+  }
+  other = RopeSequence.from(other);
+  return !this.length && other || other.length < GOOD_LEAF_SIZE && this.leafAppend(other) || this.length < GOOD_LEAF_SIZE && other.leafPrepend(this) || this.appendInner(other);
+};
+RopeSequence.prototype.prepend = function prepend(other) {
+  if (!other.length) {
+    return this;
+  }
+  return RopeSequence.from(other).append(this);
+};
+RopeSequence.prototype.appendInner = function appendInner(other) {
+  return new Append(this, other);
+};
+RopeSequence.prototype.slice = function slice(from2, to) {
+  if (from2 === void 0) from2 = 0;
+  if (to === void 0) to = this.length;
+  if (from2 >= to) {
+    return RopeSequence.empty;
+  }
+  return this.sliceInner(Math.max(0, from2), Math.min(this.length, to));
+};
+RopeSequence.prototype.get = function get(i) {
+  if (i < 0 || i >= this.length) {
+    return void 0;
+  }
+  return this.getInner(i);
+};
+RopeSequence.prototype.forEach = function forEach(f, from2, to) {
+  if (from2 === void 0) from2 = 0;
+  if (to === void 0) to = this.length;
+  if (from2 <= to) {
+    this.forEachInner(f, from2, to, 0);
+  } else {
+    this.forEachInvertedInner(f, from2, to, 0);
+  }
+};
+RopeSequence.prototype.map = function map4(f, from2, to) {
+  if (from2 === void 0) from2 = 0;
+  if (to === void 0) to = this.length;
+  var result = [];
+  this.forEach(function(elt, i) {
+    return result.push(f(elt, i));
+  }, from2, to);
+  return result;
+};
+RopeSequence.from = function from(values) {
+  if (values instanceof RopeSequence) {
+    return values;
+  }
+  return values && values.length ? new Leaf(values) : RopeSequence.empty;
+};
+var Leaf = /* @__PURE__ */ (function(RopeSequence3) {
+  function Leaf2(values) {
+    RopeSequence3.call(this);
+    this.values = values;
+  }
+  if (RopeSequence3) Leaf2.__proto__ = RopeSequence3;
+  Leaf2.prototype = Object.create(RopeSequence3 && RopeSequence3.prototype);
+  Leaf2.prototype.constructor = Leaf2;
+  var prototypeAccessors = { length: { configurable: true }, depth: { configurable: true } };
+  Leaf2.prototype.flatten = function flatten() {
+    return this.values;
+  };
+  Leaf2.prototype.sliceInner = function sliceInner(from2, to) {
+    if (from2 == 0 && to == this.length) {
+      return this;
+    }
+    return new Leaf2(this.values.slice(from2, to));
+  };
+  Leaf2.prototype.getInner = function getInner(i) {
+    return this.values[i];
+  };
+  Leaf2.prototype.forEachInner = function forEachInner(f, from2, to, start) {
+    for (var i = from2; i < to; i++) {
+      if (f(this.values[i], start + i) === false) {
+        return false;
+      }
+    }
+  };
+  Leaf2.prototype.forEachInvertedInner = function forEachInvertedInner(f, from2, to, start) {
+    for (var i = from2 - 1; i >= to; i--) {
+      if (f(this.values[i], start + i) === false) {
+        return false;
+      }
+    }
+  };
+  Leaf2.prototype.leafAppend = function leafAppend(other) {
+    if (this.length + other.length <= GOOD_LEAF_SIZE) {
+      return new Leaf2(this.values.concat(other.flatten()));
+    }
+  };
+  Leaf2.prototype.leafPrepend = function leafPrepend(other) {
+    if (this.length + other.length <= GOOD_LEAF_SIZE) {
+      return new Leaf2(other.flatten().concat(this.values));
+    }
+  };
+  prototypeAccessors.length.get = function() {
+    return this.values.length;
+  };
+  prototypeAccessors.depth.get = function() {
+    return 0;
+  };
+  Object.defineProperties(Leaf2.prototype, prototypeAccessors);
+  return Leaf2;
+})(RopeSequence);
+RopeSequence.empty = new Leaf([]);
+var Append = /* @__PURE__ */ (function(RopeSequence3) {
+  function Append2(left, right) {
+    RopeSequence3.call(this);
+    this.left = left;
+    this.right = right;
+    this.length = left.length + right.length;
+    this.depth = Math.max(left.depth, right.depth) + 1;
+  }
+  if (RopeSequence3) Append2.__proto__ = RopeSequence3;
+  Append2.prototype = Object.create(RopeSequence3 && RopeSequence3.prototype);
+  Append2.prototype.constructor = Append2;
+  Append2.prototype.flatten = function flatten() {
+    return this.left.flatten().concat(this.right.flatten());
+  };
+  Append2.prototype.getInner = function getInner(i) {
+    return i < this.left.length ? this.left.get(i) : this.right.get(i - this.left.length);
+  };
+  Append2.prototype.forEachInner = function forEachInner(f, from2, to, start) {
+    var leftLen = this.left.length;
+    if (from2 < leftLen && this.left.forEachInner(f, from2, Math.min(to, leftLen), start) === false) {
+      return false;
+    }
+    if (to > leftLen && this.right.forEachInner(f, Math.max(from2 - leftLen, 0), Math.min(this.length, to) - leftLen, start + leftLen) === false) {
+      return false;
+    }
+  };
+  Append2.prototype.forEachInvertedInner = function forEachInvertedInner(f, from2, to, start) {
+    var leftLen = this.left.length;
+    if (from2 > leftLen && this.right.forEachInvertedInner(f, from2 - leftLen, Math.max(to, leftLen) - leftLen, start + leftLen) === false) {
+      return false;
+    }
+    if (to < leftLen && this.left.forEachInvertedInner(f, Math.min(from2, leftLen), to, start) === false) {
+      return false;
+    }
+  };
+  Append2.prototype.sliceInner = function sliceInner(from2, to) {
+    if (from2 == 0 && to == this.length) {
+      return this;
+    }
+    var leftLen = this.left.length;
+    if (to <= leftLen) {
+      return this.left.slice(from2, to);
+    }
+    if (from2 >= leftLen) {
+      return this.right.slice(from2 - leftLen, to - leftLen);
+    }
+    return this.left.slice(from2, leftLen).append(this.right.slice(0, to - leftLen));
+  };
+  Append2.prototype.leafAppend = function leafAppend(other) {
+    var inner = this.right.leafAppend(other);
+    if (inner) {
+      return new Append2(this.left, inner);
+    }
+  };
+  Append2.prototype.leafPrepend = function leafPrepend(other) {
+    var inner = this.left.leafPrepend(other);
+    if (inner) {
+      return new Append2(inner, this.right);
+    }
+  };
+  Append2.prototype.appendInner = function appendInner2(other) {
+    if (this.left.depth >= Math.max(this.right.depth, other.depth) + 1) {
+      return new Append2(this.left, new Append2(this.right, other));
+    }
+    return new Append2(this, other);
+  };
+  return Append2;
+})(RopeSequence);
+var dist_default2 = RopeSequence;
+
+// node_modules/prosemirror-history/dist/index.js
+var max_empty_items = 500;
+var Branch = class _Branch {
+  constructor(items, eventCount) {
+    this.items = items;
+    this.eventCount = eventCount;
+  }
+  // Pop the latest event off the branch's history and apply it
+  // to a document transform.
+  popEvent(state, preserveItems) {
+    if (this.eventCount == 0)
+      return null;
+    let end = this.items.length;
+    for (; ; end--) {
+      let next = this.items.get(end - 1);
+      if (next.selection) {
+        --end;
+        break;
+      }
+    }
+    let remap, mapFrom;
+    if (preserveItems) {
+      remap = this.remapping(end, this.items.length);
+      mapFrom = remap.maps.length;
+    }
+    let transform = state.tr;
+    let selection, remaining;
+    let addAfter = [], addBefore = [];
+    this.items.forEach((item, i) => {
+      if (!item.step) {
+        if (!remap) {
+          remap = this.remapping(end, i + 1);
+          mapFrom = remap.maps.length;
+        }
+        mapFrom--;
+        addBefore.push(item);
+        return;
+      }
+      if (remap) {
+        addBefore.push(new Item(item.map));
+        let step = item.step.map(remap.slice(mapFrom)), map5;
+        if (step && transform.maybeStep(step).doc) {
+          map5 = transform.mapping.maps[transform.mapping.maps.length - 1];
+          addAfter.push(new Item(map5, void 0, void 0, addAfter.length + addBefore.length));
+        }
+        mapFrom--;
+        if (map5)
+          remap.appendMap(map5, mapFrom);
+      } else {
+        transform.maybeStep(item.step);
+      }
+      if (item.selection) {
+        selection = remap ? item.selection.map(remap.slice(mapFrom)) : item.selection;
+        remaining = new _Branch(this.items.slice(0, end).append(addBefore.reverse().concat(addAfter)), this.eventCount - 1);
+        return false;
+      }
+    }, this.items.length, 0);
+    return { remaining, transform, selection };
+  }
+  // Create a new branch with the given transform added.
+  addTransform(transform, selection, histOptions, preserveItems) {
+    let newItems = [], eventCount = this.eventCount;
+    let oldItems = this.items, lastItem = !preserveItems && oldItems.length ? oldItems.get(oldItems.length - 1) : null;
+    for (let i = 0; i < transform.steps.length; i++) {
+      let step = transform.steps[i].invert(transform.docs[i]);
+      let item = new Item(transform.mapping.maps[i], step, selection), merged;
+      if (merged = lastItem && lastItem.merge(item)) {
+        item = merged;
+        if (i)
+          newItems.pop();
+        else
+          oldItems = oldItems.slice(0, oldItems.length - 1);
+      }
+      newItems.push(item);
+      if (selection) {
+        eventCount++;
+        selection = void 0;
+      }
+      if (!preserveItems)
+        lastItem = item;
+    }
+    let overflow = eventCount - histOptions.depth;
+    if (overflow > DEPTH_OVERFLOW) {
+      oldItems = cutOffEvents(oldItems, overflow);
+      eventCount -= overflow;
+    }
+    return new _Branch(oldItems.append(newItems), eventCount);
+  }
+  remapping(from2, to) {
+    let maps = new Mapping();
+    this.items.forEach((item, i) => {
+      let mirrorPos = item.mirrorOffset != null && i - item.mirrorOffset >= from2 ? maps.maps.length - item.mirrorOffset : void 0;
+      maps.appendMap(item.map, mirrorPos);
+    }, from2, to);
+    return maps;
+  }
+  addMaps(array) {
+    if (this.eventCount == 0)
+      return this;
+    return new _Branch(this.items.append(array.map((map5) => new Item(map5))), this.eventCount);
+  }
+  // When the collab module receives remote changes, the history has
+  // to know about those, so that it can adjust the steps that were
+  // rebased on top of the remote changes, and include the position
+  // maps for the remote changes in its array of items.
+  rebased(rebasedTransform, rebasedCount) {
+    if (!this.eventCount)
+      return this;
+    let rebasedItems = [], start = Math.max(0, this.items.length - rebasedCount);
+    let mapping = rebasedTransform.mapping;
+    let newUntil = rebasedTransform.steps.length;
+    let eventCount = this.eventCount;
+    this.items.forEach((item) => {
+      if (item.selection)
+        eventCount--;
+    }, start);
+    let iRebased = rebasedCount;
+    this.items.forEach((item) => {
+      let pos = mapping.getMirror(--iRebased);
+      if (pos == null)
+        return;
+      newUntil = Math.min(newUntil, pos);
+      let map5 = mapping.maps[pos];
+      if (item.step) {
+        let step = rebasedTransform.steps[pos].invert(rebasedTransform.docs[pos]);
+        let selection = item.selection && item.selection.map(mapping.slice(iRebased + 1, pos));
+        if (selection)
+          eventCount++;
+        rebasedItems.push(new Item(map5, step, selection));
+      } else {
+        rebasedItems.push(new Item(map5));
+      }
+    }, start);
+    let newMaps = [];
+    for (let i = rebasedCount; i < newUntil; i++)
+      newMaps.push(new Item(mapping.maps[i]));
+    let items = this.items.slice(0, start).append(newMaps).append(rebasedItems);
+    let branch = new _Branch(items, eventCount);
+    if (branch.emptyItemCount() > max_empty_items)
+      branch = branch.compress(this.items.length - rebasedItems.length);
+    return branch;
+  }
+  emptyItemCount() {
+    let count = 0;
+    this.items.forEach((item) => {
+      if (!item.step)
+        count++;
+    });
+    return count;
+  }
+  // Compressing a branch means rewriting it to push the air (map-only
+  // items) out. During collaboration, these naturally accumulate
+  // because each remote change adds one. The `upto` argument is used
+  // to ensure that only the items below a given level are compressed,
+  // because `rebased` relies on a clean, untouched set of items in
+  // order to associate old items with rebased steps.
+  compress(upto = this.items.length) {
+    let remap = this.remapping(0, upto), mapFrom = remap.maps.length;
+    let items = [], events = 0;
+    this.items.forEach((item, i) => {
+      if (i >= upto) {
+        items.push(item);
+        if (item.selection)
+          events++;
+      } else if (item.step) {
+        let step = item.step.map(remap.slice(mapFrom)), map5 = step && step.getMap();
+        mapFrom--;
+        if (map5)
+          remap.appendMap(map5, mapFrom);
+        if (step) {
+          let selection = item.selection && item.selection.map(remap.slice(mapFrom));
+          if (selection)
+            events++;
+          let newItem = new Item(map5.invert(), step, selection), merged, last = items.length - 1;
+          if (merged = items.length && items[last].merge(newItem))
+            items[last] = merged;
+          else
+            items.push(newItem);
+        }
+      } else if (item.map) {
+        mapFrom--;
+      }
+    }, this.items.length, 0);
+    return new _Branch(dist_default2.from(items.reverse()), events);
+  }
+};
+Branch.empty = new Branch(dist_default2.empty, 0);
+function cutOffEvents(items, n) {
+  let cutPoint;
+  items.forEach((item, i) => {
+    if (item.selection && n-- == 0) {
+      cutPoint = i;
+      return false;
+    }
+  });
+  return items.slice(cutPoint);
+}
+var Item = class _Item {
+  constructor(map5, step, selection, mirrorOffset) {
+    this.map = map5;
+    this.step = step;
+    this.selection = selection;
+    this.mirrorOffset = mirrorOffset;
+  }
+  merge(other) {
+    if (this.step && other.step && !other.selection) {
+      let step = other.step.merge(this.step);
+      if (step)
+        return new _Item(step.getMap().invert(), step, this.selection);
+    }
+  }
+};
+var HistoryState = class {
+  constructor(done, undone, prevRanges, prevTime, prevComposition) {
+    this.done = done;
+    this.undone = undone;
+    this.prevRanges = prevRanges;
+    this.prevTime = prevTime;
+    this.prevComposition = prevComposition;
+  }
+};
+var DEPTH_OVERFLOW = 20;
+function applyTransaction(history3, state, tr, options) {
+  let historyTr = tr.getMeta(historyKey), rebased;
+  if (historyTr)
+    return historyTr.historyState;
+  if (tr.getMeta(closeHistoryKey))
+    history3 = new HistoryState(history3.done, history3.undone, null, 0, -1);
+  let appended = tr.getMeta("appendedTransaction");
+  if (tr.steps.length == 0) {
+    return history3;
+  } else if (appended && appended.getMeta(historyKey)) {
+    if (appended.getMeta(historyKey).redo)
+      return new HistoryState(history3.done.addTransform(tr, void 0, options, mustPreserveItems(state)), history3.undone, rangesFor(tr.mapping.maps), history3.prevTime, history3.prevComposition);
+    else
+      return new HistoryState(history3.done, history3.undone.addTransform(tr, void 0, options, mustPreserveItems(state)), null, history3.prevTime, history3.prevComposition);
+  } else if (tr.getMeta("addToHistory") !== false && !(appended && appended.getMeta("addToHistory") === false)) {
+    let composition = tr.getMeta("composition");
+    let newGroup = history3.prevTime == 0 || !appended && history3.prevComposition != composition && (history3.prevTime < (tr.time || 0) - options.newGroupDelay || !isAdjacentTo(tr, history3.prevRanges));
+    let prevRanges = appended ? mapRanges(history3.prevRanges, tr.mapping) : rangesFor(tr.mapping.maps);
+    return new HistoryState(history3.done.addTransform(tr, newGroup ? state.selection.getBookmark() : void 0, options, mustPreserveItems(state)), Branch.empty, prevRanges, tr.time, composition == null ? history3.prevComposition : composition);
+  } else if (rebased = tr.getMeta("rebased")) {
+    return new HistoryState(history3.done.rebased(tr, rebased), history3.undone.rebased(tr, rebased), mapRanges(history3.prevRanges, tr.mapping), history3.prevTime, history3.prevComposition);
+  } else {
+    return new HistoryState(history3.done.addMaps(tr.mapping.maps), history3.undone.addMaps(tr.mapping.maps), mapRanges(history3.prevRanges, tr.mapping), history3.prevTime, history3.prevComposition);
+  }
+}
+function isAdjacentTo(transform, prevRanges) {
+  if (!prevRanges)
+    return false;
+  if (!transform.docChanged)
+    return true;
+  let adjacent = false;
+  transform.mapping.maps[0].forEach((start, end) => {
+    for (let i = 0; i < prevRanges.length; i += 2)
+      if (start <= prevRanges[i + 1] && end >= prevRanges[i])
+        adjacent = true;
+  });
+  return adjacent;
+}
+function rangesFor(maps) {
+  let result = [];
+  for (let i = maps.length - 1; i >= 0 && result.length == 0; i--)
+    maps[i].forEach((_from, _to, from2, to) => result.push(from2, to));
+  return result;
+}
+function mapRanges(ranges, mapping) {
+  if (!ranges)
+    return null;
+  let result = [];
+  for (let i = 0; i < ranges.length; i += 2) {
+    let from2 = mapping.map(ranges[i], 1), to = mapping.map(ranges[i + 1], -1);
+    if (from2 <= to)
+      result.push(from2, to);
+  }
+  return result;
+}
+function histTransaction(history3, state, redo2) {
+  let preserveItems = mustPreserveItems(state);
+  let histOptions = historyKey.get(state).spec.config;
+  let pop = (redo2 ? history3.undone : history3.done).popEvent(state, preserveItems);
+  if (!pop)
+    return null;
+  let selection = pop.selection.resolve(pop.transform.doc);
+  let added = (redo2 ? history3.done : history3.undone).addTransform(pop.transform, state.selection.getBookmark(), histOptions, preserveItems);
+  let newHist = new HistoryState(redo2 ? added : pop.remaining, redo2 ? pop.remaining : added, null, 0, -1);
+  return pop.transform.setSelection(selection).setMeta(historyKey, { redo: redo2, historyState: newHist });
+}
+var cachedPreserveItems = false;
+var cachedPreserveItemsPlugins = null;
+function mustPreserveItems(state) {
+  let plugins2 = state.plugins;
+  if (cachedPreserveItemsPlugins != plugins2) {
+    cachedPreserveItems = false;
+    cachedPreserveItemsPlugins = plugins2;
+    for (let i = 0; i < plugins2.length; i++)
+      if (plugins2[i].spec.historyPreserveItems) {
+        cachedPreserveItems = true;
+        break;
+      }
+  }
+  return cachedPreserveItems;
+}
+var historyKey = new PluginKey("history");
+var closeHistoryKey = new PluginKey("closeHistory");
+function history(config2 = {}) {
+  config2 = {
+    depth: config2.depth || 100,
+    newGroupDelay: config2.newGroupDelay || 500
+  };
+  return new Plugin({
+    key: historyKey,
+    state: {
+      init() {
+        return new HistoryState(Branch.empty, Branch.empty, null, 0, -1);
+      },
+      apply(tr, hist, state) {
+        return applyTransaction(hist, state, tr, config2);
+      }
+    },
+    config: config2,
+    props: {
+      handleDOMEvents: {
+        beforeinput(view, e) {
+          let inputType = e.inputType;
+          let command = inputType == "historyUndo" ? undo : inputType == "historyRedo" ? redo : null;
+          if (!command || !view.editable)
+            return false;
+          e.preventDefault();
+          return command(view.state, view.dispatch);
+        }
+      }
+    }
+  });
+}
+function buildCommand(redo2, scroll) {
+  return (state, dispatch) => {
+    let hist = historyKey.getState(state);
+    if (!hist || (redo2 ? hist.undone : hist.done).eventCount == 0)
+      return false;
+    if (dispatch) {
+      let tr = histTransaction(hist, state, redo2);
+      if (tr)
+        dispatch(scroll ? tr.scrollIntoView() : tr);
+    }
+    return true;
+  };
+}
+var undo = buildCommand(false, true);
+var redo = buildCommand(true, true);
+var undoNoScroll = buildCommand(false, false);
+var redoNoScroll = buildCommand(true, false);
+
+// node_modules/@milkdown/plugin-history/lib/index.js
+function withMeta3(plugin, meta) {
+  Object.assign(plugin, {
+    meta: {
+      package: "@milkdown/plugin-history",
+      ...meta
+    }
+  });
+  return plugin;
+}
+var undoCommand = $command("Undo", () => () => undo);
+withMeta3(undoCommand, {
+  displayName: "Command<undo>"
+});
+var redoCommand = $command("Redo", () => () => redo);
+withMeta3(redoCommand, {
+  displayName: "Command<redo>"
+});
+var historyProviderConfig = $ctx({}, "historyProviderConfig");
+withMeta3(historyProviderConfig, {
+  displayName: "Ctx<historyProviderConfig>"
+});
+var historyProviderPlugin = $prose(
+  (ctx) => history(ctx.get(historyProviderConfig.key))
+);
+withMeta3(historyProviderPlugin, {
+  displayName: "Ctx<historyProviderPlugin>"
+});
+var historyKeymap = $useKeymap("historyKeymap", {
+  Undo: {
+    shortcuts: "Mod-z",
+    command: (ctx) => {
+      const commands3 = ctx.get(commandsCtx);
+      return () => commands3.call(undoCommand.key);
+    }
+  },
+  Redo: {
+    shortcuts: ["Mod-y", "Shift-Mod-z"],
+    command: (ctx) => {
+      const commands3 = ctx.get(commandsCtx);
+      return () => commands3.call(redoCommand.key);
+    }
+  }
+});
+withMeta3(historyKeymap.ctx, {
+  displayName: "KeymapCtx<history>"
+});
+withMeta3(historyKeymap.shortcuts, {
+  displayName: "Keymap<history>"
+});
+var history2 = [
+  historyProviderConfig,
+  historyProviderPlugin,
+  historyKeymap,
+  undoCommand,
+  redoCommand
+].flat();
 export {
   Editor,
   TooltipProvider,
···
   commonmark,
   defaultValueCtx,
   editorViewCtx,
+  history2 as history,
   listener,
   listenerCtx,
+  redoCommand,
   rootCtx,
   serializerCtx,
   toggleEmphasisCommand,
   toggleStrongCommand,
   tooltipFactory,
   turnIntoTextCommand,
+  undoCommand,
   wrapInBlockquoteCommand,
   wrapInBulletListCommand,
   wrapInHeadingCommand

templates/document_edit.html

···
         <div class="toolbar-actions">
             <button class="btn btn-sm btn-outline source-only active" id="btn-preview" onclick="togglePreview()">Preview</button>
             <button class="btn btn-sm btn-outline source-only" id="btn-wrap" onclick="toggleWrap()">Wrap</button>
+            <button class="btn btn-sm btn-outline rich-only" id="btn-undo" onclick="richUndo()" title="Undo (⌘Z)">↩</button>
+            <button class="btn btn-sm btn-outline rich-only" id="btn-redo" onclick="richRedo()" title="Redo (⌘⇧Z)">↪</button>
             <button class="btn btn-sm btn-outline" id="btn-source" onclick="toggleSourceMode()">Source</button>
             <span id="save-status"></span>
             <button class="btn btn-sm" id="btn-save" onclick="saveDocument()">Save</button>
···
         Editor, rootCtx, defaultValueCtx, editorViewCtx, serializerCtx,
         commonmark,
         listener, listenerCtx,
+        history, undoCommand, redoCommand, callCommand,
     } from '/static/vendor/milkdown.js';
 
     const textarea = document.getElementById('editor-textarea');
···
                 ctx.set(defaultValueCtx, initialMarkdown);
             })
             .use(commonmark)
+            .use(history)
             .use(listener)
             .config((ctx) => {
                 ctx.get(listenerCtx).markdownUpdated((_ctx, markdown, prevMarkdown) => {
···
         return milkdownEditor;
     }
 
+    // ── Undo / Redo ───────────────────────────────────────────────────────────
+
+    window.richUndo = function() {
+        if (milkdownEditor) milkdownEditor.action(callCommand(undoCommand.key));
+    };
+    window.richRedo = function() {
+        if (milkdownEditor) milkdownEditor.action(callCommand(redoCommand.key));
+    };
+
     // ── Mode switching ────────────────────────────────────────────────────────
 
     function applyMode(mode, animate) {
         const richEl = document.getElementById('editor-rich');
         const sourceEl = document.getElementById('editor-source');
         const sourceOnlyBtns = document.querySelectorAll('.source-only');
+        const richOnlyBtns = document.querySelectorAll('.rich-only');
         const sourceBtn = document.getElementById('btn-source');
 
         if (mode === 'source') {
             richEl.style.display = 'none';
             sourceEl.style.display = '';
             sourceOnlyBtns.forEach(b => b.style.display = '');
+            richOnlyBtns.forEach(b => b.style.display = 'none');
             sourceBtn.classList.add('active');
         } else {
             richEl.style.display = '';
             sourceEl.style.display = 'none';
             sourceOnlyBtns.forEach(b => b.style.display = 'none');
+            richOnlyBtns.forEach(b => b.style.display = '');
             sourceBtn.classList.remove('active');
         }
     }