pptx-glimpse 1.1.2 → 3.0.0

package/dist/browser.js

@@ -0,0 +1,3180 @@
+import {
+  DEFAULT_OUTPUT_WIDTH,
+  asPartPath,
+  asRelationshipId,
+  asSourceNodeId,
+  collectUsedFonts,
+  convertPptxToSvg,
+  findShapeNodeBySourceHandle,
+  readPptx,
+  replaceParagraphPlainText,
+  replaceTextRunPlainText,
+  updateShapeTransform,
+  writePptx
+} from "./chunk-KMSN55AE.js";
+import {
+  DEFAULT_FONT_MAPPING,
+  clearFontCache,
+  createFontMapping,
+  createOpentypeSetupFromBuffers,
+  createOpentypeTextMeasurerFromBuffers,
+  getMappedFont,
+  getWarningEntries,
+  getWarningSummary
+} from "./chunk-2AYNMYMC.js";
+import {
+  renderSvgToPng
+} from "./chunk-QPT6BMN5.js";
+
+// ../renderer/src/png/browser-png-converter.ts
+import { initWasm } from "@resvg/resvg-wasm";
+var wasmInitPromise = null;
+async function normalizeWasmInput(wasm) {
+  if (wasm instanceof ArrayBuffer || wasm instanceof Uint8Array) {
+    return wasm;
+  }
+  if (!wasm.ok) {
+    throw new Error(`Failed to load resvg WASM: HTTP ${wasm.status.toString()}`);
+  }
+  return wasm.arrayBuffer();
+}
+async function initResvgWasm(wasm) {
+  if (!wasmInitPromise) {
+    wasmInitPromise = normalizeWasmInput(wasm).then((wasmInput) => initWasm(wasmInput)).catch((error) => {
+      wasmInitPromise = null;
+      throw error;
+    });
+  }
+  await wasmInitPromise;
+}
+async function svgToPng(svgString, options) {
+  if (!wasmInitPromise) {
+    throw new Error("initResvgWasm(wasm) must be called before browser PNG conversion.");
+  }
+  await wasmInitPromise;
+  return renderSvgToPng(svgString, options);
+}
+
+// ../../node_modules/.pnpm/orderedmap@2.1.1/node_modules/orderedmap/dist/index.js
+function OrderedMap(content) {
+  this.content = content;
+}
+OrderedMap.prototype = {
+  constructor: OrderedMap,
+  find: function(key) {
+    for (var i = 0; i < this.content.length; i += 2)
+      if (this.content[i] === key) return i;
+    return -1;
+  },
+  // :: (string) → ?any
+  // Retrieve the value stored under `key`, or return undefined when
+  // no such key exists.
+  get: function(key) {
+    var found2 = this.find(key);
+    return found2 == -1 ? void 0 : this.content[found2 + 1];
+  },
+  // :: (string, any, ?string) → OrderedMap
+  // Create a new map by replacing the value of `key` with a new
+  // value, or adding a binding to the end of the map. If `newKey` is
+  // given, the key of the binding will be replaced with that key.
+  update: function(key, value, newKey) {
+    var self = newKey && newKey != key ? this.remove(newKey) : this;
+    var found2 = self.find(key), content = self.content.slice();
+    if (found2 == -1) {
+      content.push(newKey || key, value);
+    } else {
+      content[found2 + 1] = value;
+      if (newKey) content[found2] = newKey;
+    }
+    return new OrderedMap(content);
+  },
+  // :: (string) → OrderedMap
+  // Return a map with the given key removed, if it existed.
+  remove: function(key) {
+    var found2 = this.find(key);
+    if (found2 == -1) return this;
+    var content = this.content.slice();
+    content.splice(found2, 2);
+    return new OrderedMap(content);
+  },
+  // :: (string, any) → OrderedMap
+  // Add a new key to the start of the map.
+  addToStart: function(key, value) {
+    return new OrderedMap([key, value].concat(this.remove(key).content));
+  },
+  // :: (string, any) → OrderedMap
+  // Add a new key to the end of the map.
+  addToEnd: function(key, value) {
+    var content = this.remove(key).content.slice();
+    content.push(key, value);
+    return new OrderedMap(content);
+  },
+  // :: (string, string, any) → OrderedMap
+  // Add a key after the given key. If `place` is not found, the new
+  // key is added to the end.
+  addBefore: function(place, key, value) {
+    var without = this.remove(key), content = without.content.slice();
+    var found2 = without.find(place);
+    content.splice(found2 == -1 ? content.length : found2, 0, key, value);
+    return new OrderedMap(content);
+  },
+  // :: ((key: string, value: any))
+  // Call the given function for each key/value pair in the map, in
+  // order.
+  forEach: function(f) {
+    for (var i = 0; i < this.content.length; i += 2)
+      f(this.content[i], this.content[i + 1]);
+  },
+  // :: (union<Object, OrderedMap>) → OrderedMap
+  // Create a new map by prepending the keys in this map that don't
+  // appear in `map` before the keys in `map`.
+  prepend: function(map) {
+    map = OrderedMap.from(map);
+    if (!map.size) return this;
+    return new OrderedMap(map.content.concat(this.subtract(map).content));
+  },
+  // :: (union<Object, OrderedMap>) → OrderedMap
+  // Create a new map by appending the keys in this map that don't
+  // appear in `map` after the keys in `map`.
+  append: function(map) {
+    map = OrderedMap.from(map);
+    if (!map.size) return this;
+    return new OrderedMap(this.subtract(map).content.concat(map.content));
+  },
+  // :: (union<Object, OrderedMap>) → OrderedMap
+  // Create a map containing all the keys in this map that don't
+  // appear in `map`.
+  subtract: function(map) {
+    var result = this;
+    map = OrderedMap.from(map);
+    for (var i = 0; i < map.content.length; i += 2)
+      result = result.remove(map.content[i]);
+    return result;
+  },
+  // :: () → Object
+  // Turn ordered map into a plain object.
+  toObject: function() {
+    var result = {};
+    this.forEach(function(key, value) {
+      result[key] = value;
+    });
+    return result;
+  },
+  // :: number
+  // The amount of keys in this map.
+  get size() {
+    return this.content.length >> 1;
+  }
+};
+OrderedMap.from = function(value) {
+  if (value instanceof OrderedMap) return value;
+  var content = [];
+  if (value) for (var prop in value) content.push(prop, value[prop]);
+  return new OrderedMap(content);
+};
+var dist_default = OrderedMap;
+
+// ../../node_modules/.pnpm/prosemirror-model@1.25.9/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) {
+      let tA = childA.text, tB = childB.text, j = 0;
+      for (; tA[j] == tB[j]; j++)
+        pos++;
+      if (j && j < tA.length && j < tB.length && surrogateHigh(tA.charCodeAt(j - 1)) && surrogateLow(tA.charCodeAt(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 tA = childA.text, tB = childB.text, iA2 = tA.length, iB2 = tB.length;
+      while (iA2 > 0 && iB2 > 0 && tA[iA2 - 1] == tB[iB2 - 1]) {
+        iA2--;
+        iB2--;
+        posA--;
+        posB--;
+      }
+      if (iA2 && iB2 && iA2 < tA.length && surrogateHigh(tA.charCodeAt(iA2 - 1)) && surrogateLow(tA.charCodeAt(iA2))) {
+        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;
+  }
+}
+function surrogateLow(ch) {
+  return ch >= 56320 && ch < 57344;
+}
+function surrogateHigh(ch) {
+  return ch >= 55296 && ch < 56320;
+}
+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 _Fragment.fromArray(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, this.openStart + 1, this.openEnd + 1);
+    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, openStart, openEnd, parent) {
+  let { index, offset } = content.findIndex(dist), child = content.maybeChild(index);
+  if (offset == dist || child.isText) {
+    if (parent && openStart <= 0 && openEnd <= 0 && !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, index == 0 ? openStart - 1 : 0, index == content.childCount - 1 ? openEnd - 1 : 0, 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) {
+  if (!node.type.validContent(content))
+    throw new ReplaceError("Invalid content for node " + node.type.name);
+  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 overlapping
+  the given two positions that are relative to start of this
+  node's content. This includes all ancestors of the nodes
+  containing the two positions. 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;
+var TextNode = class _TextNode extends Node {
+  /**
+  @internal
+  */
+  constructor(type, attrs, content, marks) {
+    super(type, attrs, null, marks);
+    if (!content)
+      throw new RangeError("Empty text nodes are not allowed");
+    this.text = content;
+  }
+  toString() {
+    if (this.type.spec.toDebugString)
+      return this.type.spec.toDebugString(this);
+    return wrapMarks(this.marks, JSON.stringify(this.text));
+  }
+  get textContent() {
+    return this.text;
+  }
+  textBetween(from, to) {
+    return this.text.slice(from, to);
+  }
+  get nodeSize() {
+    return this.text.length;
+  }
+  mark(marks) {
+    return marks == this.marks ? this : new _TextNode(this.type, this.attrs, this.text, marks);
+  }
+  withText(text) {
+    if (text == this.text)
+      return this;
+    return new _TextNode(this.type, this.attrs, text, this.marks);
+  }
+  cut(from = 0, to = this.text.length) {
+    if (from == 0 && to == this.text.length)
+      return this;
+    return this.withText(this.text.slice(from, to));
+  }
+  eq(other) {
+    return this.sameMarkup(other) && this.text == other.text;
+  }
+  toJSON() {
+    let base = super.toJSON();
+    base.text = this.text;
+    return base;
+  }
+};
+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)");
+  }
+}
+function defaultAttrs(attrs) {
+  let defaults = /* @__PURE__ */ Object.create(null);
+  for (let attrName in attrs) {
+    let attr = attrs[attrName];
+    if (!attr.hasDefault)
+      return null;
+    defaults[attrName] = attr.default;
+  }
+  return defaults;
+}
+function computeAttrs(attrs, value) {
+  let built = /* @__PURE__ */ Object.create(null);
+  for (let name in attrs) {
+    let given = value && value[name];
+    if (given === void 0) {
+      let attr = attrs[name];
+      if (attr.hasDefault)
+        given = attr.default;
+      else
+        throw new RangeError("No value supplied for attribute " + name);
+    }
+    built[name] = given;
+  }
+  return built;
+}
+function checkAttrs(attrs, values, type, name) {
+  for (let attr in values)
+    if (!(attr in attrs))
+      throw new RangeError(`Unsupported attribute ${attr} for ${type} of type ${name}`);
+  for (let attr in attrs) {
+    if (attrs[attr].validate)
+      attrs[attr].validate(values[attr]);
+  }
+}
+function initAttrs(typeName, attrs) {
+  let result = /* @__PURE__ */ Object.create(null);
+  if (attrs)
+    for (let name in attrs)
+      result[name] = new Attribute(typeName, name, attrs[name]);
+  return result;
+}
+var NodeType = class _NodeType {
+  /**
+  @internal
+  */
+  constructor(name, schema, spec) {
+    this.name = name;
+    this.schema = schema;
+    this.spec = spec;
+    this.markSet = null;
+    this.groups = spec.group ? spec.group.split(" ") : [];
+    this.attrs = initAttrs(name, spec.attrs);
+    this.defaultAttrs = defaultAttrs(this.attrs);
+    this.contentMatch = null;
+    this.inlineContent = null;
+    this.isBlock = !(spec.inline || name == "text");
+    this.isText = name == "text";
+  }
+  /**
+  True if this is an inline type.
+  */
+  get isInline() {
+    return !this.isBlock;
+  }
+  /**
+  True if this is a textblock type, a block that contains inline
+  content.
+  */
+  get isTextblock() {
+    return this.isBlock && this.inlineContent;
+  }
+  /**
+  True for node types that allow no content.
+  */
+  get isLeaf() {
+    return this.contentMatch == ContentMatch.empty;
+  }
+  /**
+  True when this node is an atom, i.e. when it does not have
+  directly editable content.
+  */
+  get isAtom() {
+    return this.isLeaf || !!this.spec.atom;
+  }
+  /**
+  Return true when this node type is part of the given
+  [group](https://prosemirror.net/docs/ref/#model.NodeSpec.group).
+  */
+  isInGroup(group) {
+    return this.groups.indexOf(group) > -1;
+  }
+  /**
+  The node type's [whitespace](https://prosemirror.net/docs/ref/#model.NodeSpec.whitespace) option.
+  */
+  get whitespace() {
+    return this.spec.whitespace || (this.spec.code ? "pre" : "normal");
+  }
+  /**
+  Tells you whether this node type has any required attributes.
+  */
+  hasRequiredAttrs() {
+    for (let n in this.attrs)
+      if (this.attrs[n].isRequired)
+        return true;
+    return false;
+  }
+  /**
+  Indicates whether this node allows some of the same content as
+  the given node type.
+  */
+  compatibleContent(other) {
+    return this == other || this.contentMatch.compatible(other.contentMatch);
+  }
+  /**
+  @internal
+  */
+  computeAttrs(attrs) {
+    if (!attrs && this.defaultAttrs)
+      return this.defaultAttrs;
+    else
+      return computeAttrs(this.attrs, attrs);
+  }
+  /**
+  Create a `Node` of this type. The given attributes are
+  checked and defaulted (you can pass `null` to use the type's
+  defaults entirely, if no required attributes exist). `content`
+  may be a `Fragment`, a node, an array of nodes, or
+  `null`. Similarly `marks` may be `null` to default to the empty
+  set of marks.
+  */
+  create(attrs = null, content, marks) {
+    if (this.isText)
+      throw new Error("NodeType.create can't construct text nodes");
+    return new Node(this, this.computeAttrs(attrs), Fragment.from(content), Mark.setFrom(marks));
+  }
+  /**
+  Like [`create`](https://prosemirror.net/docs/ref/#model.NodeType.create), but check the given content
+  against the node type's content restrictions, and throw an error
+  if it doesn't match.
+  */
+  createChecked(attrs = null, content, marks) {
+    content = Fragment.from(content);
+    this.checkContent(content);
+    return new Node(this, this.computeAttrs(attrs), content, Mark.setFrom(marks));
+  }
+  /**
+  Like [`create`](https://prosemirror.net/docs/ref/#model.NodeType.create), but see if it is
+  necessary to add nodes to the start or end of the given fragment
+  to make it fit the node. If no fitting wrapping can be found,
+  return null. Note that, due to the fact that required nodes can
+  always be created, this will always succeed if you pass null or
+  `Fragment.empty` as content.
+  */
+  createAndFill(attrs = null, content, marks) {
+    attrs = this.computeAttrs(attrs);
+    content = Fragment.from(content);
+    if (content.size) {
+      let before = this.contentMatch.fillBefore(content);
+      if (!before)
+        return null;
+      content = before.append(content);
+    }
+    let matched = this.contentMatch.matchFragment(content);
+    let after = matched && matched.fillBefore(Fragment.empty, true);
+    if (!after)
+      return null;
+    return new Node(this, attrs, content.append(after), Mark.setFrom(marks));
+  }
+  /**
+  Returns true if the given fragment is valid content for this node
+  type.
+  */
+  validContent(content) {
+    let result = this.contentMatch.matchFragment(content);
+    if (!result || !result.validEnd)
+      return false;
+    for (let i = 0; i < content.childCount; i++)
+      if (!this.allowsMarks(content.child(i).marks))
+        return false;
+    return true;
+  }
+  /**
+  Throws a RangeError if the given fragment is not valid content for this
+  node type.
+  @internal
+  */
+  checkContent(content) {
+    if (!this.validContent(content))
+      throw new RangeError(`Invalid content for node ${this.name}: ${content.toString().slice(0, 50)}`);
+  }
+  /**
+  @internal
+  */
+  checkAttrs(attrs) {
+    checkAttrs(this.attrs, attrs, "node", this.name);
+  }
+  /**
+  Check whether the given mark type is allowed in this node.
+  */
+  allowsMarkType(markType) {
+    return this.markSet == null || this.markSet.indexOf(markType) > -1;
+  }
+  /**
+  Test whether the given set of marks are allowed in this node.
+  */
+  allowsMarks(marks) {
+    if (this.markSet == null)
+      return true;
+    for (let i = 0; i < marks.length; i++)
+      if (!this.allowsMarkType(marks[i].type))
+        return false;
+    return true;
+  }
+  /**
+  Removes the marks that are not allowed in this node from the given set.
+  */
+  allowedMarks(marks) {
+    if (this.markSet == null)
+      return marks;
+    let copy;
+    for (let i = 0; i < marks.length; i++) {
+      if (!this.allowsMarkType(marks[i].type)) {
+        if (!copy)
+          copy = marks.slice(0, i);
+      } else if (copy) {
+        copy.push(marks[i]);
+      }
+    }
+    return !copy ? marks : copy.length ? copy : Mark.none;
+  }
+  /**
+  @internal
+  */
+  static compile(nodes, schema) {
+    let result = /* @__PURE__ */ Object.create(null);
+    nodes.forEach((name, spec) => result[name] = new _NodeType(name, schema, spec));
+    let topType = schema.spec.topNode || "doc";
+    if (!result[topType])
+      throw new RangeError("Schema is missing its top node type ('" + topType + "')");
+    if (!result.text)
+      throw new RangeError("Every schema needs a 'text' type");
+    for (let _ in result.text.attrs)
+      throw new RangeError("The text node type should not have attributes");
+    return result;
+  }
+};
+function validateType(typeName, attrName, type) {
+  let types = type.split("|");
+  return (value) => {
+    let name = value === null ? "null" : typeof value;
+    if (types.indexOf(name) < 0)
+      throw new RangeError(`Expected value of type ${types} for attribute ${attrName} on type ${typeName}, got ${name}`);
+  };
+}
+var Attribute = class {
+  constructor(typeName, attrName, options) {
+    this.hasDefault = Object.prototype.hasOwnProperty.call(options, "default");
+    this.default = options.default;
+    this.validate = typeof options.validate == "string" ? validateType(typeName, attrName, options.validate) : options.validate;
+  }
+  get isRequired() {
+    return !this.hasDefault;
+  }
+};
+var MarkType = class _MarkType {
+  /**
+  @internal
+  */
+  constructor(name, rank, schema, spec) {
+    this.name = name;
+    this.rank = rank;
+    this.schema = schema;
+    this.spec = spec;
+    this.attrs = initAttrs(name, spec.attrs);
+    this.excluded = null;
+    let defaults = defaultAttrs(this.attrs);
+    this.instance = defaults ? new Mark(this, defaults) : null;
+  }
+  /**
+  Create a mark of this type. `attrs` may be `null` or an object
+  containing only some of the mark's attributes. The others, if
+  they have defaults, will be added.
+  */
+  create(attrs = null) {
+    if (!attrs && this.instance)
+      return this.instance;
+    return new Mark(this, computeAttrs(this.attrs, attrs));
+  }
+  /**
+  @internal
+  */
+  static compile(marks, schema) {
+    let result = /* @__PURE__ */ Object.create(null), rank = 0;
+    marks.forEach((name, spec) => result[name] = new _MarkType(name, rank++, schema, spec));
+    return result;
+  }
+  /**
+  When there is a mark of this type in the given set, a new set
+  without it is returned. Otherwise, the input set is returned.
+  */
+  removeFromSet(set) {
+    for (var i = 0; i < set.length; i++)
+      if (set[i].type == this) {
+        set = set.slice(0, i).concat(set.slice(i + 1));
+        i--;
+      }
+    return set;
+  }
+  /**
+  Tests whether there is a mark of this type in the given set.
+  */
+  isInSet(set) {
+    for (let i = 0; i < set.length; i++)
+      if (set[i].type == this)
+        return set[i];
+  }
+  /**
+  @internal
+  */
+  checkAttrs(attrs) {
+    checkAttrs(this.attrs, attrs, "mark", this.name);
+  }
+  /**
+  Queries whether a given mark type is
+  [excluded](https://prosemirror.net/docs/ref/#model.MarkSpec.excludes) by this one.
+  */
+  excludes(other) {
+    return this.excluded.indexOf(other) > -1;
+  }
+};
+var Schema = class {
+  /**
+  Construct a schema from a schema [specification](https://prosemirror.net/docs/ref/#model.SchemaSpec).
+  */
+  constructor(spec) {
+    this.linebreakReplacement = null;
+    this.cached = /* @__PURE__ */ Object.create(null);
+    let instanceSpec = this.spec = {};
+    for (let prop in spec)
+      instanceSpec[prop] = spec[prop];
+    instanceSpec.nodes = dist_default.from(spec.nodes), instanceSpec.marks = dist_default.from(spec.marks || {}), this.nodes = NodeType.compile(this.spec.nodes, this);
+    this.marks = MarkType.compile(this.spec.marks, this);
+    let contentExprCache = /* @__PURE__ */ Object.create(null);
+    for (let prop in this.nodes) {
+      if (prop in this.marks)
+        throw new RangeError(prop + " can not be both a node and a mark");
+      let type = this.nodes[prop], contentExpr = type.spec.content || "", markExpr = type.spec.marks;
+      type.contentMatch = contentExprCache[contentExpr] || (contentExprCache[contentExpr] = ContentMatch.parse(contentExpr, this.nodes));
+      type.inlineContent = type.contentMatch.inlineContent;
+      if (type.spec.linebreakReplacement) {
+        if (this.linebreakReplacement)
+          throw new RangeError("Multiple linebreak nodes defined");
+        if (!type.isInline || !type.isLeaf)
+          throw new RangeError("Linebreak replacement nodes must be inline leaf nodes");
+        this.linebreakReplacement = type;
+      }
+      type.markSet = markExpr == "_" ? null : markExpr ? gatherMarks(this, markExpr.split(" ")) : markExpr == "" || !type.inlineContent ? [] : null;
+    }
+    for (let prop in this.marks) {
+      let type = this.marks[prop], excl = type.spec.excludes;
+      type.excluded = excl == null ? [type] : excl == "" ? [] : gatherMarks(this, excl.split(" "));
+    }
+    this.nodeFromJSON = (json) => Node.fromJSON(this, json);
+    this.markFromJSON = (json) => Mark.fromJSON(this, json);
+    this.topNodeType = this.nodes[this.spec.topNode || "doc"];
+    this.cached.wrappings = /* @__PURE__ */ Object.create(null);
+  }
+  /**
+  Create a node in this schema. The `type` may be a string or a
+  `NodeType` instance. Attributes will be extended with defaults,
+  `content` may be a `Fragment`, `null`, a `Node`, or an array of
+  nodes.
+  */
+  node(type, attrs = null, content, marks) {
+    if (typeof type == "string")
+      type = this.nodeType(type);
+    else if (!(type instanceof NodeType))
+      throw new RangeError("Invalid node type: " + type);
+    else if (type.schema != this)
+      throw new RangeError("Node type from different schema used (" + type.name + ")");
+    return type.createChecked(attrs, content, marks);
+  }
+  /**
+  Create a text node in the schema. Empty text nodes are not
+  allowed.
+  */
+  text(text, marks) {
+    let type = this.nodes.text;
+    return new TextNode(type, type.defaultAttrs, text, Mark.setFrom(marks));
+  }
+  /**
+  Create a mark with the given type and attributes.
+  */
+  mark(type, attrs) {
+    if (typeof type == "string")
+      type = this.marks[type];
+    return type.create(attrs);
+  }
+  /**
+  @internal
+  */
+  nodeType(name) {
+    let found2 = this.nodes[name];
+    if (!found2)
+      throw new RangeError("Unknown node type: " + name);
+    return found2;
+  }
+};
+function gatherMarks(schema, marks) {
+  let found2 = [];
+  for (let i = 0; i < marks.length; i++) {
+    let name = marks[i], mark = schema.marks[name], ok = mark;
+    if (mark) {
+      found2.push(mark);
+    } else {
+      for (let prop in schema.marks) {
+        let mark2 = schema.marks[prop];
+        if (name == "_" || mark2.spec.group && mark2.spec.group.split(" ").indexOf(name) > -1)
+          found2.push(ok = mark2);
+      }
+    }
+    if (!ok)
+      throw new SyntaxError("Unknown mark type: '" + marks[i] + "'");
+  }
+  return found2;
+}
+
+// ../editor-core/dist/index.js
+var pptxTextBodySchema = new Schema({
+  nodes: {
+    doc: { content: "paragraph*" },
+    paragraph: {
+      content: "text*",
+      attrs: {
+        handle: { default: null },
+        properties: { default: null }
+      },
+      toDOM: () => ["p", 0]
+    },
+    text: { group: "inline" }
+  },
+  marks: {
+    pptxRun: {
+      attrs: {
+        handle: { default: null },
+        properties: { default: null }
+      },
+      toDOM: () => ["span", { "data-pptx-run": "" }, 0]
+    }
+  }
+});
+function textBodyToProseMirrorDocJson(textBody) {
+  assertSupportedTextBody(textBody);
+  return {
+    type: "doc",
+    content: textBody.paragraphs.map((paragraph) => {
+      const content = paragraph.runs.map((run) => ({
+        type: "text",
+        text: run.text,
+        marks: [
+          {
+            type: "pptxRun",
+            attrs: {
+              handle: run.handle ?? null,
+              properties: run.properties ?? null
+            }
+          }
+        ]
+      }));
+      return {
+        type: "paragraph",
+        attrs: {
+          handle: paragraph.handle ?? null,
+          properties: paragraph.properties ?? null
+        },
+        ...content.length > 0 ? { content } : {}
+      };
+    })
+  };
+}
+function assertSupportedTextBody(textBody) {
+  textBody.paragraphs.forEach((paragraph, paragraphIndex) => {
+    paragraph.runs.forEach((run, runIndex) => {
+      if (run.text.length === 0) {
+        throw new Error(
+          `textBodyToProseMirrorDocJson: empty text runs are unsupported at paragraph ${paragraphIndex}, run ${runIndex}`
+        );
+      }
+      if (run.text.includes("\n") || (run.rawSidecars?.length ?? 0) > 0) {
+        throw new Error(
+          `textBodyToProseMirrorDocJson: unsupported run-like content at paragraph ${paragraphIndex}, run ${runIndex}`
+        );
+      }
+    });
+  });
+}
+function proseMirrorDocJsonToTextBody(originalTextBody, docJson) {
+  const parsed = parsePptxTextBodyProseMirrorDocJson(docJson);
+  validateProseMirrorDocJson(parsed);
+  const paragraphs = (parsed.content ?? []).map(
+    (paragraph, index) => paragraphJsonToSourceParagraph(originalTextBody.paragraphs[index], paragraph)
+  );
+  return {
+    ...originalTextBody,
+    paragraphs
+  };
+}
+function proseMirrorDocJsonToEditorCommands(originalTextBody, docJson) {
+  const editedTextBody = proseMirrorDocJsonToTextBody(originalTextBody, docJson);
+  if (editedTextBody.paragraphs.length !== originalTextBody.paragraphs.length) {
+    throw new Error("proseMirrorDocJsonToEditorCommands: paragraph count changes are unsupported");
+  }
+  return editedTextBody.paragraphs.flatMap(
+    (editedParagraph, paragraphIndex) => {
+      const originalParagraph = originalTextBody.paragraphs[paragraphIndex];
+      if (originalParagraph === void 0) return [];
+      if (paragraphRunHandlesMatch(originalParagraph, editedParagraph)) {
+        return editedParagraph.runs.flatMap(
+          (editedRun, runIndex) => {
+            const originalRun = originalParagraph.runs[runIndex];
+            if (originalRun === void 0 || editedRun.text === originalRun.text) return [];
+            if (editedRun.handle === void 0) {
+              throw new Error(
+                "proseMirrorDocJsonToEditorCommands: changed text run has no source handle"
+              );
+            }
+            return [
+              {
+                kind: "replaceTextRunPlainText",
+                handle: editedRun.handle,
+                text: editedRun.text
+              }
+            ];
+          }
+        );
+      }
+      if (editedParagraph.handle === void 0) {
+        throw new Error(
+          "proseMirrorDocJsonToEditorCommands: paragraph structure changed but paragraph has no source handle"
+        );
+      }
+      return [
+        {
+          kind: "replaceParagraphPlainText",
+          handle: editedParagraph.handle,
+          text: paragraphPlainText(editedParagraph)
+        }
+      ];
+    }
+  );
+}
+function validateProseMirrorDocJson(docJson) {
+  const doc = Node.fromJSON(pptxTextBodySchema, docJson);
+  doc.check();
+}
+function paragraphJsonToSourceParagraph(originalParagraph, paragraphJson) {
+  const groups = collectRunGroups(paragraphJson, originalParagraph);
+  return {
+    ...originalParagraph ?? {},
+    runs: groups.map(sourceRunFromGroup),
+    ...originalParagraph?.properties !== void 0 ? { properties: originalParagraph.properties } : {},
+    ...originalParagraph?.handle !== void 0 ? { handle: originalParagraph.handle } : sourceHandleFromUnknown(paragraphJson.attrs?.handle) !== void 0 ? { handle: sourceHandleFromUnknown(paragraphJson.attrs?.handle) } : {}
+  };
+}
+function collectRunGroups(paragraphJson, originalParagraph) {
+  const groups = [];
+  let previousHandle = originalParagraph?.runs[0]?.handle;
+  for (const textNode of paragraphJson.content ?? []) {
+    const mark = textNode.marks?.find((candidate) => candidate.type === "pptxRun");
+    const markedHandle = sourceHandleFromUnknown(mark?.attrs?.handle);
+    const handle = markedHandle ?? previousHandle;
+    const originalRun = handle === void 0 ? void 0 : findOriginalRun(originalParagraph, handle);
+    const properties = originalRun?.properties;
+    const lastGroup = groups.at(-1);
+    if (lastGroup !== void 0 && sourceHandlesEqual(lastGroup.handle, handle)) {
+      groups[groups.length - 1] = {
+        ...lastGroup,
+        text: lastGroup.text + textNode.text
+      };
+    } else {
+      groups.push({
+        ...handle !== void 0 ? { handle } : {},
+        ...properties !== void 0 ? { properties } : {},
+        text: textNode.text
+      });
+    }
+    previousHandle = handle;
+  }
+  return groups;
+}
+function sourceRunFromGroup(group) {
+  return {
+    kind: "textRun",
+    text: group.text,
+    ...group.properties !== void 0 ? { properties: group.properties } : {},
+    ...group.handle !== void 0 ? { handle: group.handle } : {}
+  };
+}
+function findOriginalRun(paragraph, handle) {
+  return paragraph?.runs.find((run) => sourceHandlesEqual(run.handle, handle));
+}
+function paragraphRunHandlesMatch(originalParagraph, editedParagraph) {
+  if (originalParagraph.runs.length !== editedParagraph.runs.length) return false;
+  return originalParagraph.runs.every(
+    (run, index) => sourceHandlesEqual(run.handle, editedParagraph.runs[index]?.handle)
+  );
+}
+function paragraphPlainText(paragraph) {
+  return paragraph.runs.map((run) => run.text).join("");
+}
+function parsePptxTextBodyProseMirrorDocJson(value) {
+  if (!isRecord(value) || value.type !== "doc") {
+    throw new Error("ProseMirror text body doc JSON must be a doc node");
+  }
+  if (value.content !== void 0 && readArray(value.content, isParagraphJson) === void 0) {
+    throw new Error("ProseMirror text body doc JSON content must contain paragraph nodes");
+  }
+  const content = readArray(value.content, isParagraphJson);
+  return {
+    type: "doc",
+    ...content !== void 0 ? { content } : {}
+  };
+}
+function isParagraphJson(value) {
+  if (!isRecord(value) || value.type !== "paragraph") return false;
+  if (value.content !== void 0 && readArray(value.content, isTextJson) === void 0) {
+    return false;
+  }
+  return value.attrs === void 0 || isRecord(value.attrs);
+}
+function isTextJson(value) {
+  if (!isRecord(value) || value.type !== "text" || typeof value.text !== "string") return false;
+  if (value.marks === void 0) return true;
+  return readArray(value.marks, isRunMarkJson) !== void 0;
+}
+function isRunMarkJson(value) {
+  if (!isRecord(value) || value.type !== "pptxRun") return false;
+  return value.attrs === void 0 || isRecord(value.attrs);
+}
+function readArray(value, itemGuard) {
+  if (value === void 0) return void 0;
+  if (!Array.isArray(value)) return void 0;
+  return value.every(itemGuard) ? value : void 0;
+}
+function sourceHandleFromUnknown(value) {
+  if (value === null || value === void 0) return void 0;
+  if (!isRecord(value) || typeof value.partPath !== "string") return void 0;
+  const handle = {
+    partPath: asPartPath(value.partPath),
+    ...typeof value.nodeId === "string" ? { nodeId: asSourceNodeId(value.nodeId) } : {},
+    ...typeof value.relationshipId === "string" ? { relationshipId: asRelationshipId(value.relationshipId) } : {},
+    ...typeof value.orderingSlot === "number" ? { orderingSlot: value.orderingSlot } : {}
+  };
+  return handle;
+}
+function sourceHandlesEqual(left, right) {
+  if (left === void 0 || right === void 0) return left === right;
+  return sourceHandleKey(left) === sourceHandleKey(right);
+}
+function sourceHandleKey(handle) {
+  return [
+    handle.partPath,
+    handle.nodeId ?? "",
+    handle.relationshipId ?? "",
+    handle.orderingSlot ?? ""
+  ].join("\0");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var EditorSession = class {
+  #document;
+  #selection;
+  #undoStack = [];
+  #redoStack = [];
+  constructor(document) {
+    this.#document = document;
+  }
+  get document() {
+    return this.#document;
+  }
+  get selection() {
+    return this.#selection;
+  }
+  get canUndo() {
+    return this.#undoStack.length > 0;
+  }
+  get canRedo() {
+    return this.#redoStack.length > 0;
+  }
+  get undoDepth() {
+    return this.#undoStack.length;
+  }
+  get redoDepth() {
+    return this.#redoStack.length;
+  }
+  selectShape(handle) {
+    if (findShapeNodeBySourceHandle(this.#document, handle) === void 0) {
+      return {
+        ok: false,
+        code: "invalid-selection",
+        message: "selectShape: shape handle was not found in PptxSourceModel source"
+      };
+    }
+    const selection = { shapeHandle: handle };
+    this.#selection = selection;
+    return { ok: true, selection };
+  }
+  deselectShape() {
+    this.#selection = void 0;
+  }
+  apply(command) {
+    return this.applyAll([command]);
+  }
+  applyAll(commands) {
+    const before = this.#document;
+    if (commands.length === 0) return { ok: true, document: before };
+    try {
+      const after = normalizeEditorEdits(
+        commands.reduce((document, command) => applyCommandToDocument(document, command), before)
+      );
+      this.#document = after;
+      this.#undoStack.push({ before, after });
+      this.#redoStack.length = 0;
+      return { ok: true, document: after };
+    } catch (error) {
+      return {
+        ok: false,
+        code: "invalid-command",
+        message: error instanceof Error ? error.message : "Editor command was rejected.",
+        cause: error
+      };
+    }
+  }
+  undo() {
+    const entry = this.#undoStack.pop();
+    if (entry === void 0) return { ok: false, reason: "empty-undo-stack" };
+    this.#document = entry.before;
+    this.#redoStack.push(entry);
+    return { ok: true, document: entry.before };
+  }
+  redo() {
+    const entry = this.#redoStack.pop();
+    if (entry === void 0) return { ok: false, reason: "empty-redo-stack" };
+    this.#document = entry.after;
+    this.#undoStack.push(entry);
+    return { ok: true, document: entry.after };
+  }
+};
+function createEditorSession(document) {
+  return new EditorSession(document);
+}
+function applyCommandToDocument(document, command) {
+  switch (command.kind) {
+    case "replaceTextRunPlainText":
+      return replaceTextRunPlainText(document, command.handle, command.text);
+    case "replaceParagraphPlainText":
+      return replaceParagraphPlainText(document, command.handle, command.text);
+    case "moveShape":
+      return moveShape(document, command);
+    case "resizeShape":
+      return resizeShape(document, command);
+    case "setShapeTransform":
+      return setShapeTransform(document, command);
+  }
+}
+function moveShape(document, command) {
+  requireFiniteEmu(command.offsetX, "moveShape", "offsetX");
+  requireFiniteEmu(command.offsetY, "moveShape", "offsetY");
+  const current = requireEditableShapeTransform(document, command.handle, "moveShape");
+  return updateShapeTransform(document, command.handle, {
+    offsetX: command.offsetX,
+    offsetY: command.offsetY,
+    width: current.width,
+    height: current.height
+  });
+}
+function resizeShape(document, command) {
+  requirePositiveFiniteEmu(command.width, "resizeShape", "width");
+  requirePositiveFiniteEmu(command.height, "resizeShape", "height");
+  const current = requireEditableShapeTransform(document, command.handle, "resizeShape");
+  return updateShapeTransform(document, command.handle, {
+    offsetX: current.offsetX,
+    offsetY: current.offsetY,
+    width: command.width,
+    height: command.height
+  });
+}
+function setShapeTransform(document, command) {
+  requireFiniteEmu(command.offsetX, "setShapeTransform", "offsetX");
+  requireFiniteEmu(command.offsetY, "setShapeTransform", "offsetY");
+  requirePositiveFiniteEmu(command.width, "setShapeTransform", "width");
+  requirePositiveFiniteEmu(command.height, "setShapeTransform", "height");
+  requireEditableShapeTransform(document, command.handle, "setShapeTransform");
+  return updateShapeTransform(document, command.handle, {
+    offsetX: command.offsetX,
+    offsetY: command.offsetY,
+    width: command.width,
+    height: command.height
+  });
+}
+function requireEditableShapeTransform(document, handle, commandName) {
+  const shape = findShapeNodeBySourceHandle(document, handle);
+  if (shape === void 0) {
+    throw new Error(`${commandName}: shape handle was not found in PptxSourceModel source`);
+  }
+  if (!hasTransform(shape)) {
+    throw new Error(`${commandName}: shape handle does not reference a shape with xfrm`);
+  }
+  return shape.transform;
+}
+function requireFiniteEmu(value, commandName, fieldName) {
+  if (!Number.isFinite(value)) {
+    throw new Error(`${commandName}: ${fieldName} must be a finite EMU value`);
+  }
+}
+function requirePositiveFiniteEmu(value, commandName, fieldName) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`${commandName}: ${fieldName} must be a finite positive EMU value`);
+  }
+}
+function hasTransform(shape) {
+  return shape.kind !== "raw" && shape.transform !== void 0;
+}
+function normalizeEditorEdits(document) {
+  const edits = document.edits;
+  if (edits === void 0) return document;
+  const seenTextRuns = /* @__PURE__ */ new Set();
+  const seenParagraphs = /* @__PURE__ */ new Set();
+  const seenShapeTransforms = /* @__PURE__ */ new Set();
+  const normalizedReversed = [];
+  for (let index = edits.length - 1; index >= 0; index -= 1) {
+    const edit = edits[index];
+    if (edit.kind === "replaceTextRunPlainText") {
+      const key = editHandleNodeKey(edit);
+      const paragraphKey = textRunParagraphEditKey(edit);
+      if (paragraphKey !== void 0 && seenParagraphs.has(paragraphKey)) continue;
+      if (seenTextRuns.has(key)) continue;
+      seenTextRuns.add(key);
+    }
+    if (edit.kind === "replaceParagraphPlainText") {
+      const key = editHandleNodeKey(edit);
+      if (seenParagraphs.has(key)) continue;
+      seenParagraphs.add(key);
+    }
+    if (edit.kind === "updateShapeTransform") {
+      const key = editHandleNodeKey(edit);
+      if (seenShapeTransforms.has(key)) continue;
+      seenShapeTransforms.add(key);
+    }
+    normalizedReversed.push(edit);
+  }
+  if (normalizedReversed.length === edits.length) return document;
+  return {
+    ...document,
+    edits: normalizedReversed.reverse()
+  };
+}
+function editHandleNodeKey(edit) {
+  return [
+    edit.handle.partPath,
+    edit.handle.nodeId ?? "",
+    edit.handle.relationshipId ?? "",
+    edit.handle.orderingSlot ?? ""
+  ].join("\0");
+}
+function textRunParagraphEditKey(edit) {
+  const nodeId = String(edit.handle.nodeId ?? "");
+  const byShapeId = /^(text:shape:.+:p:(\d+)):r:\d+$/.exec(nodeId);
+  const byShapeSlot = /^(text:shapeSlot:\d+:p:(\d+)):r:\d+$/.exec(nodeId);
+  const paragraphNodeId = byShapeId?.[1] ?? byShapeSlot?.[1];
+  const paragraphOrderingSlot = byShapeId?.[2] ?? byShapeSlot?.[2] ?? "";
+  if (paragraphNodeId === void 0) return void 0;
+  return [
+    edit.handle.partPath,
+    paragraphNodeId,
+    edit.handle.relationshipId ?? "",
+    paragraphOrderingSlot
+  ].join("\0");
+}
+
+// src/browser-editor.ts
+var EMU_PER_INCH = 914400;
+var DEFAULT_DPI = 96;
+var BrowserPptxEditorSession = class _BrowserPptxEditorSession {
+  #session;
+  #slides = [];
+  #renderOptions;
+  constructor(source, renderOptions) {
+    this.#session = createEditorSession(source);
+    this.#renderOptions = renderOptions;
+  }
+  static async create(input, renderOptions = {}) {
+    const editor = new _BrowserPptxEditorSession(readPptx(input), renderOptions);
+    await editor.renderCurrentSlides();
+    return editor;
+  }
+  get document() {
+    return this.#session.document;
+  }
+  get slides() {
+    return this.#slides;
+  }
+  get history() {
+    return {
+      canUndo: this.#session.canUndo,
+      canRedo: this.#session.canRedo,
+      undoDepth: this.#session.undoDepth,
+      redoDepth: this.#session.redoDepth
+    };
+  }
+  get selection() {
+    return this.#session.selection;
+  }
+  response() {
+    return {
+      slides: this.#slides,
+      history: this.history,
+      ...this.selection !== void 0 ? { selection: this.selection } : {}
+    };
+  }
+  shapes(slideNumber) {
+    const slide = this.#session.document.slides[slideNumber - 1];
+    if (slide === void 0) return [];
+    return slide.shapes.flatMap((shape, index) => shapeInfo(shape, index));
+  }
+  async renderCurrentSlides() {
+    const report = await convertPptxToSvg(writePptx(this.#session.document), {
+      textOutput: "text",
+      skipSystemFonts: true,
+      ...this.#renderOptions
+    });
+    this.#slides = report.slides;
+    return this.#slides;
+  }
+  async apply(command) {
+    const result = this.#session.apply(command);
+    if (!result.ok) {
+      throw new Error(result.message);
+    }
+    await this.renderCurrentSlides();
+    return this.response();
+  }
+  async applyTextBodyDocJson(handle, docJson) {
+    const textBody = this.#requireEditableShapeTextBody(handle);
+    const commands = proseMirrorDocJsonToEditorCommands(textBody, docJson);
+    if (commands.length === 0) return this.response();
+    const result = this.#session.applyAll(commands);
+    if (!result.ok) {
+      throw new Error(result.message);
+    }
+    await this.renderCurrentSlides();
+    return this.response();
+  }
+  selectShape(handle) {
+    const result = this.#session.selectShape(handle);
+    if (!result.ok) {
+      throw new Error(result.message);
+    }
+    return this.response();
+  }
+  async undo() {
+    const result = this.#session.undo();
+    if (!result.ok) {
+      throw new Error(result.reason);
+    }
+    await this.renderCurrentSlides();
+    return this.response();
+  }
+  async redo() {
+    const result = this.#session.redo();
+    if (!result.ok) {
+      throw new Error(result.reason);
+    }
+    await this.renderCurrentSlides();
+    return this.response();
+  }
+  save() {
+    const output = writePptx(this.#session.document);
+    readPptx(output);
+    return { ok: true, pptx: output, history: this.history };
+  }
+  #requireEditableShapeTextBody(handle) {
+    const shape = findShapeNodeBySourceHandle(this.#session.document, handle);
+    if (shape === void 0) {
+      throw new Error("text body edit: shape handle was not found in PptxSourceModel source");
+    }
+    if (shape.kind !== "shape" || shape.textBody === void 0) {
+      throw new Error("text body edit: shape does not have editable text body");
+    }
+    return shape.textBody;
+  }
+};
+function createBrowserPptxEditorSession(input, renderOptions) {
+  return BrowserPptxEditorSession.create(input, renderOptions);
+}
+function shapeInfo(shape, index, editableTransform = true) {
+  const canEditTransform = shape.kind !== "raw" && shape.transform !== void 0 && editableTransform && isEditableTransformShape(shape);
+  const base = {
+    id: String(shape.nodeId ?? shape.handle?.nodeId ?? `${shape.kind}:${String(index)}`),
+    kind: shape.kind,
+    ...shapeName(shape) !== void 0 ? { name: shapeName(shape) } : {},
+    ...shape.handle !== void 0 ? { handle: shape.handle } : {},
+    ...canEditTransform ? {
+      bounds: transformBoundsPx(shape.transform),
+      editableTransform: true
+    } : {},
+    ..."textBody" in shape && shape.textBody !== void 0 ? {
+      textRuns: collectTextRuns(
+        shape.textBody.paragraphs.flatMap((paragraph) => paragraph.runs)
+      )
+    } : {},
+    ...shape.kind === "shape" && canEditTransform && shape.textBody !== void 0 ? editableTextBody(shape.textBody) : {}
+  };
+  if (shape.kind !== "group") return [base];
+  return [
+    base,
+    ...shape.children.flatMap((child, childIndex) => shapeInfo(child, childIndex, false))
+  ];
+}
+function shapeName(shape) {
+  return "name" in shape ? shape.name : void 0;
+}
+function isEditableTransformShape(shape) {
+  if (shape.kind === "raw" || shape.transform === void 0 || shape.handle?.nodeId === void 0) {
+    return false;
+  }
+  return !shape.rawSidecars?.some((sidecar) => sidecar.node.name === "mc:AlternateContent");
+}
+function collectTextRuns(runs) {
+  return runs.flatMap((run) => {
+    if (run.handle === void 0) return [];
+    return [{ text: run.text, handle: run.handle }];
+  });
+}
+function editableTextBody(textBody) {
+  try {
+    return { editableTextBody: { docJson: textBodyToProseMirrorDocJson(textBody) } };
+  } catch {
+    return {};
+  }
+}
+function transformBoundsPx(transform) {
+  return {
+    x: emuToPixels(transform.offsetX),
+    y: emuToPixels(transform.offsetY),
+    width: emuToPixels(transform.width),
+    height: emuToPixels(transform.height)
+  };
+}
+function emuToPixels(value) {
+  return value / EMU_PER_INCH * DEFAULT_DPI;
+}
+
+// src/browser.ts
+async function convertPptxToPng(input, options) {
+  const svgResult = await convertPptxToSvg(input, {
+    ...options,
+    textOutput: "path"
+  });
+  const width = options?.width ?? DEFAULT_OUTPUT_WIDTH;
+  const height = options?.height;
+  const fontBuffers = options?.fonts?.map((font) => toUint8Array(font.data)) ?? [];
+  const slides = [];
+  for (const { slideNumber, svg } of svgResult.slides) {
+    const pngResult = await svgToPng(svg, { width, height, fontBuffers });
+    slides.push({
+      slideNumber,
+      png: new Uint8Array(pngResult.png),
+      width: pngResult.width,
+      height: pngResult.height
+    });
+  }
+  return {
+    slides,
+    diagnostics: svgResult.diagnostics,
+    supportCoverage: svgResult.supportCoverage
+  };
+}
+function initResvgWasm2(wasm) {
+  return initResvgWasm(wasm);
+}
+function toUint8Array(data) {
+  return data instanceof Uint8Array ? data : new Uint8Array(data);
+}
+export {
+  BrowserPptxEditorSession,
+  DEFAULT_FONT_MAPPING,
+  clearFontCache,
+  collectUsedFonts,
+  convertPptxToPng,
+  convertPptxToSvg,
+  createBrowserPptxEditorSession,
+  createFontMapping,
+  createOpentypeSetupFromBuffers,
+  createOpentypeTextMeasurerFromBuffers,
+  getMappedFont,
+  getWarningEntries,
+  getWarningSummary,
+  initResvgWasm2 as initResvgWasm
+};