@blockslides/extension-add-slide-button 0.1.0

package/dist/index.js

@@ -0,0 +1,3236 @@
+// src/add-slide-button.ts
+import { Extension, createStyleTag } from "@blockslides/core";
+
+// ../../node_modules/.pnpm/prosemirror-model@1.25.3/node_modules/prosemirror-model/dist/index.js
+function findDiffStart(a, b, pos) {
+  for (let i = 0; ; i++) {
+    if (i == a.childCount || i == b.childCount)
+      return a.childCount == b.childCount ? null : pos;
+    let childA = a.child(i), childB = b.child(i);
+    if (childA == childB) {
+      pos += childA.nodeSize;
+      continue;
+    }
+    if (!childA.sameMarkup(childB))
+      return pos;
+    if (childA.isText && childA.text != childB.text) {
+      for (let j = 0; childA.text[j] == childB.text[j]; j++)
+        pos++;
+      return pos;
+    }
+    if (childA.content.size || childB.content.size) {
+      let inner = findDiffStart(childA.content, childB.content, pos + 1);
+      if (inner != null)
+        return inner;
+    }
+    pos += childA.nodeSize;
+  }
+}
+function findDiffEnd(a, b, posA, posB) {
+  for (let iA = a.childCount, iB = b.childCount; ; ) {
+    if (iA == 0 || iB == 0)
+      return iA == iB ? null : { a: posA, b: posB };
+    let childA = a.child(--iA), childB = b.child(--iB), size = childA.nodeSize;
+    if (childA == childB) {
+      posA -= size;
+      posB -= size;
+      continue;
+    }
+    if (!childA.sameMarkup(childB))
+      return { a: posA, b: posB };
+    if (childA.isText && childA.text != childB.text) {
+      let same = 0, minSize = Math.min(childA.text.length, childB.text.length);
+      while (same < minSize && childA.text[childA.text.length - same - 1] == childB.text[childB.text.length - same - 1]) {
+        same++;
+        posA--;
+        posB--;
+      }
+      return { a: posA, b: posB };
+    }
+    if (childA.content.size || childB.content.size) {
+      let inner = findDiffEnd(childA.content, childB.content, posA - 1, posB - 1);
+      if (inner)
+        return inner;
+    }
+    posA -= size;
+    posB -= size;
+  }
+}
+var Fragment = class _Fragment {
+  /**
+  @internal
+  */
+  constructor(content, size) {
+    this.content = content;
+    this.size = size || 0;
+    if (size == null)
+      for (let i = 0; i < content.length; i++)
+        this.size += content[i].nodeSize;
+  }
+  /**
+  Invoke a callback for all descendant nodes between the given two
+  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) {
+    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) {
+        let start = pos + 1;
+        child.nodesBetween(Math.max(0, from - start), Math.min(child.content.size, to - start), f, nodeStart + start);
+      }
+      pos = end;
+    }
+  }
+  /**
+  Call the given callback for every descendant node. `pos` will be
+  relative to the start of the fragment. The callback may return
+  `false` to prevent traversal of a given node's children.
+  */
+  descendants(f) {
+    this.nodesBetween(0, this.size, f);
+  }
+  /**
+  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) {
+    let text = "", first = true;
+    this.nodesBetween(from, to, (node, pos) => {
+      let nodeText = node.isText ? node.text.slice(Math.max(from, pos) - pos, to - pos) : !node.isLeaf ? "" : leafText ? typeof leafText === "function" ? leafText(node) : leafText : node.type.spec.leafText ? node.type.spec.leafText(node) : "";
+      if (node.isBlock && (node.isLeaf && nodeText || node.isTextblock) && blockSeparator) {
+        if (first)
+          first = false;
+        else
+          text += blockSeparator;
+      }
+      text += nodeText;
+    }, 0);
+    return text;
+  }
+  /**
+  Create a new fragment containing the combined content of this
+  fragment and the other.
+  */
+  append(other) {
+    if (!other.size)
+      return this;
+    if (!this.size)
+      return other;
+    let last = this.lastChild, first = other.firstChild, content = this.content.slice(), i = 0;
+    if (last.isText && last.sameMarkup(first)) {
+      content[content.length - 1] = last.withText(last.text + first.text);
+      i = 1;
+    }
+    for (; i < other.content.length; i++)
+      content.push(other.content[i]);
+    return new _Fragment(content, this.size + other.size);
+  }
+  /**
+  Cut out the sub-fragment between the two given positions.
+  */
+  cut(from, to = this.size) {
+    if (from == 0 && to == this.size)
+      return this;
+    let result = [], size = 0;
+    if (to > from)
+      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 (child.isText)
+              child = child.cut(Math.max(0, from - 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));
+          }
+          result.push(child);
+          size += child.nodeSize;
+        }
+        pos = end;
+      }
+    return new _Fragment(result, size);
+  }
+  /**
+  @internal
+  */
+  cutByIndex(from, to) {
+    if (from == to)
+      return _Fragment.empty;
+    if (from == 0 && to == this.content.length)
+      return this;
+    return new _Fragment(this.content.slice(from, to));
+  }
+  /**
+  Create a new fragment in which the node at the given index is
+  replaced by the given node.
+  */
+  replaceChild(index, node) {
+    let current = this.content[index];
+    if (current == node)
+      return this;
+    let copy = this.content.slice();
+    let size = this.size + node.nodeSize - current.nodeSize;
+    copy[index] = node;
+    return new _Fragment(copy, size);
+  }
+  /**
+  Create a new fragment by prepending the given node to this
+  fragment.
+  */
+  addToStart(node) {
+    return new _Fragment([node].concat(this.content), this.size + node.nodeSize);
+  }
+  /**
+  Create a new fragment by appending the given node to this
+  fragment.
+  */
+  addToEnd(node) {
+    return new _Fragment(this.content.concat(node), this.size + node.nodeSize);
+  }
+  /**
+  Compare this fragment to another one.
+  */
+  eq(other) {
+    if (this.content.length != other.content.length)
+      return false;
+    for (let i = 0; i < this.content.length; i++)
+      if (!this.content[i].eq(other.content[i]))
+        return false;
+    return true;
+  }
+  /**
+  The first child of the fragment, or `null` if it is empty.
+  */
+  get firstChild() {
+    return this.content.length ? this.content[0] : null;
+  }
+  /**
+  The last child of the fragment, or `null` if it is empty.
+  */
+  get lastChild() {
+    return this.content.length ? this.content[this.content.length - 1] : null;
+  }
+  /**
+  The number of child nodes in this fragment.
+  */
+  get childCount() {
+    return this.content.length;
+  }
+  /**
+  Get the child node at the given index. Raise an error when the
+  index is out of range.
+  */
+  child(index) {
+    let found2 = this.content[index];
+    if (!found2)
+      throw new RangeError("Index " + index + " out of range for " + this);
+    return found2;
+  }
+  /**
+  Get the child node at the given index, if it exists.
+  */
+  maybeChild(index) {
+    return this.content[index] || null;
+  }
+  /**
+  Call `f` for every child node, passing the node, its offset
+  into this parent node, and its index.
+  */
+  forEach(f) {
+    for (let i = 0, p = 0; i < this.content.length; i++) {
+      let child = this.content[i];
+      f(child, p, i);
+      p += child.nodeSize;
+    }
+  }
+  /**
+  Find the first position at which this fragment and another
+  fragment differ, or `null` if they are the same.
+  */
+  findDiffStart(other, pos = 0) {
+    return findDiffStart(this, other, pos);
+  }
+  /**
+  Find the first position, searching from the end, at which this
+  fragment and the given fragment differ, or `null` if they are
+  the same. Since this position will not be the same in both
+  nodes, an object with two separate positions is returned.
+  */
+  findDiffEnd(other, pos = this.size, otherPos = other.size) {
+    return findDiffEnd(this, other, pos, otherPos);
+  }
+  /**
+  Find the index and inner offset corresponding to a given relative
+  position in this fragment. The result object will be reused
+  (overwritten) the next time the function is called. @internal
+  */
+  findIndex(pos) {
+    if (pos == 0)
+      return retIndex(0, pos);
+    if (pos == this.size)
+      return retIndex(this.content.length, pos);
+    if (pos > this.size || pos < 0)
+      throw new RangeError(`Position ${pos} outside of fragment (${this})`);
+    for (let i = 0, curPos = 0; ; i++) {
+      let cur = this.child(i), end = curPos + cur.nodeSize;
+      if (end >= pos) {
+        if (end == pos)
+          return retIndex(i + 1, end);
+        return retIndex(i, curPos);
+      }
+      curPos = end;
+    }
+  }
+  /**
+  Return a debugging string that describes this fragment.
+  */
+  toString() {
+    return "<" + this.toStringInner() + ">";
+  }
+  /**
+  @internal
+  */
+  toStringInner() {
+    return this.content.join(", ");
+  }
+  /**
+  Create a JSON-serializeable representation of this fragment.
+  */
+  toJSON() {
+    return this.content.length ? this.content.map((n) => n.toJSON()) : null;
+  }
+  /**
+  Deserialize a fragment from its JSON representation.
+  */
+  static fromJSON(schema, value) {
+    if (!value)
+      return _Fragment.empty;
+    if (!Array.isArray(value))
+      throw new RangeError("Invalid input for Fragment.fromJSON");
+    return new _Fragment(value.map(schema.nodeFromJSON));
+  }
+  /**
+  Build a fragment from an array of nodes. Ensures that adjacent
+  text nodes with the same marks are joined together.
+  */
+  static fromArray(array) {
+    if (!array.length)
+      return _Fragment.empty;
+    let joined, size = 0;
+    for (let i = 0; i < array.length; i++) {
+      let node = array[i];
+      size += node.nodeSize;
+      if (i && node.isText && array[i - 1].sameMarkup(node)) {
+        if (!joined)
+          joined = array.slice(0, i);
+        joined[joined.length - 1] = node.withText(joined[joined.length - 1].text + node.text);
+      } else if (joined) {
+        joined.push(node);
+      }
+    }
+    return new _Fragment(joined || array, size);
+  }
+  /**
+  Create a fragment from something that can be interpreted as a
+  set of nodes. For `null`, it returns the empty fragment. For a
+  fragment, the fragment itself. For a node or array of nodes, a
+  fragment containing those nodes.
+  */
+  static from(nodes) {
+    if (!nodes)
+      return _Fragment.empty;
+    if (nodes instanceof _Fragment)
+      return nodes;
+    if (Array.isArray(nodes))
+      return this.fromArray(nodes);
+    if (nodes.attrs)
+      return new _Fragment([nodes], nodes.nodeSize);
+    throw new RangeError("Can not convert " + nodes + " to a Fragment" + (nodes.nodesBetween ? " (looks like multiple versions of prosemirror-model were loaded)" : ""));
+  }
+};
+Fragment.empty = new Fragment([], 0);
+var found = { index: 0, offset: 0 };
+function retIndex(index, offset) {
+  found.index = index;
+  found.offset = offset;
+  return found;
+}
+function compareDeep(a, b) {
+  if (a === b)
+    return true;
+  if (!(a && typeof a == "object") || !(b && typeof b == "object"))
+    return false;
+  let array = Array.isArray(a);
+  if (Array.isArray(b) != array)
+    return false;
+  if (array) {
+    if (a.length != b.length)
+      return false;
+    for (let i = 0; i < a.length; i++)
+      if (!compareDeep(a[i], b[i]))
+        return false;
+  } else {
+    for (let p in a)
+      if (!(p in b) || !compareDeep(a[p], b[p]))
+        return false;
+    for (let p in b)
+      if (!(p in a))
+        return false;
+  }
+  return true;
+}
+var Mark = class _Mark {
+  /**
+  @internal
+  */
+  constructor(type, attrs) {
+    this.type = type;
+    this.attrs = attrs;
+  }
+  /**
+  Given a set of marks, create a new set which contains this one as
+  well, in the right position. If this mark is already in the set,
+  the set itself is returned. If any marks that are set to be
+  [exclusive](https://prosemirror.net/docs/ref/#model.MarkSpec.excludes) with this mark are present,
+  those are replaced by this one.
+  */
+  addToSet(set) {
+    let copy, placed = false;
+    for (let i = 0; i < set.length; i++) {
+      let other = set[i];
+      if (this.eq(other))
+        return set;
+      if (this.type.excludes(other.type)) {
+        if (!copy)
+          copy = set.slice(0, i);
+      } else if (other.type.excludes(this.type)) {
+        return set;
+      } else {
+        if (!placed && other.type.rank > this.type.rank) {
+          if (!copy)
+            copy = set.slice(0, i);
+          copy.push(this);
+          placed = true;
+        }
+        if (copy)
+          copy.push(other);
+      }
+    }
+    if (!copy)
+      copy = set.slice();
+    if (!placed)
+      copy.push(this);
+    return copy;
+  }
+  /**
+  Remove this mark from the given set, returning a new set. If this
+  mark is not in the set, the set itself is returned.
+  */
+  removeFromSet(set) {
+    for (let i = 0; i < set.length; i++)
+      if (this.eq(set[i]))
+        return set.slice(0, i).concat(set.slice(i + 1));
+    return set;
+  }
+  /**
+  Test whether this mark is in the given set of marks.
+  */
+  isInSet(set) {
+    for (let i = 0; i < set.length; i++)
+      if (this.eq(set[i]))
+        return true;
+    return false;
+  }
+  /**
+  Test whether this mark has the same type and attributes as
+  another mark.
+  */
+  eq(other) {
+    return this == other || this.type == other.type && compareDeep(this.attrs, other.attrs);
+  }
+  /**
+  Convert this mark to a JSON-serializeable representation.
+  */
+  toJSON() {
+    let obj = { type: this.type.name };
+    for (let _ in this.attrs) {
+      obj.attrs = this.attrs;
+      break;
+    }
+    return obj;
+  }
+  /**
+  Deserialize a mark from JSON.
+  */
+  static fromJSON(schema, json) {
+    if (!json)
+      throw new RangeError("Invalid input for Mark.fromJSON");
+    let type = schema.marks[json.type];
+    if (!type)
+      throw new RangeError(`There is no mark type ${json.type} in this schema`);
+    let mark = type.create(json.attrs);
+    type.checkAttrs(mark.attrs);
+    return mark;
+  }
+  /**
+  Test whether two sets of marks are identical.
+  */
+  static sameSet(a, b) {
+    if (a == b)
+      return true;
+    if (a.length != b.length)
+      return false;
+    for (let i = 0; i < a.length; i++)
+      if (!a[i].eq(b[i]))
+        return false;
+    return true;
+  }
+  /**
+  Create a properly sorted mark set from null, a single mark, or an
+  unsorted array of marks.
+  */
+  static setFrom(marks) {
+    if (!marks || Array.isArray(marks) && marks.length == 0)
+      return _Mark.none;
+    if (marks instanceof _Mark)
+      return [marks];
+    let copy = marks.slice();
+    copy.sort((a, b) => a.type.rank - b.type.rank);
+    return copy;
+  }
+};
+Mark.none = [];
+var ReplaceError = class extends Error {
+};
+var Slice = class _Slice {
+  /**
+  Create a slice. When specifying a non-zero open depth, you must
+  make sure that there are nodes of at least that depth at the
+  appropriate side of the fragment—i.e. if the fragment is an
+  empty paragraph node, `openStart` and `openEnd` can't be greater
+  than 1.
+  
+  It is not necessary for the content of open nodes to conform to
+  the schema's content constraints, though it should be a valid
+  start/end/middle for such a node, depending on which sides are
+  open.
+  */
+  constructor(content, openStart, openEnd) {
+    this.content = content;
+    this.openStart = openStart;
+    this.openEnd = openEnd;
+  }
+  /**
+  The size this slice would add when inserted into a document.
+  */
+  get size() {
+    return this.content.size - this.openStart - this.openEnd;
+  }
+  /**
+  @internal
+  */
+  insertAt(pos, fragment) {
+    let content = insertInto(this.content, pos + this.openStart, fragment);
+    return content && new _Slice(content, this.openStart, this.openEnd);
+  }
+  /**
+  @internal
+  */
+  removeBetween(from, to) {
+    return new _Slice(removeRange(this.content, from + this.openStart, to + this.openStart), this.openStart, this.openEnd);
+  }
+  /**
+  Tests whether this slice is equal to another slice.
+  */
+  eq(other) {
+    return this.content.eq(other.content) && this.openStart == other.openStart && this.openEnd == other.openEnd;
+  }
+  /**
+  @internal
+  */
+  toString() {
+    return this.content + "(" + this.openStart + "," + this.openEnd + ")";
+  }
+  /**
+  Convert a slice to a JSON-serializable representation.
+  */
+  toJSON() {
+    if (!this.content.size)
+      return null;
+    let json = { content: this.content.toJSON() };
+    if (this.openStart > 0)
+      json.openStart = this.openStart;
+    if (this.openEnd > 0)
+      json.openEnd = this.openEnd;
+    return json;
+  }
+  /**
+  Deserialize a slice from its JSON representation.
+  */
+  static fromJSON(schema, json) {
+    if (!json)
+      return _Slice.empty;
+    let openStart = json.openStart || 0, openEnd = json.openEnd || 0;
+    if (typeof openStart != "number" || typeof openEnd != "number")
+      throw new RangeError("Invalid input for Slice.fromJSON");
+    return new _Slice(Fragment.fromJSON(schema, json.content), openStart, openEnd);
+  }
+  /**
+  Create a slice from a fragment by taking the maximum possible
+  open value on both side of the fragment.
+  */
+  static maxOpen(fragment, openIsolating = true) {
+    let openStart = 0, openEnd = 0;
+    for (let n = fragment.firstChild; n && !n.isLeaf && (openIsolating || !n.type.spec.isolating); n = n.firstChild)
+      openStart++;
+    for (let n = fragment.lastChild; n && !n.isLeaf && (openIsolating || !n.type.spec.isolating); n = n.lastChild)
+      openEnd++;
+    return new _Slice(fragment, openStart, openEnd);
+  }
+};
+Slice.empty = new Slice(Fragment.empty, 0, 0);
+function removeRange(content, from, to) {
+  let { index, offset } = content.findIndex(from), child = content.maybeChild(index);
+  let { index: indexTo, offset: offsetTo } = content.findIndex(to);
+  if (offset == from || child.isText) {
+    if (offsetTo != to && !content.child(indexTo).isText)
+      throw new RangeError("Removing non-flat range");
+    return content.cut(0, from).append(content.cut(to));
+  }
+  if (index != indexTo)
+    throw new RangeError("Removing non-flat range");
+  return content.replaceChild(index, child.copy(removeRange(child.content, from - offset - 1, to - offset - 1)));
+}
+function insertInto(content, dist, insert, parent) {
+  let { index, offset } = content.findIndex(dist), child = content.maybeChild(index);
+  if (offset == dist || child.isText) {
+    if (parent && !parent.canReplace(index, index, insert))
+      return null;
+    return content.cut(0, dist).append(insert).append(content.cut(dist));
+  }
+  let inner = insertInto(child.content, dist - offset - 1, insert, child);
+  return inner && content.replaceChild(index, child.copy(inner));
+}
+function replace($from, $to, slice) {
+  if (slice.openStart > $from.depth)
+    throw new ReplaceError("Inserted content deeper than insertion position");
+  if ($from.depth - slice.openStart != $to.depth - slice.openEnd)
+    throw new ReplaceError("Inconsistent open depths");
+  return replaceOuter($from, $to, slice, 0);
+}
+function replaceOuter($from, $to, slice, depth) {
+  let index = $from.index(depth), node = $from.node(depth);
+  if (index == $to.index(depth) && depth < $from.depth - slice.openStart) {
+    let inner = replaceOuter($from, $to, slice, depth + 1);
+    return node.copy(node.content.replaceChild(index, inner));
+  } else if (!slice.content.size) {
+    return close(node, replaceTwoWay($from, $to, depth));
+  } else if (!slice.openStart && !slice.openEnd && $from.depth == depth && $to.depth == depth) {
+    let parent = $from.parent, content = parent.content;
+    return close(parent, content.cut(0, $from.parentOffset).append(slice.content).append(content.cut($to.parentOffset)));
+  } else {
+    let { start, end } = prepareSliceForReplace(slice, $from);
+    return close(node, replaceThreeWay($from, start, end, $to, depth));
+  }
+}
+function checkJoin(main, sub) {
+  if (!sub.type.compatibleContent(main.type))
+    throw new ReplaceError("Cannot join " + sub.type.name + " onto " + main.type.name);
+}
+function joinable($before, $after, depth) {
+  let node = $before.node(depth);
+  checkJoin(node, $after.node(depth));
+  return node;
+}
+function addNode(child, target) {
+  let last = target.length - 1;
+  if (last >= 0 && child.isText && child.sameMarkup(target[last]))
+    target[last] = child.withText(target[last].text + child.text);
+  else
+    target.push(child);
+}
+function addRange($start, $end, depth, target) {
+  let node = ($end || $start).node(depth);
+  let startIndex = 0, endIndex = $end ? $end.index(depth) : node.childCount;
+  if ($start) {
+    startIndex = $start.index(depth);
+    if ($start.depth > depth) {
+      startIndex++;
+    } else if ($start.textOffset) {
+      addNode($start.nodeAfter, target);
+      startIndex++;
+    }
+  }
+  for (let i = startIndex; i < endIndex; i++)
+    addNode(node.child(i), target);
+  if ($end && $end.depth == depth && $end.textOffset)
+    addNode($end.nodeBefore, target);
+}
+function close(node, content) {
+  node.type.checkContent(content);
+  return node.copy(content);
+}
+function replaceThreeWay($from, $start, $end, $to, depth) {
+  let openStart = $from.depth > depth && joinable($from, $start, depth + 1);
+  let openEnd = $to.depth > depth && joinable($end, $to, depth + 1);
+  let content = [];
+  addRange(null, $from, depth, content);
+  if (openStart && openEnd && $start.index(depth) == $end.index(depth)) {
+    checkJoin(openStart, openEnd);
+    addNode(close(openStart, replaceThreeWay($from, $start, $end, $to, depth + 1)), content);
+  } else {
+    if (openStart)
+      addNode(close(openStart, replaceTwoWay($from, $start, depth + 1)), content);
+    addRange($start, $end, depth, content);
+    if (openEnd)
+      addNode(close(openEnd, replaceTwoWay($end, $to, depth + 1)), content);
+  }
+  addRange($to, null, depth, content);
+  return new Fragment(content);
+}
+function replaceTwoWay($from, $to, depth) {
+  let content = [];
+  addRange(null, $from, depth, content);
+  if ($from.depth > depth) {
+    let type = joinable($from, $to, depth + 1);
+    addNode(close(type, replaceTwoWay($from, $to, depth + 1)), content);
+  }
+  addRange($to, null, depth, content);
+  return new Fragment(content);
+}
+function prepareSliceForReplace(slice, $along) {
+  let extra = $along.depth - slice.openStart, parent = $along.node(extra);
+  let node = parent.copy(slice.content);
+  for (let i = extra - 1; i >= 0; i--)
+    node = $along.node(i).copy(Fragment.from(node));
+  return {
+    start: node.resolveNoCache(slice.openStart + extra),
+    end: node.resolveNoCache(node.content.size - slice.openEnd - extra)
+  };
+}
+var ResolvedPos = class _ResolvedPos {
+  /**
+  @internal
+  */
+  constructor(pos, path, parentOffset) {
+    this.pos = pos;
+    this.path = path;
+    this.parentOffset = parentOffset;
+    this.depth = path.length / 3 - 1;
+  }
+  /**
+  @internal
+  */
+  resolveDepth(val) {
+    if (val == null)
+      return this.depth;
+    if (val < 0)
+      return this.depth + val;
+    return val;
+  }
+  /**
+  The parent node that the position points into. Note that even if
+  a position points into a text node, that node is not considered
+  the parent—text nodes are ‘flat’ in this model, and have no content.
+  */
+  get parent() {
+    return this.node(this.depth);
+  }
+  /**
+  The root node in which the position was resolved.
+  */
+  get doc() {
+    return this.node(0);
+  }
+  /**
+  The ancestor node at the given level. `p.node(p.depth)` is the
+  same as `p.parent`.
+  */
+  node(depth) {
+    return this.path[this.resolveDepth(depth) * 3];
+  }
+  /**
+  The index into the ancestor at the given level. If this points
+  at the 3rd node in the 2nd paragraph on the top level, for
+  example, `p.index(0)` is 1 and `p.index(1)` is 2.
+  */
+  index(depth) {
+    return this.path[this.resolveDepth(depth) * 3 + 1];
+  }
+  /**
+  The index pointing after this position into the ancestor at the
+  given level.
+  */
+  indexAfter(depth) {
+    depth = this.resolveDepth(depth);
+    return this.index(depth) + (depth == this.depth && !this.textOffset ? 0 : 1);
+  }
+  /**
+  The (absolute) position at the start of the node at the given
+  level.
+  */
+  start(depth) {
+    depth = this.resolveDepth(depth);
+    return depth == 0 ? 0 : this.path[depth * 3 - 1] + 1;
+  }
+  /**
+  The (absolute) position at the end of the node at the given
+  level.
+  */
+  end(depth) {
+    depth = this.resolveDepth(depth);
+    return this.start(depth) + this.node(depth).content.size;
+  }
+  /**
+  The (absolute) position directly before the wrapping node at the
+  given level, or, when `depth` is `this.depth + 1`, the original
+  position.
+  */
+  before(depth) {
+    depth = this.resolveDepth(depth);
+    if (!depth)
+      throw new RangeError("There is no position before the top-level node");
+    return depth == this.depth + 1 ? this.pos : this.path[depth * 3 - 1];
+  }
+  /**
+  The (absolute) position directly after the wrapping node at the
+  given level, or the original position when `depth` is `this.depth + 1`.
+  */
+  after(depth) {
+    depth = this.resolveDepth(depth);
+    if (!depth)
+      throw new RangeError("There is no position after the top-level node");
+    return depth == this.depth + 1 ? this.pos : this.path[depth * 3 - 1] + this.path[depth * 3].nodeSize;
+  }
+  /**
+  When this position points into a text node, this returns the
+  distance between the position and the start of the text node.
+  Will be zero for positions that point between nodes.
+  */
+  get textOffset() {
+    return this.pos - this.path[this.path.length - 1];
+  }
+  /**
+  Get the node directly after the position, if any. If the position
+  points into a text node, only the part of that node after the
+  position is returned.
+  */
+  get nodeAfter() {
+    let parent = this.parent, index = this.index(this.depth);
+    if (index == parent.childCount)
+      return null;
+    let dOff = this.pos - this.path[this.path.length - 1], child = parent.child(index);
+    return dOff ? parent.child(index).cut(dOff) : child;
+  }
+  /**
+  Get the node directly before the position, if any. If the
+  position points into a text node, only the part of that node
+  before the position is returned.
+  */
+  get nodeBefore() {
+    let index = this.index(this.depth);
+    let dOff = this.pos - this.path[this.path.length - 1];
+    if (dOff)
+      return this.parent.child(index).cut(0, dOff);
+    return index == 0 ? null : this.parent.child(index - 1);
+  }
+  /**
+  Get the position at the given index in the parent node at the
+  given depth (which defaults to `this.depth`).
+  */
+  posAtIndex(index, depth) {
+    depth = this.resolveDepth(depth);
+    let node = this.path[depth * 3], pos = depth == 0 ? 0 : this.path[depth * 3 - 1] + 1;
+    for (let i = 0; i < index; i++)
+      pos += node.child(i).nodeSize;
+    return pos;
+  }
+  /**
+  Get the marks at this position, factoring in the surrounding
+  marks' [`inclusive`](https://prosemirror.net/docs/ref/#model.MarkSpec.inclusive) property. If the
+  position is at the start of a non-empty node, the marks of the
+  node after it (if any) are returned.
+  */
+  marks() {
+    let parent = this.parent, index = this.index();
+    if (parent.content.size == 0)
+      return Mark.none;
+    if (this.textOffset)
+      return parent.child(index).marks;
+    let main = parent.maybeChild(index - 1), other = parent.maybeChild(index);
+    if (!main) {
+      let tmp = main;
+      main = other;
+      other = tmp;
+    }
+    let marks = main.marks;
+    for (var i = 0; i < marks.length; i++)
+      if (marks[i].type.spec.inclusive === false && (!other || !marks[i].isInSet(other.marks)))
+        marks = marks[i--].removeFromSet(marks);
+    return marks;
+  }
+  /**
+  Get the marks after the current position, if any, except those
+  that are non-inclusive and not present at position `$end`. This
+  is mostly useful for getting the set of marks to preserve after a
+  deletion. Will return `null` if this position is at the end of
+  its parent node or its parent node isn't a textblock (in which
+  case no marks should be preserved).
+  */
+  marksAcross($end) {
+    let after = this.parent.maybeChild(this.index());
+    if (!after || !after.isInline)
+      return null;
+    let marks = after.marks, next = $end.parent.maybeChild($end.index());
+    for (var i = 0; i < marks.length; i++)
+      if (marks[i].type.spec.inclusive === false && (!next || !marks[i].isInSet(next.marks)))
+        marks = marks[i--].removeFromSet(marks);
+    return marks;
+  }
+  /**
+  The depth up to which this position and the given (non-resolved)
+  position share the same parent nodes.
+  */
+  sharedDepth(pos) {
+    for (let depth = this.depth; depth > 0; depth--)
+      if (this.start(depth) <= pos && this.end(depth) >= pos)
+        return depth;
+    return 0;
+  }
+  /**
+  Returns a range based on the place where this position and the
+  given position diverge around block content. If both point into
+  the same textblock, for example, a range around that textblock
+  will be returned. If they point into different blocks, the range
+  around those blocks in their shared ancestor is returned. You can
+  pass in an optional predicate that will be called with a parent
+  node to see if a range into that parent is acceptable.
+  */
+  blockRange(other = this, pred) {
+    if (other.pos < this.pos)
+      return other.blockRange(this);
+    for (let d = this.depth - (this.parent.inlineContent || this.pos == other.pos ? 1 : 0); d >= 0; d--)
+      if (other.pos <= this.end(d) && (!pred || pred(this.node(d))))
+        return new NodeRange(this, other, d);
+    return null;
+  }
+  /**
+  Query whether the given position shares the same parent node.
+  */
+  sameParent(other) {
+    return this.pos - this.parentOffset == other.pos - other.parentOffset;
+  }
+  /**
+  Return the greater of this and the given position.
+  */
+  max(other) {
+    return other.pos > this.pos ? other : this;
+  }
+  /**
+  Return the smaller of this and the given position.
+  */
+  min(other) {
+    return other.pos < this.pos ? other : this;
+  }
+  /**
+  @internal
+  */
+  toString() {
+    let str = "";
+    for (let i = 1; i <= this.depth; i++)
+      str += (str ? "/" : "") + this.node(i).type.name + "_" + this.index(i - 1);
+    return str + ":" + this.parentOffset;
+  }
+  /**
+  @internal
+  */
+  static resolve(doc, pos) {
+    if (!(pos >= 0 && pos <= doc.content.size))
+      throw new RangeError("Position " + pos + " out of range");
+    let path = [];
+    let start = 0, parentOffset = pos;
+    for (let node = doc; ; ) {
+      let { index, offset } = node.content.findIndex(parentOffset);
+      let rem = parentOffset - offset;
+      path.push(node, index, start + offset);
+      if (!rem)
+        break;
+      node = node.child(index);
+      if (node.isText)
+        break;
+      parentOffset = rem - 1;
+      start += offset + 1;
+    }
+    return new _ResolvedPos(pos, path, parentOffset);
+  }
+  /**
+  @internal
+  */
+  static resolveCached(doc, pos) {
+    let cache = resolveCache.get(doc);
+    if (cache) {
+      for (let i = 0; i < cache.elts.length; i++) {
+        let elt = cache.elts[i];
+        if (elt.pos == pos)
+          return elt;
+      }
+    } else {
+      resolveCache.set(doc, cache = new ResolveCache());
+    }
+    let result = cache.elts[cache.i] = _ResolvedPos.resolve(doc, pos);
+    cache.i = (cache.i + 1) % resolveCacheSize;
+    return result;
+  }
+};
+var ResolveCache = class {
+  constructor() {
+    this.elts = [];
+    this.i = 0;
+  }
+};
+var resolveCacheSize = 12;
+var resolveCache = /* @__PURE__ */ new WeakMap();
+var NodeRange = class {
+  /**
+  Construct a node range. `$from` and `$to` should point into the
+  same node until at least the given `depth`, since a node range
+  denotes an adjacent set of nodes in a single parent node.
+  */
+  constructor($from, $to, depth) {
+    this.$from = $from;
+    this.$to = $to;
+    this.depth = depth;
+  }
+  /**
+  The position at the start of the range.
+  */
+  get start() {
+    return this.$from.before(this.depth + 1);
+  }
+  /**
+  The position at the end of the range.
+  */
+  get end() {
+    return this.$to.after(this.depth + 1);
+  }
+  /**
+  The parent node that the range points into.
+  */
+  get parent() {
+    return this.$from.node(this.depth);
+  }
+  /**
+  The start index of the range in the parent node.
+  */
+  get startIndex() {
+    return this.$from.index(this.depth);
+  }
+  /**
+  The end index of the range in the parent node.
+  */
+  get endIndex() {
+    return this.$to.indexAfter(this.depth);
+  }
+};
+var emptyAttrs = /* @__PURE__ */ Object.create(null);
+var Node = class _Node {
+  /**
+  @internal
+  */
+  constructor(type, attrs, content, marks = Mark.none) {
+    this.type = type;
+    this.attrs = attrs;
+    this.marks = marks;
+    this.content = content || Fragment.empty;
+  }
+  /**
+  The array of this node's child nodes.
+  */
+  get children() {
+    return this.content.content;
+  }
+  /**
+  The size of this node, as defined by the integer-based [indexing
+  scheme](https://prosemirror.net/docs/guide/#doc.indexing). For text nodes, this is the
+  amount of characters. For other leaf nodes, it is one. For
+  non-leaf nodes, it is the size of the content plus two (the
+  start and end token).
+  */
+  get nodeSize() {
+    return this.isLeaf ? 1 : 2 + this.content.size;
+  }
+  /**
+  The number of children that the node has.
+  */
+  get childCount() {
+    return this.content.childCount;
+  }
+  /**
+  Get the child node at the given index. Raises an error when the
+  index is out of range.
+  */
+  child(index) {
+    return this.content.child(index);
+  }
+  /**
+  Get the child node at the given index, if it exists.
+  */
+  maybeChild(index) {
+    return this.content.maybeChild(index);
+  }
+  /**
+  Call `f` for every child node, passing the node, its offset
+  into this parent node, and its index.
+  */
+  forEach(f) {
+    this.content.forEach(f);
+  }
+  /**
+  Invoke a callback for all descendant nodes recursively between
+  the given two positions that are relative to start of this
+  node's content. The callback is invoked with the node, its
+  position relative to the original node (method receiver),
+  its parent node, and its child index. When the callback returns
+  false for a given node, that node's children will not be
+  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);
+  }
+  /**
+  Call the given callback for every descendant node. Doesn't
+  descend into a node when the callback returns `false`.
+  */
+  descendants(f) {
+    this.nodesBetween(0, this.content.size, f);
+  }
+  /**
+  Concatenates all the text nodes found in this fragment and its
+  children.
+  */
+  get textContent() {
+    return this.isLeaf && this.type.spec.leafText ? this.type.spec.leafText(this) : this.textBetween(0, this.content.size, "");
+  }
+  /**
+  Get all text between positions `from` and `to`. When
+  `blockSeparator` is given, it will be inserted to separate text
+  from different block nodes. If `leafText` is given, it'll be
+  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);
+  }
+  /**
+  Returns this node's first child, or `null` if there are no
+  children.
+  */
+  get firstChild() {
+    return this.content.firstChild;
+  }
+  /**
+  Returns this node's last child, or `null` if there are no
+  children.
+  */
+  get lastChild() {
+    return this.content.lastChild;
+  }
+  /**
+  Test whether two nodes represent the same piece of document.
+  */
+  eq(other) {
+    return this == other || this.sameMarkup(other) && this.content.eq(other.content);
+  }
+  /**
+  Compare the markup (type, attributes, and marks) of this node to
+  those of another. Returns `true` if both have the same markup.
+  */
+  sameMarkup(other) {
+    return this.hasMarkup(other.type, other.attrs, other.marks);
+  }
+  /**
+  Check whether this node's markup correspond to the given type,
+  attributes, and marks.
+  */
+  hasMarkup(type, attrs, marks) {
+    return this.type == type && compareDeep(this.attrs, attrs || type.defaultAttrs || emptyAttrs) && Mark.sameSet(this.marks, marks || Mark.none);
+  }
+  /**
+  Create a new node with the same markup as this node, containing
+  the given content (or empty, if no content is given).
+  */
+  copy(content = null) {
+    if (content == this.content)
+      return this;
+    return new _Node(this.type, this.attrs, content, this.marks);
+  }
+  /**
+  Create a copy of this node, with the given set of marks instead
+  of the node's own marks.
+  */
+  mark(marks) {
+    return marks == this.marks ? this : new _Node(this.type, this.attrs, this.content, marks);
+  }
+  /**
+  Create a copy of this node with only the content between the
+  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)
+      return this;
+    return this.copy(this.content.cut(from, 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)
+      return Slice.empty;
+    let $from = this.resolve(from), $to = this.resolve(to);
+    let depth = includeParents ? 0 : $from.sharedDepth(to);
+    let start = $from.start(depth), node = $from.node(depth);
+    let content = node.content.cut($from.pos - start, $to.pos - start);
+    return new Slice(content, $from.depth - depth, $to.depth - depth);
+  }
+  /**
+  Replace the part of the document between the given positions with
+  the given slice. The slice must 'fit', meaning its open sides
+  must be able to connect to the surrounding content, and its
+  content nodes must be valid children for the node they are placed
+  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);
+  }
+  /**
+  Find the node directly after the given position.
+  */
+  nodeAt(pos) {
+    for (let node = this; ; ) {
+      let { index, offset } = node.content.findIndex(pos);
+      node = node.maybeChild(index);
+      if (!node)
+        return null;
+      if (offset == pos || node.isText)
+        return node;
+      pos -= offset + 1;
+    }
+  }
+  /**
+  Find the (direct) child node after the given offset, if any,
+  and return it along with its index and offset relative to this
+  node.
+  */
+  childAfter(pos) {
+    let { index, offset } = this.content.findIndex(pos);
+    return { node: this.content.maybeChild(index), index, offset };
+  }
+  /**
+  Find the (direct) child node before the given offset, if any,
+  and return it along with its index and offset relative to this
+  node.
+  */
+  childBefore(pos) {
+    if (pos == 0)
+      return { node: null, index: 0, offset: 0 };
+    let { index, offset } = this.content.findIndex(pos);
+    if (offset < pos)
+      return { node: this.content.child(index), index, offset };
+    let node = this.content.child(index - 1);
+    return { node, index: index - 1, offset: offset - node.nodeSize };
+  }
+  /**
+  Resolve the given position in the document, returning an
+  [object](https://prosemirror.net/docs/ref/#model.ResolvedPos) with information about its context.
+  */
+  resolve(pos) {
+    return ResolvedPos.resolveCached(this, pos);
+  }
+  /**
+  @internal
+  */
+  resolveNoCache(pos) {
+    return ResolvedPos.resolve(this, pos);
+  }
+  /**
+  Test whether a given mark or mark type occurs in this document
+  between the two given positions.
+  */
+  rangeHasMark(from, to, type) {
+    let found2 = false;
+    if (to > from)
+      this.nodesBetween(from, to, (node) => {
+        if (type.isInSet(node.marks))
+          found2 = true;
+        return !found2;
+      });
+    return found2;
+  }
+  /**
+  True when this is a block (non-inline node)
+  */
+  get isBlock() {
+    return this.type.isBlock;
+  }
+  /**
+  True when this is a textblock node, a block node with inline
+  content.
+  */
+  get isTextblock() {
+    return this.type.isTextblock;
+  }
+  /**
+  True when this node allows inline content.
+  */
+  get inlineContent() {
+    return this.type.inlineContent;
+  }
+  /**
+  True when this is an inline node (a text node or a node that can
+  appear among text).
+  */
+  get isInline() {
+    return this.type.isInline;
+  }
+  /**
+  True when this is a text node.
+  */
+  get isText() {
+    return this.type.isText;
+  }
+  /**
+  True when this is a leaf node.
+  */
+  get isLeaf() {
+    return this.type.isLeaf;
+  }
+  /**
+  True when this is an atom, i.e. when it does not have directly
+  editable content. This is usually the same as `isLeaf`, but can
+  be configured with the [`atom` property](https://prosemirror.net/docs/ref/#model.NodeSpec.atom)
+  on a node's spec (typically used when the node is displayed as
+  an uneditable [node view](https://prosemirror.net/docs/ref/#view.NodeView)).
+  */
+  get isAtom() {
+    return this.type.isAtom;
+  }
+  /**
+  Return a string representation of this node for debugging
+  purposes.
+  */
+  toString() {
+    if (this.type.spec.toDebugString)
+      return this.type.spec.toDebugString(this);
+    let name = this.type.name;
+    if (this.content.size)
+      name += "(" + this.content.toStringInner() + ")";
+    return wrapMarks(this.marks, name);
+  }
+  /**
+  Get the content match in this node at the given index.
+  */
+  contentMatchAt(index) {
+    let match = this.type.contentMatch.matchFragment(this.content, 0, index);
+    if (!match)
+      throw new Error("Called contentMatchAt on a node with invalid content");
+    return match;
+  }
+  /**
+  Test whether replacing the range between `from` and `to` (by
+  child index) with the given replacement fragment (which defaults
+  to the empty fragment) would leave the node's content valid. You
+  can optionally pass `start` and `end` indices into the
+  replacement fragment.
+  */
+  canReplace(from, to, replacement = Fragment.empty, start = 0, end = replacement.childCount) {
+    let one = this.contentMatchAt(from).matchFragment(replacement, start, end);
+    let two = one && one.matchFragment(this.content, to);
+    if (!two || !two.validEnd)
+      return false;
+    for (let i = start; i < end; i++)
+      if (!this.type.allowsMarks(replacement.child(i).marks))
+        return false;
+    return true;
+  }
+  /**
+  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) {
+    if (marks && !this.type.allowsMarks(marks))
+      return false;
+    let start = this.contentMatchAt(from).matchType(type);
+    let end = start && start.matchFragment(this.content, to);
+    return end ? end.validEnd : false;
+  }
+  /**
+  Test whether the given node's content could be appended to this
+  node. If that node is empty, this will only return true if there
+  is at least one node type that can appear in both nodes (to avoid
+  merging completely incompatible nodes).
+  */
+  canAppend(other) {
+    if (other.content.size)
+      return this.canReplace(this.childCount, this.childCount, other.content);
+    else
+      return this.type.compatibleContent(other.type);
+  }
+  /**
+  Check whether this node and its descendants conform to the
+  schema, and raise an exception when they do not.
+  */
+  check() {
+    this.type.checkContent(this.content);
+    this.type.checkAttrs(this.attrs);
+    let copy = Mark.none;
+    for (let i = 0; i < this.marks.length; i++) {
+      let mark = this.marks[i];
+      mark.type.checkAttrs(mark.attrs);
+      copy = mark.addToSet(copy);
+    }
+    if (!Mark.sameSet(copy, this.marks))
+      throw new RangeError(`Invalid collection of marks for node ${this.type.name}: ${this.marks.map((m) => m.type.name)}`);
+    this.content.forEach((node) => node.check());
+  }
+  /**
+  Return a JSON-serializeable representation of this node.
+  */
+  toJSON() {
+    let obj = { type: this.type.name };
+    for (let _ in this.attrs) {
+      obj.attrs = this.attrs;
+      break;
+    }
+    if (this.content.size)
+      obj.content = this.content.toJSON();
+    if (this.marks.length)
+      obj.marks = this.marks.map((n) => n.toJSON());
+    return obj;
+  }
+  /**
+  Deserialize a node from its JSON representation.
+  */
+  static fromJSON(schema, json) {
+    if (!json)
+      throw new RangeError("Invalid input for Node.fromJSON");
+    let marks = void 0;
+    if (json.marks) {
+      if (!Array.isArray(json.marks))
+        throw new RangeError("Invalid mark data for Node.fromJSON");
+      marks = json.marks.map(schema.markFromJSON);
+    }
+    if (json.type == "text") {
+      if (typeof json.text != "string")
+        throw new RangeError("Invalid text node in JSON");
+      return schema.text(json.text, marks);
+    }
+    let content = Fragment.fromJSON(schema, json.content);
+    let node = schema.nodeType(json.type).create(json.attrs, content, marks);
+    node.type.checkAttrs(node.attrs);
+    return node;
+  }
+};
+Node.prototype.text = void 0;
+function wrapMarks(marks, str) {
+  for (let i = marks.length - 1; i >= 0; i--)
+    str = marks[i].type.name + "(" + str + ")";
+  return str;
+}
+var ContentMatch = class _ContentMatch {
+  /**
+  @internal
+  */
+  constructor(validEnd) {
+    this.validEnd = validEnd;
+    this.next = [];
+    this.wrapCache = [];
+  }
+  /**
+  @internal
+  */
+  static parse(string, nodeTypes) {
+    let stream = new TokenStream(string, nodeTypes);
+    if (stream.next == null)
+      return _ContentMatch.empty;
+    let expr = parseExpr(stream);
+    if (stream.next)
+      stream.err("Unexpected trailing text");
+    let match = dfa(nfa(expr));
+    checkForDeadEnds(match, stream);
+    return match;
+  }
+  /**
+  Match a node type, returning a match after that node if
+  successful.
+  */
+  matchType(type) {
+    for (let i = 0; i < this.next.length; i++)
+      if (this.next[i].type == type)
+        return this.next[i].next;
+    return null;
+  }
+  /**
+  Try to match a fragment. Returns the resulting match when
+  successful.
+  */
+  matchFragment(frag, start = 0, end = frag.childCount) {
+    let cur = this;
+    for (let i = start; cur && i < end; i++)
+      cur = cur.matchType(frag.child(i).type);
+    return cur;
+  }
+  /**
+  @internal
+  */
+  get inlineContent() {
+    return this.next.length != 0 && this.next[0].type.isInline;
+  }
+  /**
+  Get the first matching node type at this match position that can
+  be generated.
+  */
+  get defaultType() {
+    for (let i = 0; i < this.next.length; i++) {
+      let { type } = this.next[i];
+      if (!(type.isText || type.hasRequiredAttrs()))
+        return type;
+    }
+    return null;
+  }
+  /**
+  @internal
+  */
+  compatible(other) {
+    for (let i = 0; i < this.next.length; i++)
+      for (let j = 0; j < other.next.length; j++)
+        if (this.next[i].type == other.next[j].type)
+          return true;
+    return false;
+  }
+  /**
+  Try to match the given fragment, and if that fails, see if it can
+  be made to match by inserting nodes in front of it. When
+  successful, return a fragment of inserted nodes (which may be
+  empty if nothing had to be inserted). When `toEnd` is true, only
+  return a fragment if the resulting match goes to the end of the
+  content expression.
+  */
+  fillBefore(after, toEnd = false, startIndex = 0) {
+    let seen = [this];
+    function search(match, types) {
+      let finished = match.matchFragment(after, startIndex);
+      if (finished && (!toEnd || finished.validEnd))
+        return Fragment.from(types.map((tp) => tp.createAndFill()));
+      for (let i = 0; i < match.next.length; i++) {
+        let { type, next } = match.next[i];
+        if (!(type.isText || type.hasRequiredAttrs()) && seen.indexOf(next) == -1) {
+          seen.push(next);
+          let found2 = search(next, types.concat(type));
+          if (found2)
+            return found2;
+        }
+      }
+      return null;
+    }
+    return search(this, []);
+  }
+  /**
+  Find a set of wrapping node types that would allow a node of the
+  given type to appear at this position. The result may be empty
+  (when it fits directly) and will be null when no such wrapping
+  exists.
+  */
+  findWrapping(target) {
+    for (let i = 0; i < this.wrapCache.length; i += 2)
+      if (this.wrapCache[i] == target)
+        return this.wrapCache[i + 1];
+    let computed = this.computeWrapping(target);
+    this.wrapCache.push(target, computed);
+    return computed;
+  }
+  /**
+  @internal
+  */
+  computeWrapping(target) {
+    let seen = /* @__PURE__ */ Object.create(null), active = [{ match: this, type: null, via: null }];
+    while (active.length) {
+      let current = active.shift(), match = current.match;
+      if (match.matchType(target)) {
+        let result = [];
+        for (let obj = current; obj.type; obj = obj.via)
+          result.push(obj.type);
+        return result.reverse();
+      }
+      for (let i = 0; i < match.next.length; i++) {
+        let { type, next } = match.next[i];
+        if (!type.isLeaf && !type.hasRequiredAttrs() && !(type.name in seen) && (!current.type || next.validEnd)) {
+          active.push({ match: type.contentMatch, type, via: current });
+          seen[type.name] = true;
+        }
+      }
+    }
+    return null;
+  }
+  /**
+  The number of outgoing edges this node has in the finite
+  automaton that describes the content expression.
+  */
+  get edgeCount() {
+    return this.next.length;
+  }
+  /**
+  Get the _n_​th outgoing edge from this node in the finite
+  automaton that describes the content expression.
+  */
+  edge(n) {
+    if (n >= this.next.length)
+      throw new RangeError(`There's no ${n}th edge in this content match`);
+    return this.next[n];
+  }
+  /**
+  @internal
+  */
+  toString() {
+    let seen = [];
+    function scan(m) {
+      seen.push(m);
+      for (let i = 0; i < m.next.length; i++)
+        if (seen.indexOf(m.next[i].next) == -1)
+          scan(m.next[i].next);
+    }
+    scan(this);
+    return seen.map((m, i) => {
+      let out = i + (m.validEnd ? "*" : " ") + " ";
+      for (let i2 = 0; i2 < m.next.length; i2++)
+        out += (i2 ? ", " : "") + m.next[i2].type.name + "->" + seen.indexOf(m.next[i2].next);
+      return out;
+    }).join("\n");
+  }
+};
+ContentMatch.empty = new ContentMatch(true);
+var TokenStream = class {
+  constructor(string, nodeTypes) {
+    this.string = string;
+    this.nodeTypes = nodeTypes;
+    this.inline = null;
+    this.pos = 0;
+    this.tokens = string.split(/\s*(?=\b|\W|$)/);
+    if (this.tokens[this.tokens.length - 1] == "")
+      this.tokens.pop();
+    if (this.tokens[0] == "")
+      this.tokens.shift();
+  }
+  get next() {
+    return this.tokens[this.pos];
+  }
+  eat(tok) {
+    return this.next == tok && (this.pos++ || true);
+  }
+  err(str) {
+    throw new SyntaxError(str + " (in content expression '" + this.string + "')");
+  }
+};
+function parseExpr(stream) {
+  let exprs = [];
+  do {
+    exprs.push(parseExprSeq(stream));
+  } while (stream.eat("|"));
+  return exprs.length == 1 ? exprs[0] : { type: "choice", exprs };
+}
+function parseExprSeq(stream) {
+  let exprs = [];
+  do {
+    exprs.push(parseExprSubscript(stream));
+  } while (stream.next && stream.next != ")" && stream.next != "|");
+  return exprs.length == 1 ? exprs[0] : { type: "seq", exprs };
+}
+function parseExprSubscript(stream) {
+  let expr = parseExprAtom(stream);
+  for (; ; ) {
+    if (stream.eat("+"))
+      expr = { type: "plus", expr };
+    else if (stream.eat("*"))
+      expr = { type: "star", expr };
+    else if (stream.eat("?"))
+      expr = { type: "opt", expr };
+    else if (stream.eat("{"))
+      expr = parseExprRange(stream, expr);
+    else
+      break;
+  }
+  return expr;
+}
+function parseNum(stream) {
+  if (/\D/.test(stream.next))
+    stream.err("Expected number, got '" + stream.next + "'");
+  let result = Number(stream.next);
+  stream.pos++;
+  return result;
+}
+function parseExprRange(stream, expr) {
+  let min = parseNum(stream), max = min;
+  if (stream.eat(",")) {
+    if (stream.next != "}")
+      max = parseNum(stream);
+    else
+      max = -1;
+  }
+  if (!stream.eat("}"))
+    stream.err("Unclosed braced range");
+  return { type: "range", min, max, expr };
+}
+function resolveName(stream, name) {
+  let types = stream.nodeTypes, type = types[name];
+  if (type)
+    return [type];
+  let result = [];
+  for (let typeName in types) {
+    let type2 = types[typeName];
+    if (type2.isInGroup(name))
+      result.push(type2);
+  }
+  if (result.length == 0)
+    stream.err("No node type or group '" + name + "' found");
+  return result;
+}
+function parseExprAtom(stream) {
+  if (stream.eat("(")) {
+    let expr = parseExpr(stream);
+    if (!stream.eat(")"))
+      stream.err("Missing closing paren");
+    return expr;
+  } else if (!/\W/.test(stream.next)) {
+    let exprs = resolveName(stream, stream.next).map((type) => {
+      if (stream.inline == null)
+        stream.inline = type.isInline;
+      else if (stream.inline != type.isInline)
+        stream.err("Mixing inline and block content");
+      return { type: "name", value: type };
+    });
+    stream.pos++;
+    return exprs.length == 1 ? exprs[0] : { type: "choice", exprs };
+  } else {
+    stream.err("Unexpected token '" + stream.next + "'");
+  }
+}
+function nfa(expr) {
+  let nfa2 = [[]];
+  connect(compile(expr, 0), node());
+  return nfa2;
+  function node() {
+    return nfa2.push([]) - 1;
+  }
+  function edge(from, to, term) {
+    let edge2 = { term, to };
+    nfa2[from].push(edge2);
+    return edge2;
+  }
+  function connect(edges, to) {
+    edges.forEach((edge2) => edge2.to = to);
+  }
+  function compile(expr2, from) {
+    if (expr2.type == "choice") {
+      return expr2.exprs.reduce((out, expr3) => out.concat(compile(expr3, from)), []);
+    } else if (expr2.type == "seq") {
+      for (let i = 0; ; i++) {
+        let next = compile(expr2.exprs[i], from);
+        if (i == expr2.exprs.length - 1)
+          return next;
+        connect(next, from = node());
+      }
+    } else if (expr2.type == "star") {
+      let loop = node();
+      edge(from, loop);
+      connect(compile(expr2.expr, loop), loop);
+      return [edge(loop)];
+    } else if (expr2.type == "plus") {
+      let loop = node();
+      connect(compile(expr2.expr, from), loop);
+      connect(compile(expr2.expr, loop), loop);
+      return [edge(loop)];
+    } else if (expr2.type == "opt") {
+      return [edge(from)].concat(compile(expr2.expr, from));
+    } else if (expr2.type == "range") {
+      let cur = from;
+      for (let i = 0; i < expr2.min; i++) {
+        let next = node();
+        connect(compile(expr2.expr, cur), next);
+        cur = next;
+      }
+      if (expr2.max == -1) {
+        connect(compile(expr2.expr, cur), cur);
+      } else {
+        for (let i = expr2.min; i < expr2.max; i++) {
+          let next = node();
+          edge(cur, next);
+          connect(compile(expr2.expr, cur), next);
+          cur = next;
+        }
+      }
+      return [edge(cur)];
+    } else if (expr2.type == "name") {
+      return [edge(from, void 0, expr2.value)];
+    } else {
+      throw new Error("Unknown expr type");
+    }
+  }
+}
+function cmp(a, b) {
+  return b - a;
+}
+function nullFrom(nfa2, node) {
+  let result = [];
+  scan(node);
+  return result.sort(cmp);
+  function scan(node2) {
+    let edges = nfa2[node2];
+    if (edges.length == 1 && !edges[0].term)
+      return scan(edges[0].to);
+    result.push(node2);
+    for (let i = 0; i < edges.length; i++) {
+      let { term, to } = edges[i];
+      if (!term && result.indexOf(to) == -1)
+        scan(to);
+    }
+  }
+}
+function dfa(nfa2) {
+  let labeled = /* @__PURE__ */ Object.create(null);
+  return explore(nullFrom(nfa2, 0));
+  function explore(states) {
+    let out = [];
+    states.forEach((node) => {
+      nfa2[node].forEach(({ term, to }) => {
+        if (!term)
+          return;
+        let set;
+        for (let i = 0; i < out.length; i++)
+          if (out[i][0] == term)
+            set = out[i][1];
+        nullFrom(nfa2, to).forEach((node2) => {
+          if (!set)
+            out.push([term, set = []]);
+          if (set.indexOf(node2) == -1)
+            set.push(node2);
+        });
+      });
+    });
+    let state = labeled[states.join(",")] = new ContentMatch(states.indexOf(nfa2.length - 1) > -1);
+    for (let i = 0; i < out.length; i++) {
+      let states2 = out[i][1].sort(cmp);
+      state.next.push({ type: out[i][0], next: labeled[states2.join(",")] || explore(states2) });
+    }
+    return state;
+  }
+}
+function checkForDeadEnds(match, stream) {
+  for (let i = 0, work = [match]; i < work.length; i++) {
+    let state = work[i], dead = !state.validEnd, nodes = [];
+    for (let j = 0; j < state.next.length; j++) {
+      let { type, next } = state.next[j];
+      nodes.push(type.name);
+      if (dead && !(type.isText || type.hasRequiredAttrs()))
+        dead = false;
+      if (work.indexOf(next) == -1)
+        work.push(next);
+    }
+    if (dead)
+      stream.err("Only non-generatable nodes (" + nodes.join(", ") + ") in a required position (see https://prosemirror.net/docs/guide/#generatable)");
+  }
+}
+
+// ../../node_modules/.pnpm/prosemirror-transform@1.10.4/node_modules/prosemirror-transform/dist/index.js
+var lower16 = 65535;
+var factor16 = Math.pow(2, 16);
+function makeRecover(index, offset) {
+  return index + offset * factor16;
+}
+function recoverIndex(value) {
+  return value & lower16;
+}
+function recoverOffset(value) {
+  return (value - (value & lower16)) / factor16;
+}
+var DEL_BEFORE = 1;
+var DEL_AFTER = 2;
+var DEL_ACROSS = 4;
+var DEL_SIDE = 8;
+var MapResult = class {
+  /**
+  @internal
+  */
+  constructor(pos, delInfo, recover) {
+    this.pos = pos;
+    this.delInfo = delInfo;
+    this.recover = recover;
+  }
+  /**
+  Tells you whether the position was deleted, that is, whether the
+  step removed the token on the side queried (via the `assoc`)
+  argument from the document.
+  */
+  get deleted() {
+    return (this.delInfo & DEL_SIDE) > 0;
+  }
+  /**
+  Tells you whether the token before the mapped position was deleted.
+  */
+  get deletedBefore() {
+    return (this.delInfo & (DEL_BEFORE | DEL_ACROSS)) > 0;
+  }
+  /**
+  True when the token after the mapped position was deleted.
+  */
+  get deletedAfter() {
+    return (this.delInfo & (DEL_AFTER | DEL_ACROSS)) > 0;
+  }
+  /**
+  Tells whether any of the steps mapped through deletes across the
+  position (including both the token before and after the
+  position).
+  */
+  get deletedAcross() {
+    return (this.delInfo & DEL_ACROSS) > 0;
+  }
+};
+var StepMap = class _StepMap {
+  /**
+  Create a position map. The modifications to the document are
+  represented as an array of numbers, in which each group of three
+  represents a modified chunk as `[start, oldSize, newSize]`.
+  */
+  constructor(ranges, inverted = false) {
+    this.ranges = ranges;
+    this.inverted = inverted;
+    if (!ranges.length && _StepMap.empty)
+      return _StepMap.empty;
+  }
+  /**
+  @internal
+  */
+  recover(value) {
+    let diff = 0, index = recoverIndex(value);
+    if (!this.inverted)
+      for (let i = 0; i < index; i++)
+        diff += this.ranges[i * 3 + 2] - this.ranges[i * 3 + 1];
+    return this.ranges[index * 3] + diff + recoverOffset(value);
+  }
+  mapResult(pos, assoc = 1) {
+    return this._map(pos, assoc, false);
+  }
+  map(pos, assoc = 1) {
+    return this._map(pos, assoc, true);
+  }
+  /**
+  @internal
+  */
+  _map(pos, assoc, simple) {
+    let diff = 0, oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
+    for (let i = 0; i < this.ranges.length; i += 3) {
+      let start = this.ranges[i] - (this.inverted ? diff : 0);
+      if (start > pos)
+        break;
+      let oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex], end = start + oldSize;
+      if (pos <= end) {
+        let side = !oldSize ? assoc : pos == start ? -1 : pos == end ? 1 : assoc;
+        let result = start + diff + (side < 0 ? 0 : newSize);
+        if (simple)
+          return result;
+        let recover = pos == (assoc < 0 ? start : end) ? null : makeRecover(i / 3, pos - start);
+        let del = pos == start ? DEL_AFTER : pos == end ? DEL_BEFORE : DEL_ACROSS;
+        if (assoc < 0 ? pos != start : pos != end)
+          del |= DEL_SIDE;
+        return new MapResult(result, del, recover);
+      }
+      diff += newSize - oldSize;
+    }
+    return simple ? pos + diff : new MapResult(pos + diff, 0, null);
+  }
+  /**
+  @internal
+  */
+  touches(pos, recover) {
+    let diff = 0, index = recoverIndex(recover);
+    let oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
+    for (let i = 0; i < this.ranges.length; i += 3) {
+      let start = this.ranges[i] - (this.inverted ? diff : 0);
+      if (start > pos)
+        break;
+      let oldSize = this.ranges[i + oldIndex], end = start + oldSize;
+      if (pos <= end && i == index * 3)
+        return true;
+      diff += this.ranges[i + newIndex] - oldSize;
+    }
+    return false;
+  }
+  /**
+  Calls the given function on each of the changed ranges included in
+  this map.
+  */
+  forEach(f) {
+    let oldIndex = this.inverted ? 2 : 1, newIndex = this.inverted ? 1 : 2;
+    for (let i = 0, diff = 0; i < this.ranges.length; i += 3) {
+      let start = this.ranges[i], oldStart = start - (this.inverted ? diff : 0), newStart = start + (this.inverted ? 0 : diff);
+      let oldSize = this.ranges[i + oldIndex], newSize = this.ranges[i + newIndex];
+      f(oldStart, oldStart + oldSize, newStart, newStart + newSize);
+      diff += newSize - oldSize;
+    }
+  }
+  /**
+  Create an inverted version of this map. The result can be used to
+  map positions in the post-step document to the pre-step document.
+  */
+  invert() {
+    return new _StepMap(this.ranges, !this.inverted);
+  }
+  /**
+  @internal
+  */
+  toString() {
+    return (this.inverted ? "-" : "") + JSON.stringify(this.ranges);
+  }
+  /**
+  Create a map that moves all positions by offset `n` (which may be
+  negative). This can be useful when applying steps meant for a
+  sub-document to a larger document, or vice-versa.
+  */
+  static offset(n) {
+    return n == 0 ? _StepMap.empty : new _StepMap(n < 0 ? [0, -n, 0] : [0, 0, n]);
+  }
+};
+StepMap.empty = new StepMap([]);
+var stepsByID = /* @__PURE__ */ Object.create(null);
+var Step = class {
+  /**
+  Get the step map that represents the changes made by this step,
+  and which can be used to transform between positions in the old
+  and the new document.
+  */
+  getMap() {
+    return StepMap.empty;
+  }
+  /**
+  Try to merge this step with another one, to be applied directly
+  after it. Returns the merged step when possible, null if the
+  steps can't be merged.
+  */
+  merge(other) {
+    return null;
+  }
+  /**
+  Deserialize a step from its JSON representation. Will call
+  through to the step class' own implementation of this method.
+  */
+  static fromJSON(schema, json) {
+    if (!json || !json.stepType)
+      throw new RangeError("Invalid input for Step.fromJSON");
+    let type = stepsByID[json.stepType];
+    if (!type)
+      throw new RangeError(`No step type ${json.stepType} defined`);
+    return type.fromJSON(schema, json);
+  }
+  /**
+  To be able to serialize steps to JSON, each step needs a string
+  ID to attach to its JSON representation. Use this method to
+  register an ID for your step classes. Try to pick something
+  that's unlikely to clash with steps from other modules.
+  */
+  static jsonID(id, stepClass) {
+    if (id in stepsByID)
+      throw new RangeError("Duplicate use of step JSON ID " + id);
+    stepsByID[id] = stepClass;
+    stepClass.prototype.jsonID = id;
+    return stepClass;
+  }
+};
+var StepResult = class _StepResult {
+  /**
+  @internal
+  */
+  constructor(doc, failed) {
+    this.doc = doc;
+    this.failed = failed;
+  }
+  /**
+  Create a successful step result.
+  */
+  static ok(doc) {
+    return new _StepResult(doc, null);
+  }
+  /**
+  Create a failed step result.
+  */
+  static fail(message) {
+    return new _StepResult(null, message);
+  }
+  /**
+  Call [`Node.replace`](https://prosemirror.net/docs/ref/#model.Node.replace) with the given
+  arguments. Create a successful result if it succeeds, and a
+  failed one if it throws a `ReplaceError`.
+  */
+  static fromReplace(doc, from, to, slice) {
+    try {
+      return _StepResult.ok(doc.replace(from, to, slice));
+    } catch (e) {
+      if (e instanceof ReplaceError)
+        return _StepResult.fail(e.message);
+      throw e;
+    }
+  }
+};
+function mapFragment(fragment, f, parent) {
+  let mapped = [];
+  for (let i = 0; i < fragment.childCount; i++) {
+    let child = fragment.child(i);
+    if (child.content.size)
+      child = child.copy(mapFragment(child.content, f, child));
+    if (child.isInline)
+      child = f(child, parent, i);
+    mapped.push(child);
+  }
+  return Fragment.fromArray(mapped);
+}
+var AddMarkStep = class _AddMarkStep extends Step {
+  /**
+  Create a mark step.
+  */
+  constructor(from, to, mark) {
+    super();
+    this.from = from;
+    this.to = to;
+    this.mark = mark;
+  }
+  apply(doc) {
+    let oldSlice = doc.slice(this.from, this.to), $from = doc.resolve(this.from);
+    let parent = $from.node($from.sharedDepth(this.to));
+    let slice = new Slice(mapFragment(oldSlice.content, (node, parent2) => {
+      if (!node.isAtom || !parent2.type.allowsMarkType(this.mark.type))
+        return node;
+      return node.mark(this.mark.addToSet(node.marks));
+    }, parent), oldSlice.openStart, oldSlice.openEnd);
+    return StepResult.fromReplace(doc, this.from, this.to, slice);
+  }
+  invert() {
+    return new RemoveMarkStep(this.from, this.to, this.mark);
+  }
+  map(mapping) {
+    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
+    if (from.deleted && to.deleted || from.pos >= to.pos)
+      return null;
+    return new _AddMarkStep(from.pos, to.pos, this.mark);
+  }
+  merge(other) {
+    if (other instanceof _AddMarkStep && other.mark.eq(this.mark) && this.from <= other.to && this.to >= other.from)
+      return new _AddMarkStep(Math.min(this.from, other.from), Math.max(this.to, other.to), this.mark);
+    return null;
+  }
+  toJSON() {
+    return {
+      stepType: "addMark",
+      mark: this.mark.toJSON(),
+      from: this.from,
+      to: this.to
+    };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(schema, json) {
+    if (typeof json.from != "number" || typeof json.to != "number")
+      throw new RangeError("Invalid input for AddMarkStep.fromJSON");
+    return new _AddMarkStep(json.from, json.to, schema.markFromJSON(json.mark));
+  }
+};
+Step.jsonID("addMark", AddMarkStep);
+var RemoveMarkStep = class _RemoveMarkStep extends Step {
+  /**
+  Create a mark-removing step.
+  */
+  constructor(from, to, mark) {
+    super();
+    this.from = from;
+    this.to = to;
+    this.mark = mark;
+  }
+  apply(doc) {
+    let oldSlice = doc.slice(this.from, this.to);
+    let slice = new Slice(mapFragment(oldSlice.content, (node) => {
+      return node.mark(this.mark.removeFromSet(node.marks));
+    }, doc), oldSlice.openStart, oldSlice.openEnd);
+    return StepResult.fromReplace(doc, this.from, this.to, slice);
+  }
+  invert() {
+    return new AddMarkStep(this.from, this.to, this.mark);
+  }
+  map(mapping) {
+    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
+    if (from.deleted && to.deleted || from.pos >= to.pos)
+      return null;
+    return new _RemoveMarkStep(from.pos, to.pos, this.mark);
+  }
+  merge(other) {
+    if (other instanceof _RemoveMarkStep && other.mark.eq(this.mark) && this.from <= other.to && this.to >= other.from)
+      return new _RemoveMarkStep(Math.min(this.from, other.from), Math.max(this.to, other.to), this.mark);
+    return null;
+  }
+  toJSON() {
+    return {
+      stepType: "removeMark",
+      mark: this.mark.toJSON(),
+      from: this.from,
+      to: this.to
+    };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(schema, json) {
+    if (typeof json.from != "number" || typeof json.to != "number")
+      throw new RangeError("Invalid input for RemoveMarkStep.fromJSON");
+    return new _RemoveMarkStep(json.from, json.to, schema.markFromJSON(json.mark));
+  }
+};
+Step.jsonID("removeMark", RemoveMarkStep);
+var AddNodeMarkStep = class _AddNodeMarkStep extends Step {
+  /**
+  Create a node mark step.
+  */
+  constructor(pos, mark) {
+    super();
+    this.pos = pos;
+    this.mark = mark;
+  }
+  apply(doc) {
+    let node = doc.nodeAt(this.pos);
+    if (!node)
+      return StepResult.fail("No node at mark step's position");
+    let updated = node.type.create(node.attrs, null, this.mark.addToSet(node.marks));
+    return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
+  }
+  invert(doc) {
+    let node = doc.nodeAt(this.pos);
+    if (node) {
+      let newSet = this.mark.addToSet(node.marks);
+      if (newSet.length == node.marks.length) {
+        for (let i = 0; i < node.marks.length; i++)
+          if (!node.marks[i].isInSet(newSet))
+            return new _AddNodeMarkStep(this.pos, node.marks[i]);
+        return new _AddNodeMarkStep(this.pos, this.mark);
+      }
+    }
+    return new RemoveNodeMarkStep(this.pos, this.mark);
+  }
+  map(mapping) {
+    let pos = mapping.mapResult(this.pos, 1);
+    return pos.deletedAfter ? null : new _AddNodeMarkStep(pos.pos, this.mark);
+  }
+  toJSON() {
+    return { stepType: "addNodeMark", pos: this.pos, mark: this.mark.toJSON() };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(schema, json) {
+    if (typeof json.pos != "number")
+      throw new RangeError("Invalid input for AddNodeMarkStep.fromJSON");
+    return new _AddNodeMarkStep(json.pos, schema.markFromJSON(json.mark));
+  }
+};
+Step.jsonID("addNodeMark", AddNodeMarkStep);
+var RemoveNodeMarkStep = class _RemoveNodeMarkStep extends Step {
+  /**
+  Create a mark-removing step.
+  */
+  constructor(pos, mark) {
+    super();
+    this.pos = pos;
+    this.mark = mark;
+  }
+  apply(doc) {
+    let node = doc.nodeAt(this.pos);
+    if (!node)
+      return StepResult.fail("No node at mark step's position");
+    let updated = node.type.create(node.attrs, null, this.mark.removeFromSet(node.marks));
+    return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
+  }
+  invert(doc) {
+    let node = doc.nodeAt(this.pos);
+    if (!node || !this.mark.isInSet(node.marks))
+      return this;
+    return new AddNodeMarkStep(this.pos, this.mark);
+  }
+  map(mapping) {
+    let pos = mapping.mapResult(this.pos, 1);
+    return pos.deletedAfter ? null : new _RemoveNodeMarkStep(pos.pos, this.mark);
+  }
+  toJSON() {
+    return { stepType: "removeNodeMark", pos: this.pos, mark: this.mark.toJSON() };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(schema, json) {
+    if (typeof json.pos != "number")
+      throw new RangeError("Invalid input for RemoveNodeMarkStep.fromJSON");
+    return new _RemoveNodeMarkStep(json.pos, schema.markFromJSON(json.mark));
+  }
+};
+Step.jsonID("removeNodeMark", RemoveNodeMarkStep);
+var ReplaceStep = class _ReplaceStep extends Step {
+  /**
+  The given `slice` should fit the 'gap' between `from` and
+  `to`—the depths must line up, and the surrounding nodes must be
+  able to be joined with the open sides of the slice. When
+  `structure` is true, the step will fail if the content between
+  from and to is not just a sequence of closing and then opening
+  tokens (this is to guard against rebased replace steps
+  overwriting something they weren't supposed to).
+  */
+  constructor(from, to, slice, structure = false) {
+    super();
+    this.from = from;
+    this.to = to;
+    this.slice = slice;
+    this.structure = structure;
+  }
+  apply(doc) {
+    if (this.structure && contentBetween(doc, this.from, this.to))
+      return StepResult.fail("Structure replace would overwrite content");
+    return StepResult.fromReplace(doc, this.from, this.to, this.slice);
+  }
+  getMap() {
+    return new StepMap([this.from, this.to - this.from, this.slice.size]);
+  }
+  invert(doc) {
+    return new _ReplaceStep(this.from, this.from + this.slice.size, doc.slice(this.from, this.to));
+  }
+  map(mapping) {
+    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
+    if (from.deletedAcross && to.deletedAcross)
+      return null;
+    return new _ReplaceStep(from.pos, Math.max(from.pos, to.pos), this.slice, 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 ? Slice.empty : new Slice(this.slice.content.append(other.slice.content), this.slice.openStart, other.slice.openEnd);
+      return new _ReplaceStep(this.from, this.to + (other.to - other.from), slice, this.structure);
+    } else if (other.to == this.from && !this.slice.openStart && !other.slice.openEnd) {
+      let slice = this.slice.size + other.slice.size == 0 ? Slice.empty : new Slice(other.slice.content.append(this.slice.content), other.slice.openStart, this.slice.openEnd);
+      return new _ReplaceStep(other.from, this.to, slice, this.structure);
+    } else {
+      return null;
+    }
+  }
+  toJSON() {
+    let json = { stepType: "replace", from: this.from, to: this.to };
+    if (this.slice.size)
+      json.slice = this.slice.toJSON();
+    if (this.structure)
+      json.structure = true;
+    return json;
+  }
+  /**
+  @internal
+  */
+  static fromJSON(schema, json) {
+    if (typeof json.from != "number" || typeof json.to != "number")
+      throw new RangeError("Invalid input for ReplaceStep.fromJSON");
+    return new _ReplaceStep(json.from, json.to, Slice.fromJSON(schema, json.slice), !!json.structure);
+  }
+};
+Step.jsonID("replace", ReplaceStep);
+var ReplaceAroundStep = class _ReplaceAroundStep extends Step {
+  /**
+  Create a replace-around step with the given range and gap.
+  `insert` should be the point in the slice into which the content
+  of the gap should be moved. `structure` has the same meaning as
+  it has in the [`ReplaceStep`](https://prosemirror.net/docs/ref/#transform.ReplaceStep) class.
+  */
+  constructor(from, to, gapFrom, gapTo, slice, insert, structure = false) {
+    super();
+    this.from = from;
+    this.to = to;
+    this.gapFrom = gapFrom;
+    this.gapTo = gapTo;
+    this.slice = slice;
+    this.insert = insert;
+    this.structure = structure;
+  }
+  apply(doc) {
+    if (this.structure && (contentBetween(doc, this.from, this.gapFrom) || contentBetween(doc, this.gapTo, this.to)))
+      return StepResult.fail("Structure gap-replace would overwrite content");
+    let gap = doc.slice(this.gapFrom, this.gapTo);
+    if (gap.openStart || gap.openEnd)
+      return StepResult.fail("Gap is not a flat range");
+    let inserted = this.slice.insertAt(this.insert, gap.content);
+    if (!inserted)
+      return StepResult.fail("Content does not fit in gap");
+    return StepResult.fromReplace(doc, this.from, this.to, inserted);
+  }
+  getMap() {
+    return new StepMap([
+      this.from,
+      this.gapFrom - this.from,
+      this.insert,
+      this.gapTo,
+      this.to - this.gapTo,
+      this.slice.size - this.insert
+    ]);
+  }
+  invert(doc) {
+    let gap = this.gapTo - this.gapFrom;
+    return new _ReplaceAroundStep(this.from, this.from + this.slice.size + gap, this.from + this.insert, this.from + this.insert + gap, doc.slice(this.from, this.to).removeBetween(this.gapFrom - this.from, this.gapTo - this.from), this.gapFrom - this.from, this.structure);
+  }
+  map(mapping) {
+    let from = mapping.mapResult(this.from, 1), to = mapping.mapResult(this.to, -1);
+    let gapFrom = this.from == this.gapFrom ? from.pos : mapping.map(this.gapFrom, -1);
+    let gapTo = this.to == this.gapTo ? to.pos : mapping.map(this.gapTo, 1);
+    if (from.deletedAcross && to.deletedAcross || gapFrom < from.pos || gapTo > to.pos)
+      return null;
+    return new _ReplaceAroundStep(from.pos, to.pos, gapFrom, gapTo, this.slice, this.insert, this.structure);
+  }
+  toJSON() {
+    let json = {
+      stepType: "replaceAround",
+      from: this.from,
+      to: this.to,
+      gapFrom: this.gapFrom,
+      gapTo: this.gapTo,
+      insert: this.insert
+    };
+    if (this.slice.size)
+      json.slice = this.slice.toJSON();
+    if (this.structure)
+      json.structure = true;
+    return json;
+  }
+  /**
+  @internal
+  */
+  static fromJSON(schema, json) {
+    if (typeof json.from != "number" || typeof json.to != "number" || typeof json.gapFrom != "number" || typeof json.gapTo != "number" || typeof json.insert != "number")
+      throw new RangeError("Invalid input for ReplaceAroundStep.fromJSON");
+    return new _ReplaceAroundStep(json.from, json.to, json.gapFrom, json.gapTo, Slice.fromJSON(schema, json.slice), json.insert, !!json.structure);
+  }
+};
+Step.jsonID("replaceAround", ReplaceAroundStep);
+function contentBetween(doc, from, to) {
+  let $from = doc.resolve(from), dist = to - from, depth = $from.depth;
+  while (dist > 0 && depth > 0 && $from.indexAfter(depth) == $from.node(depth).childCount) {
+    depth--;
+    dist--;
+  }
+  if (dist > 0) {
+    let next = $from.node(depth).maybeChild($from.indexAfter(depth));
+    while (dist > 0) {
+      if (!next || next.isLeaf)
+        return true;
+      next = next.firstChild;
+      dist--;
+    }
+  }
+  return false;
+}
+var AttrStep = class _AttrStep extends Step {
+  /**
+  Construct an attribute step.
+  */
+  constructor(pos, attr, value) {
+    super();
+    this.pos = pos;
+    this.attr = attr;
+    this.value = value;
+  }
+  apply(doc) {
+    let node = doc.nodeAt(this.pos);
+    if (!node)
+      return StepResult.fail("No node at attribute step's position");
+    let attrs = /* @__PURE__ */ Object.create(null);
+    for (let name in node.attrs)
+      attrs[name] = node.attrs[name];
+    attrs[this.attr] = this.value;
+    let updated = node.type.create(attrs, null, node.marks);
+    return StepResult.fromReplace(doc, this.pos, this.pos + 1, new Slice(Fragment.from(updated), 0, node.isLeaf ? 0 : 1));
+  }
+  getMap() {
+    return StepMap.empty;
+  }
+  invert(doc) {
+    return new _AttrStep(this.pos, this.attr, doc.nodeAt(this.pos).attrs[this.attr]);
+  }
+  map(mapping) {
+    let pos = mapping.mapResult(this.pos, 1);
+    return pos.deletedAfter ? null : new _AttrStep(pos.pos, this.attr, this.value);
+  }
+  toJSON() {
+    return { stepType: "attr", pos: this.pos, attr: this.attr, value: this.value };
+  }
+  static fromJSON(schema, json) {
+    if (typeof json.pos != "number" || typeof json.attr != "string")
+      throw new RangeError("Invalid input for AttrStep.fromJSON");
+    return new _AttrStep(json.pos, json.attr, json.value);
+  }
+};
+Step.jsonID("attr", AttrStep);
+var DocAttrStep = class _DocAttrStep extends Step {
+  /**
+  Construct an attribute step.
+  */
+  constructor(attr, value) {
+    super();
+    this.attr = attr;
+    this.value = value;
+  }
+  apply(doc) {
+    let attrs = /* @__PURE__ */ Object.create(null);
+    for (let name in doc.attrs)
+      attrs[name] = doc.attrs[name];
+    attrs[this.attr] = this.value;
+    let updated = doc.type.create(attrs, doc.content, doc.marks);
+    return StepResult.ok(updated);
+  }
+  getMap() {
+    return StepMap.empty;
+  }
+  invert(doc) {
+    return new _DocAttrStep(this.attr, doc.attrs[this.attr]);
+  }
+  map(mapping) {
+    return this;
+  }
+  toJSON() {
+    return { stepType: "docAttr", attr: this.attr, value: this.value };
+  }
+  static fromJSON(schema, json) {
+    if (typeof json.attr != "string")
+      throw new RangeError("Invalid input for DocAttrStep.fromJSON");
+    return new _DocAttrStep(json.attr, json.value);
+  }
+};
+Step.jsonID("docAttr", DocAttrStep);
+var TransformError = class extends Error {
+};
+TransformError = function TransformError2(message) {
+  let err = Error.call(this, message);
+  err.__proto__ = TransformError2.prototype;
+  return err;
+};
+TransformError.prototype = Object.create(Error.prototype);
+TransformError.prototype.constructor = TransformError;
+TransformError.prototype.name = "TransformError";
+
+// ../../node_modules/.pnpm/prosemirror-state@1.4.3/node_modules/prosemirror-state/dist/index.js
+var classesById = /* @__PURE__ */ Object.create(null);
+var Selection = class {
+  /**
+  Initialize a selection with the head and anchor and ranges. If no
+  ranges are given, constructs a single range across `$anchor` and
+  `$head`.
+  */
+  constructor($anchor, $head, ranges) {
+    this.$anchor = $anchor;
+    this.$head = $head;
+    this.ranges = ranges || [new SelectionRange($anchor.min($head), $anchor.max($head))];
+  }
+  /**
+  The selection's anchor, as an unresolved position.
+  */
+  get anchor() {
+    return this.$anchor.pos;
+  }
+  /**
+  The selection's head.
+  */
+  get head() {
+    return this.$head.pos;
+  }
+  /**
+  The lower bound of the selection's main range.
+  */
+  get from() {
+    return this.$from.pos;
+  }
+  /**
+  The upper bound of the selection's main range.
+  */
+  get to() {
+    return this.$to.pos;
+  }
+  /**
+  The resolved lower  bound of the selection's main range.
+  */
+  get $from() {
+    return this.ranges[0].$from;
+  }
+  /**
+  The resolved upper bound of the selection's main range.
+  */
+  get $to() {
+    return this.ranges[0].$to;
+  }
+  /**
+  Indicates whether the selection contains any content.
+  */
+  get empty() {
+    let ranges = this.ranges;
+    for (let i = 0; i < ranges.length; i++)
+      if (ranges[i].$from.pos != ranges[i].$to.pos)
+        return false;
+    return true;
+  }
+  /**
+  Get the content of this selection as a slice.
+  */
+  content() {
+    return this.$from.doc.slice(this.from, this.to, true);
+  }
+  /**
+  Replace the selection with a slice or, if no slice is given,
+  delete the selection. Will append to the given transaction.
+  */
+  replace(tr, content = Slice.empty) {
+    let lastNode = content.content.lastChild, lastParent = null;
+    for (let i = 0; i < content.openEnd; i++) {
+      lastParent = lastNode;
+      lastNode = lastNode.lastChild;
+    }
+    let mapFrom = tr.steps.length, ranges = this.ranges;
+    for (let i = 0; i < ranges.length; i++) {
+      let { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);
+      tr.replaceRange(mapping.map($from.pos), mapping.map($to.pos), i ? Slice.empty : content);
+      if (i == 0)
+        selectionToInsertionEnd(tr, mapFrom, (lastNode ? lastNode.isInline : lastParent && lastParent.isTextblock) ? -1 : 1);
+    }
+  }
+  /**
+  Replace the selection with the given node, appending the changes
+  to the given transaction.
+  */
+  replaceWith(tr, node) {
+    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);
+      if (i) {
+        tr.deleteRange(from, to);
+      } else {
+        tr.replaceRangeWith(from, to, node);
+        selectionToInsertionEnd(tr, mapFrom, node.isInline ? -1 : 1);
+      }
+    }
+  }
+  /**
+  Find a valid cursor or leaf node selection starting at the given
+  position and searching back if `dir` is negative, and forward if
+  positive. When `textOnly` is true, only consider cursor
+  selections. Will return null when no valid selection position is
+  found.
+  */
+  static findFrom($pos, dir, textOnly = false) {
+    let inner = $pos.parent.inlineContent ? new TextSelection($pos) : findSelectionIn($pos.node(0), $pos.parent, $pos.pos, $pos.index(), dir, textOnly);
+    if (inner)
+      return inner;
+    for (let depth = $pos.depth - 1; depth >= 0; depth--) {
+      let found2 = dir < 0 ? findSelectionIn($pos.node(0), $pos.node(depth), $pos.before(depth + 1), $pos.index(depth), dir, textOnly) : findSelectionIn($pos.node(0), $pos.node(depth), $pos.after(depth + 1), $pos.index(depth) + 1, dir, textOnly);
+      if (found2)
+        return found2;
+    }
+    return null;
+  }
+  /**
+  Find a valid cursor or leaf node selection near the given
+  position. Searches forward first by default, but if `bias` is
+  negative, it will search backwards first.
+  */
+  static near($pos, bias = 1) {
+    return this.findFrom($pos, bias) || this.findFrom($pos, -bias) || new AllSelection($pos.node(0));
+  }
+  /**
+  Find the cursor or leaf node selection closest to the start of
+  the given document. Will return an
+  [`AllSelection`](https://prosemirror.net/docs/ref/#state.AllSelection) if no valid position
+  exists.
+  */
+  static atStart(doc) {
+    return findSelectionIn(doc, doc, 0, 0, 1) || new AllSelection(doc);
+  }
+  /**
+  Find the cursor or leaf node selection closest to the end of the
+  given document.
+  */
+  static atEnd(doc) {
+    return findSelectionIn(doc, doc, doc.content.size, doc.childCount, -1) || new AllSelection(doc);
+  }
+  /**
+  Deserialize the JSON representation of a selection. Must be
+  implemented for custom classes (as a static class method).
+  */
+  static fromJSON(doc, json) {
+    if (!json || !json.type)
+      throw new RangeError("Invalid input for Selection.fromJSON");
+    let cls = classesById[json.type];
+    if (!cls)
+      throw new RangeError(`No selection type ${json.type} defined`);
+    return cls.fromJSON(doc, json);
+  }
+  /**
+  To be able to deserialize selections from JSON, custom selection
+  classes must register themselves with an ID string, so that they
+  can be disambiguated. Try to pick something that's unlikely to
+  clash with classes from other modules.
+  */
+  static jsonID(id, selectionClass) {
+    if (id in classesById)
+      throw new RangeError("Duplicate use of selection JSON ID " + id);
+    classesById[id] = selectionClass;
+    selectionClass.prototype.jsonID = id;
+    return selectionClass;
+  }
+  /**
+  Get a [bookmark](https://prosemirror.net/docs/ref/#state.SelectionBookmark) for this selection,
+  which is a value that can be mapped without having access to a
+  current document, and later resolved to a real selection for a
+  given document again. (This is used mostly by the history to
+  track and restore old selections.) The default implementation of
+  this method just converts the selection to a text selection and
+  returns the bookmark for that.
+  */
+  getBookmark() {
+    return TextSelection.between(this.$anchor, this.$head).getBookmark();
+  }
+};
+Selection.prototype.visible = true;
+var SelectionRange = class {
+  /**
+  Create a range.
+  */
+  constructor($from, $to) {
+    this.$from = $from;
+    this.$to = $to;
+  }
+};
+var warnedAboutTextSelection = false;
+function checkTextSelection($pos) {
+  if (!warnedAboutTextSelection && !$pos.parent.inlineContent) {
+    warnedAboutTextSelection = true;
+    console["warn"]("TextSelection endpoint not pointing into a node with inline content (" + $pos.parent.type.name + ")");
+  }
+}
+var TextSelection = class _TextSelection extends Selection {
+  /**
+  Construct a text selection between the given points.
+  */
+  constructor($anchor, $head = $anchor) {
+    checkTextSelection($anchor);
+    checkTextSelection($head);
+    super($anchor, $head);
+  }
+  /**
+  Returns a resolved position if this is a cursor selection (an
+  empty text selection), and null otherwise.
+  */
+  get $cursor() {
+    return this.$anchor.pos == this.$head.pos ? this.$head : null;
+  }
+  map(doc, mapping) {
+    let $head = doc.resolve(mapping.map(this.head));
+    if (!$head.parent.inlineContent)
+      return Selection.near($head);
+    let $anchor = doc.resolve(mapping.map(this.anchor));
+    return new _TextSelection($anchor.parent.inlineContent ? $anchor : $head, $head);
+  }
+  replace(tr, content = Slice.empty) {
+    super.replace(tr, content);
+    if (content == Slice.empty) {
+      let marks = this.$from.marksAcross(this.$to);
+      if (marks)
+        tr.ensureMarks(marks);
+    }
+  }
+  eq(other) {
+    return other instanceof _TextSelection && other.anchor == this.anchor && other.head == this.head;
+  }
+  getBookmark() {
+    return new TextBookmark(this.anchor, this.head);
+  }
+  toJSON() {
+    return { type: "text", anchor: this.anchor, head: this.head };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(doc, json) {
+    if (typeof json.anchor != "number" || typeof json.head != "number")
+      throw new RangeError("Invalid input for TextSelection.fromJSON");
+    return new _TextSelection(doc.resolve(json.anchor), doc.resolve(json.head));
+  }
+  /**
+  Create a text selection from non-resolved positions.
+  */
+  static create(doc, anchor, head = anchor) {
+    let $anchor = doc.resolve(anchor);
+    return new this($anchor, head == anchor ? $anchor : doc.resolve(head));
+  }
+  /**
+  Return a text selection that spans the given positions or, if
+  they aren't text positions, find a text selection near them.
+  `bias` determines whether the method searches forward (default)
+  or backwards (negative number) first. Will fall back to calling
+  [`Selection.near`](https://prosemirror.net/docs/ref/#state.Selection^near) when the document
+  doesn't contain a valid text position.
+  */
+  static between($anchor, $head, bias) {
+    let dPos = $anchor.pos - $head.pos;
+    if (!bias || dPos)
+      bias = dPos >= 0 ? 1 : -1;
+    if (!$head.parent.inlineContent) {
+      let found2 = Selection.findFrom($head, bias, true) || Selection.findFrom($head, -bias, true);
+      if (found2)
+        $head = found2.$head;
+      else
+        return Selection.near($head, bias);
+    }
+    if (!$anchor.parent.inlineContent) {
+      if (dPos == 0) {
+        $anchor = $head;
+      } else {
+        $anchor = (Selection.findFrom($anchor, -bias, true) || Selection.findFrom($anchor, bias, true)).$anchor;
+        if ($anchor.pos < $head.pos != dPos < 0)
+          $anchor = $head;
+      }
+    }
+    return new _TextSelection($anchor, $head);
+  }
+};
+Selection.jsonID("text", TextSelection);
+var TextBookmark = class _TextBookmark {
+  constructor(anchor, head) {
+    this.anchor = anchor;
+    this.head = head;
+  }
+  map(mapping) {
+    return new _TextBookmark(mapping.map(this.anchor), mapping.map(this.head));
+  }
+  resolve(doc) {
+    return TextSelection.between(doc.resolve(this.anchor), doc.resolve(this.head));
+  }
+};
+var NodeSelection = class _NodeSelection extends Selection {
+  /**
+  Create a node selection. Does not verify the validity of its
+  argument.
+  */
+  constructor($pos) {
+    let node = $pos.nodeAfter;
+    let $end = $pos.node(0).resolve($pos.pos + node.nodeSize);
+    super($pos, $end);
+    this.node = node;
+  }
+  map(doc, mapping) {
+    let { deleted, pos } = mapping.mapResult(this.anchor);
+    let $pos = doc.resolve(pos);
+    if (deleted)
+      return Selection.near($pos);
+    return new _NodeSelection($pos);
+  }
+  content() {
+    return new Slice(Fragment.from(this.node), 0, 0);
+  }
+  eq(other) {
+    return other instanceof _NodeSelection && other.anchor == this.anchor;
+  }
+  toJSON() {
+    return { type: "node", anchor: this.anchor };
+  }
+  getBookmark() {
+    return new NodeBookmark(this.anchor);
+  }
+  /**
+  @internal
+  */
+  static fromJSON(doc, json) {
+    if (typeof json.anchor != "number")
+      throw new RangeError("Invalid input for NodeSelection.fromJSON");
+    return new _NodeSelection(doc.resolve(json.anchor));
+  }
+  /**
+  Create a node selection from non-resolved positions.
+  */
+  static create(doc, from) {
+    return new _NodeSelection(doc.resolve(from));
+  }
+  /**
+  Determines whether the given node may be selected as a node
+  selection.
+  */
+  static isSelectable(node) {
+    return !node.isText && node.type.spec.selectable !== false;
+  }
+};
+NodeSelection.prototype.visible = false;
+Selection.jsonID("node", NodeSelection);
+var NodeBookmark = class _NodeBookmark {
+  constructor(anchor) {
+    this.anchor = anchor;
+  }
+  map(mapping) {
+    let { deleted, pos } = mapping.mapResult(this.anchor);
+    return deleted ? new TextBookmark(pos, pos) : new _NodeBookmark(pos);
+  }
+  resolve(doc) {
+    let $pos = doc.resolve(this.anchor), node = $pos.nodeAfter;
+    if (node && NodeSelection.isSelectable(node))
+      return new NodeSelection($pos);
+    return Selection.near($pos);
+  }
+};
+var AllSelection = class _AllSelection extends Selection {
+  /**
+  Create an all-selection over the given document.
+  */
+  constructor(doc) {
+    super(doc.resolve(0), doc.resolve(doc.content.size));
+  }
+  replace(tr, content = Slice.empty) {
+    if (content == Slice.empty) {
+      tr.delete(0, tr.doc.content.size);
+      let sel = Selection.atStart(tr.doc);
+      if (!sel.eq(tr.selection))
+        tr.setSelection(sel);
+    } else {
+      super.replace(tr, content);
+    }
+  }
+  toJSON() {
+    return { type: "all" };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(doc) {
+    return new _AllSelection(doc);
+  }
+  map(doc) {
+    return new _AllSelection(doc);
+  }
+  eq(other) {
+    return other instanceof _AllSelection;
+  }
+  getBookmark() {
+    return AllBookmark;
+  }
+};
+Selection.jsonID("all", AllSelection);
+var AllBookmark = {
+  map() {
+    return this;
+  },
+  resolve(doc) {
+    return new AllSelection(doc);
+  }
+};
+function findSelectionIn(doc, node, pos, index, dir, text = false) {
+  if (node.inlineContent)
+    return TextSelection.create(doc, pos);
+  for (let i = index - (dir > 0 ? 0 : 1); dir > 0 ? i < node.childCount : i >= 0; i += dir) {
+    let child = node.child(i);
+    if (!child.isAtom) {
+      let inner = findSelectionIn(doc, child, pos + dir, dir < 0 ? child.childCount : 0, dir, text);
+      if (inner)
+        return inner;
+    } else if (!text && NodeSelection.isSelectable(child)) {
+      return NodeSelection.create(doc, pos - (dir < 0 ? child.nodeSize : 0));
+    }
+    pos += child.nodeSize * dir;
+  }
+  return null;
+}
+function selectionToInsertionEnd(tr, startLen, bias) {
+  let last = tr.steps.length - 1;
+  if (last < startLen)
+    return;
+  let step = tr.steps[last];
+  if (!(step instanceof ReplaceStep || step instanceof ReplaceAroundStep))
+    return;
+  let map = tr.mapping.maps[last], end;
+  map.forEach((_from, _to, _newFrom, newTo) => {
+    if (end == null)
+      end = newTo;
+  });
+  tr.setSelection(Selection.near(tr.doc.resolve(end), bias));
+}
+function bind(f, self) {
+  return !self || !f ? f : f.bind(self);
+}
+var FieldDesc = class {
+  constructor(name, desc, self) {
+    this.name = name;
+    this.init = bind(desc.init, self);
+    this.apply = bind(desc.apply, self);
+  }
+};
+var baseFields = [
+  new FieldDesc("doc", {
+    init(config) {
+      return config.doc || config.schema.topNodeType.createAndFill();
+    },
+    apply(tr) {
+      return tr.doc;
+    }
+  }),
+  new FieldDesc("selection", {
+    init(config, instance) {
+      return config.selection || Selection.atStart(instance.doc);
+    },
+    apply(tr) {
+      return tr.selection;
+    }
+  }),
+  new FieldDesc("storedMarks", {
+    init(config) {
+      return config.storedMarks || null;
+    },
+    apply(tr, _marks, _old, state) {
+      return state.selection.$cursor ? tr.storedMarks : null;
+    }
+  }),
+  new FieldDesc("scrollToSelection", {
+    init() {
+      return 0;
+    },
+    apply(tr, prev) {
+      return tr.scrolledIntoView ? prev + 1 : prev;
+    }
+  })
+];
+function bindProps(obj, self, target) {
+  for (let prop in obj) {
+    let val = obj[prop];
+    if (val instanceof Function)
+      val = val.bind(self);
+    else if (prop == "handleDOMEvents")
+      val = bindProps(val, self, {});
+    target[prop] = val;
+  }
+  return target;
+}
+var Plugin = class {
+  /**
+  Create a plugin.
+  */
+  constructor(spec) {
+    this.spec = spec;
+    this.props = {};
+    if (spec.props)
+      bindProps(spec.props, this, this.props);
+    this.key = spec.key ? spec.key.key : createKey("plugin");
+  }
+  /**
+  Extract the plugin's state field from an editor state.
+  */
+  getState(state) {
+    return state[this.key];
+  }
+};
+var keys = /* @__PURE__ */ Object.create(null);
+function createKey(name) {
+  if (name in keys)
+    return name + "$" + ++keys[name];
+  keys[name] = 0;
+  return name + "$";
+}
+var PluginKey = class {
+  /**
+  Create a plugin key.
+  */
+  constructor(name = "key") {
+    this.key = createKey(name);
+  }
+  /**
+  Get the active plugin with this key, if any, from an editor
+  state.
+  */
+  get(state) {
+    return state.config.pluginsByKey[this.key];
+  }
+  /**
+  Get the plugin's state from an editor state.
+  */
+  getState(state) {
+    return state[this.key];
+  }
+};
+
+// src/add-slide-button.ts
+var SlideNodeView = class {
+  constructor(node, view, getPos, options) {
+    this.node = node;
+    this.view = view;
+    this.getPos = getPos;
+    this.options = options;
+    this.dom = document.createElement("div");
+    this.dom.classList.add("slide-wrapper");
+    const slideSpec = node.type.spec;
+    const rendered = slideSpec.toDOM ? slideSpec.toDOM(node) : null;
+    if (rendered && Array.isArray(rendered)) {
+      const [tag, attrs] = rendered;
+      this.contentDOM = document.createElement(tag);
+      if (attrs && typeof attrs === "object") {
+        Object.entries(attrs).forEach(([key, value]) => {
+          if (key === "class") {
+            this.contentDOM.className = value;
+          } else {
+            this.contentDOM.setAttribute(key, String(value));
+          }
+        });
+      }
+    } else {
+      this.contentDOM = document.createElement("div");
+      this.contentDOM.className = "slide";
+      this.contentDOM.setAttribute("data-node-type", "slide");
+    }
+    this.button = document.createElement("button");
+    this.button.className = "add-slide-button";
+    this.button.innerHTML = options.content;
+    this.button.setAttribute("type", "button");
+    this.button.contentEditable = "false";
+    if (options.buttonStyle) {
+      Object.entries(options.buttonStyle).forEach(([key, value]) => {
+        const camelKey = key.replace(
+          /-([a-z])/g,
+          (_, letter) => letter.toUpperCase()
+        );
+        this.button.style[camelKey] = value;
+      });
+    }
+    this.button.onclick = (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      const pos = this.getPos();
+      if (pos === void 0) return;
+      if (options.onClick) {
+        let slideIndex = 0;
+        this.view.state.doc.nodesBetween(0, pos, (n) => {
+          if (n.type.name === "slide") slideIndex++;
+        });
+        options.onClick({
+          slideIndex,
+          position: pos + this.node.nodeSize,
+          view: this.view,
+          event
+        });
+      } else {
+        const schema = this.view.state.schema;
+        const slideType = schema.nodes.slide;
+        const paragraphType = schema.nodes.paragraph;
+        const slideContent = paragraphType.create();
+        const slide = slideType.create(null, slideContent);
+        const tr = this.view.state.tr.insert(pos + this.node.nodeSize, slide);
+        this.view.dispatch(tr);
+      }
+    };
+    this.dom.appendChild(this.contentDOM);
+    this.dom.appendChild(this.button);
+  }
+  update(node) {
+    if (node.type.name !== "slide") return false;
+    this.node = node;
+    return true;
+  }
+  destroy() {
+    this.button.onclick = null;
+  }
+};
+var addSlideButtonStyles = `
+.slide-wrapper {
+  position: relative;
+}
+
+.add-slide-button {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 48px;
+  height: 48px;
+  margin: 16px auto 32px auto;
+  padding: 0;
+  border: 2px solid var(--slide-border, #e5e5e5);
+  border-radius: 25%;
+  background-color: var(--slide-bg, #ffffff);
+  color: var(--editor-fg, #1a1a1a);
+  font-size: 24px;
+  font-weight: 300;
+  cursor: pointer;
+  transition: all 0.2s ease;
+  box-shadow: var(--slide-shadow, 0 4px 12px rgba(0, 0, 0, 0.08));
+}
+
+.add-slide-button:hover {
+  background-color: var(--editor-hover, #f0f0f0);
+  border-color: var(--editor-selection, #3b82f6);
+  transform: scale(1.05);
+}
+
+.add-slide-button:active {
+  background-color: var(--editor-active, #e8e8e8);
+  transform: scale(0.95);
+}
+
+.add-slide-button:focus {
+  outline: 2px solid var(--editor-focus, #3b82f6);
+  outline-offset: 2px;
+}
+`;
+var AddSlideButton = Extension.create({
+  name: "addSlideButton",
+  addOptions() {
+    return {
+      injectCSS: true,
+      injectNonce: void 0,
+      buttonStyle: {},
+      content: "+",
+      onClick: null
+    };
+  },
+  addProseMirrorPlugins() {
+    const options = this.options;
+    if (options.injectCSS) {
+      createStyleTag(
+        addSlideButtonStyles,
+        options.injectNonce,
+        "add-slide-button"
+      );
+    }
+    return [
+      new Plugin({
+        key: new PluginKey("addSlideButton"),
+        props: {
+          nodeViews: {
+            slide: (node, view, getPos) => {
+              return new SlideNodeView(
+                node,
+                view,
+                getPos,
+                options
+              );
+            }
+          }
+        }
+      })
+    ];
+  }
+});
+
+// src/index.ts
+var index_default = AddSlideButton;
+export {
+  AddSlideButton,
+  index_default as default
+};
+//# sourceMappingURL=index.js.map