@rollstack/rscanvas 0.1.0

package/dist/index.js

@@ -0,0 +1,4545 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  RSCanvas: () => RSCanvas,
+  richTextSchema: () => richTextSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/object_node.ts
+var RSObjectNode = class {
+  constructor(container, object, worldX, worldY, worldWidth, worldHeight, type, id, isEditing, rotation = 0) {
+    this._highlighted = false;
+    this._highlightColor = "#00d4aa";
+    this._dirtyHighlight = true;
+    this._object = object;
+    this._x = worldX;
+    this._y = worldY;
+    this._width = worldWidth;
+    this._height = worldHeight;
+    this._type = type;
+    this._id = id;
+    this._isEditing = isEditing;
+    this._containerNode = document.createElement("div");
+    this._containerNode.style.position = "absolute";
+    this._containerNode.style.overflow = "hidden";
+    this._containerNode.style.userSelect = "none";
+    this._containerNode.style.webkitUserSelect = "none";
+    this._containerNode.style.transformOrigin = "50% 50%";
+    this._rotation = rotation;
+    this._dirtyXY = true;
+    this._dirtySize = true;
+    this._dirtyRotation = true;
+    this._dirtyState = true;
+    container.appendChild(this._containerNode);
+  }
+  getType() {
+    return this._type;
+  }
+  getId() {
+    return this._id;
+  }
+  getContainerNode() {
+    return this._containerNode;
+  }
+  getObject() {
+    return this._object;
+  }
+  highlight(color) {
+    if (this._highlighted && this._highlightColor === color) {
+      return;
+    }
+    this._highlighted = true;
+    this._highlightColor = color;
+    this._dirtyHighlight = true;
+  }
+  unhighlight() {
+    if (!this._highlighted) {
+      return;
+    }
+    this._dirtyHighlight = true;
+    this._highlighted = false;
+  }
+  interacts(worldX, worldY) {
+    if (this._rotation === 0) {
+      return worldX >= this._x && worldX <= this._x + this._width && worldY >= this._y && worldY <= this._y + this._height;
+    }
+    const pivotX = this._x + this._width / 2;
+    const pivotY = this._y + this._height / 2;
+    const dx = worldX - pivotX;
+    const dy = worldY - pivotY;
+    const c = Math.cos(-this._rotation);
+    const s = Math.sin(-this._rotation);
+    const localX = dx * c - dy * s;
+    const localY = dx * s + dy * c;
+    const hw = this._width / 2;
+    const hh = this._height / 2;
+    return localX >= -hw && localX <= hw && localY >= -hh && localY <= hh;
+  }
+  getX() {
+    return this._x;
+  }
+  getY() {
+    return this._y;
+  }
+  getWidth() {
+    return this._width;
+  }
+  getHeight() {
+    return this._height;
+  }
+  getRotation() {
+    return this._rotation;
+  }
+  getOptionsSFCT(options) {
+    this._object.getStateSFCT(options);
+  }
+  move(x, y) {
+    if (this._x !== x || this._y !== y) {
+      this._x = x;
+      this._y = y;
+      this._dirtyXY = true;
+    }
+  }
+  translate(dx, dy) {
+    this._x += dx;
+    this._y += dy;
+    this._dirtyXY = true;
+  }
+  resize(width, height) {
+    if (this._width !== width || this._height !== height) {
+      this._width = width;
+      this._height = height;
+      this._dirtySize = true;
+    }
+  }
+  rotate(angle) {
+    if (this._rotation !== angle) {
+      this._rotation = angle;
+      this._dirtyRotation = true;
+    }
+  }
+  render() {
+    if (this._dirtyXY) {
+      this._dirtyXY = false;
+      this._containerNode.style.left = `${this._x}px`;
+      this._containerNode.style.top = `${this._y}px`;
+    }
+    if (this._dirtySize) {
+      this._dirtySize = false;
+      this._containerNode.style.width = `${this._width}px`;
+      this._containerNode.style.height = `${this._height}px`;
+    }
+    if (this._dirtyRotation) {
+      this._dirtyRotation = false;
+      this._containerNode.style.transform = `rotate(${this._rotation}rad)`;
+    }
+    if (this._dirtyState && !this._isEditing(this._id)) {
+      this._dirtyState = false;
+      this._object.renderSFCT(this._containerNode);
+    }
+    if (this._dirtyHighlight) {
+      this._dirtyHighlight = false;
+      const outline = this._highlighted ? `3px solid ${this._highlightColor}` : "none";
+      this._containerNode.style.outline = outline;
+    }
+    const editing = this._isEditing(this._id);
+    const userSelect = editing ? "text" : "none";
+    if (this._containerNode.style.userSelect !== userSelect) {
+      this._containerNode.style.userSelect = userSelect;
+      this._containerNode.style.webkitUserSelect = userSelect;
+    }
+  }
+  updateState(state) {
+    if (!this._object.isStateEqual(state)) {
+      this._object.updateState(state);
+      this._dirtyState = true;
+    }
+  }
+  destroy() {
+    this._object.destroy();
+    this._containerNode.remove();
+  }
+};
+
+// src/objects/text_object.ts
+var RSTextObject = class {
+  constructor(state) {
+    this._state = { text: "" };
+    this._state.text = state.text;
+  }
+  isStateEqual(state) {
+    return this._state.text === state.text;
+  }
+  updateState(state) {
+    this._state.text = state.text;
+  }
+  getStateSFCT(state) {
+    state.text = this._state.text;
+  }
+  renderSFCT(node) {
+    node.textContent = this._state.text;
+  }
+  destroy() {
+  }
+};
+
+// src/objects/image_object.ts
+var RSImageObject = class {
+  constructor(state) {
+    this._imgNode = null;
+    this._state = state;
+  }
+  _getUrl() {
+    if (this._state.type === "url") {
+      return this._state.url ?? "";
+    }
+    try {
+      return localStorage.getItem(this._state.key ?? "") ?? "";
+    } catch {
+      return "";
+    }
+  }
+  isStateEqual(state) {
+    if (this._state.type !== state.type) {
+      return false;
+    }
+    if (this._state.type === "url" && state.type === "url") {
+      return (this._state.url ?? "") === (state.url ?? "");
+    }
+    if (this._state.type === "localStorage" && state.type === "localStorage") {
+      return (this._state.key ?? "") === (state.key ?? "");
+    }
+    return false;
+  }
+  updateState(state) {
+    this._state = state;
+  }
+  getStateSFCT(state) {
+    const out = state;
+    out.type = this._state.type;
+    if (this._state.type === "url") {
+      out.url = this._state.url ?? "";
+      delete out.key;
+    } else {
+      out.key = this._state.key ?? "";
+      delete out.url;
+    }
+  }
+  renderSFCT(node) {
+    const url = this._getUrl();
+    if (!this._imgNode) {
+      this._imgNode = document.createElement("img");
+      this._imgNode.draggable = false;
+      this._imgNode.style.width = "100%";
+      this._imgNode.style.height = "100%";
+      node.replaceChildren(this._imgNode);
+    }
+    this._imgNode.src = url;
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+      this._imgNode.setAttribute("crossorigin", "anonymous");
+    } else {
+      this._imgNode.removeAttribute("crossorigin");
+    }
+  }
+  destroy() {
+    this._imgNode?.remove();
+    this._imgNode = null;
+  }
+};
+
+// 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/prosemirror-model/dist/index.js
+function findDiffStart(a, b, pos) {
+  for (let i = 0; ; i++) {
+    if (i == a.childCount || i == b.childCount)
+      return a.childCount == b.childCount ? null : pos;
+    let childA = a.child(i), childB = b.child(i);
+    if (childA == childB) {
+      pos += childA.nodeSize;
+      continue;
+    }
+    if (!childA.sameMarkup(childB))
+      return pos;
+    if (childA.isText && childA.text != childB.text) {
+      for (let j = 0; childA.text[j] == childB.text[j]; j++)
+        pos++;
+      return pos;
+    }
+    if (childA.content.size || childB.content.size) {
+      let inner = findDiffStart(childA.content, childB.content, pos + 1);
+      if (inner != null)
+        return inner;
+    }
+    pos += childA.nodeSize;
+  }
+}
+function findDiffEnd(a, b, posA, posB) {
+  for (let iA = a.childCount, iB = b.childCount; ; ) {
+    if (iA == 0 || iB == 0)
+      return iA == iB ? null : { a: posA, b: posB };
+    let childA = a.child(--iA), childB = b.child(--iB), size = childA.nodeSize;
+    if (childA == childB) {
+      posA -= size;
+      posB -= size;
+      continue;
+    }
+    if (!childA.sameMarkup(childB))
+      return { a: posA, b: posB };
+    if (childA.isText && childA.text != childB.text) {
+      let same = 0, minSize = Math.min(childA.text.length, childB.text.length);
+      while (same < minSize && childA.text[childA.text.length - same - 1] == childB.text[childB.text.length - same - 1]) {
+        same++;
+        posA--;
+        posB--;
+      }
+      return { a: posA, b: posB };
+    }
+    if (childA.content.size || childB.content.size) {
+      let inner = findDiffEnd(childA.content, childB.content, posA - 1, posB - 1);
+      if (inner)
+        return inner;
+    }
+    posA -= size;
+    posB -= size;
+  }
+}
+var Fragment = class _Fragment {
+  /**
+  @internal
+  */
+  constructor(content, size) {
+    this.content = content;
+    this.size = size || 0;
+    if (size == null)
+      for (let i = 0; i < content.length; i++)
+        this.size += content[i].nodeSize;
+  }
+  /**
+  Invoke a callback for all descendant nodes between the given two
+  positions (relative to start of this fragment). Doesn't descend
+  into a node when the callback returns `false`.
+  */
+  nodesBetween(from, to, f, nodeStart = 0, parent) {
+    for (let i = 0, pos = 0; pos < to; i++) {
+      let child = this.content[i], end = pos + child.nodeSize;
+      if (end > from && f(child, nodeStart + pos, parent || null, i) !== false && child.content.size) {
+        let start = pos + 1;
+        child.nodesBetween(Math.max(0, from - start), Math.min(child.content.size, to - start), f, nodeStart + start);
+      }
+      pos = end;
+    }
+  }
+  /**
+  Call the given callback for every descendant node. `pos` will be
+  relative to the start of the fragment. The callback may return
+  `false` to prevent traversal of a given node's children.
+  */
+  descendants(f) {
+    this.nodesBetween(0, this.size, f);
+  }
+  /**
+  Extract the text between `from` and `to`. See the same method on
+  [`Node`](https://prosemirror.net/docs/ref/#model.Node.textBetween).
+  */
+  textBetween(from, to, blockSeparator, leafText) {
+    let text = "", first = true;
+    this.nodesBetween(from, to, (node, pos) => {
+      let nodeText = node.isText ? node.text.slice(Math.max(from, pos) - pos, to - pos) : !node.isLeaf ? "" : leafText ? typeof leafText === "function" ? leafText(node) : leafText : node.type.spec.leafText ? node.type.spec.leafText(node) : "";
+      if (node.isBlock && (node.isLeaf && nodeText || node.isTextblock) && blockSeparator) {
+        if (first)
+          first = false;
+        else
+          text += blockSeparator;
+      }
+      text += nodeText;
+    }, 0);
+    return text;
+  }
+  /**
+  Create a new fragment containing the combined content of this
+  fragment and the other.
+  */
+  append(other) {
+    if (!other.size)
+      return this;
+    if (!this.size)
+      return other;
+    let last = this.lastChild, first = other.firstChild, content = this.content.slice(), i = 0;
+    if (last.isText && last.sameMarkup(first)) {
+      content[content.length - 1] = last.withText(last.text + first.text);
+      i = 1;
+    }
+    for (; i < other.content.length; i++)
+      content.push(other.content[i]);
+    return new _Fragment(content, this.size + other.size);
+  }
+  /**
+  Cut out the sub-fragment between the two given positions.
+  */
+  cut(from, to = this.size) {
+    if (from == 0 && to == this.size)
+      return this;
+    let result = [], size = 0;
+    if (to > from)
+      for (let i = 0, pos = 0; pos < to; i++) {
+        let child = this.content[i], end = pos + child.nodeSize;
+        if (end > from) {
+          if (pos < from || end > to) {
+            if (child.isText)
+              child = child.cut(Math.max(0, from - pos), Math.min(child.text.length, to - pos));
+            else
+              child = child.cut(Math.max(0, from - pos - 1), Math.min(child.content.size, to - pos - 1));
+          }
+          result.push(child);
+          size += child.nodeSize;
+        }
+        pos = end;
+      }
+    return new _Fragment(result, size);
+  }
+  /**
+  @internal
+  */
+  cutByIndex(from, to) {
+    if (from == to)
+      return _Fragment.empty;
+    if (from == 0 && to == this.content.length)
+      return this;
+    return new _Fragment(this.content.slice(from, to));
+  }
+  /**
+  Create a new fragment in which the node at the given index is
+  replaced by the given node.
+  */
+  replaceChild(index, node) {
+    let current = this.content[index];
+    if (current == node)
+      return this;
+    let copy = this.content.slice();
+    let size = this.size + node.nodeSize - current.nodeSize;
+    copy[index] = node;
+    return new _Fragment(copy, size);
+  }
+  /**
+  Create a new fragment by prepending the given node to this
+  fragment.
+  */
+  addToStart(node) {
+    return new _Fragment([node].concat(this.content), this.size + node.nodeSize);
+  }
+  /**
+  Create a new fragment by appending the given node to this
+  fragment.
+  */
+  addToEnd(node) {
+    return new _Fragment(this.content.concat(node), this.size + node.nodeSize);
+  }
+  /**
+  Compare this fragment to another one.
+  */
+  eq(other) {
+    if (this.content.length != other.content.length)
+      return false;
+    for (let i = 0; i < this.content.length; i++)
+      if (!this.content[i].eq(other.content[i]))
+        return false;
+    return true;
+  }
+  /**
+  The first child of the fragment, or `null` if it is empty.
+  */
+  get firstChild() {
+    return this.content.length ? this.content[0] : null;
+  }
+  /**
+  The last child of the fragment, or `null` if it is empty.
+  */
+  get lastChild() {
+    return this.content.length ? this.content[this.content.length - 1] : null;
+  }
+  /**
+  The number of child nodes in this fragment.
+  */
+  get childCount() {
+    return this.content.length;
+  }
+  /**
+  Get the child node at the given index. Raise an error when the
+  index is out of range.
+  */
+  child(index) {
+    let found2 = this.content[index];
+    if (!found2)
+      throw new RangeError("Index " + index + " out of range for " + this);
+    return found2;
+  }
+  /**
+  Get the child node at the given index, if it exists.
+  */
+  maybeChild(index) {
+    return this.content[index] || null;
+  }
+  /**
+  Call `f` for every child node, passing the node, its offset
+  into this parent node, and its index.
+  */
+  forEach(f) {
+    for (let i = 0, p = 0; i < this.content.length; i++) {
+      let child = this.content[i];
+      f(child, p, i);
+      p += child.nodeSize;
+    }
+  }
+  /**
+  Find the first position at which this fragment and another
+  fragment differ, or `null` if they are the same.
+  */
+  findDiffStart(other, pos = 0) {
+    return findDiffStart(this, other, pos);
+  }
+  /**
+  Find the first position, searching from the end, at which this
+  fragment and the given fragment differ, or `null` if they are
+  the same. Since this position will not be the same in both
+  nodes, an object with two separate positions is returned.
+  */
+  findDiffEnd(other, pos = this.size, otherPos = other.size) {
+    return findDiffEnd(this, other, pos, otherPos);
+  }
+  /**
+  Find the index and inner offset corresponding to a given relative
+  position in this fragment. The result object will be reused
+  (overwritten) the next time the function is called. @internal
+  */
+  findIndex(pos) {
+    if (pos == 0)
+      return retIndex(0, pos);
+    if (pos == this.size)
+      return retIndex(this.content.length, pos);
+    if (pos > this.size || pos < 0)
+      throw new RangeError(`Position ${pos} outside of fragment (${this})`);
+    for (let i = 0, curPos = 0; ; i++) {
+      let cur = this.child(i), end = curPos + cur.nodeSize;
+      if (end >= pos) {
+        if (end == pos)
+          return retIndex(i + 1, end);
+        return retIndex(i, curPos);
+      }
+      curPos = end;
+    }
+  }
+  /**
+  Return a debugging string that describes this fragment.
+  */
+  toString() {
+    return "<" + this.toStringInner() + ">";
+  }
+  /**
+  @internal
+  */
+  toStringInner() {
+    return this.content.join(", ");
+  }
+  /**
+  Create a JSON-serializeable representation of this fragment.
+  */
+  toJSON() {
+    return this.content.length ? this.content.map((n) => n.toJSON()) : null;
+  }
+  /**
+  Deserialize a fragment from its JSON representation.
+  */
+  static fromJSON(schema2, value) {
+    if (!value)
+      return _Fragment.empty;
+    if (!Array.isArray(value))
+      throw new RangeError("Invalid input for Fragment.fromJSON");
+    return new _Fragment(value.map(schema2.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(nodes2) {
+    if (!nodes2)
+      return _Fragment.empty;
+    if (nodes2 instanceof _Fragment)
+      return nodes2;
+    if (Array.isArray(nodes2))
+      return this.fromArray(nodes2);
+    if (nodes2.attrs)
+      return new _Fragment([nodes2], nodes2.nodeSize);
+    throw new RangeError("Can not convert " + nodes2 + " to a Fragment" + (nodes2.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(schema2, json) {
+    if (!json)
+      throw new RangeError("Invalid input for Mark.fromJSON");
+    let type = schema2.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(marks2) {
+    if (!marks2 || Array.isArray(marks2) && marks2.length == 0)
+      return _Mark.none;
+    if (marks2 instanceof _Mark)
+      return [marks2];
+    let copy = marks2.slice();
+    copy.sort((a, b) => a.type.rank - b.type.rank);
+    return copy;
+  }
+};
+Mark.none = [];
+var ReplaceError = class extends Error {
+};
+var Slice = class _Slice {
+  /**
+  Create a slice. When specifying a non-zero open depth, you must
+  make sure that there are nodes of at least that depth at the
+  appropriate side of the fragment—i.e. if the fragment is an
+  empty paragraph node, `openStart` and `openEnd` can't be greater
+  than 1.
+  
+  It is not necessary for the content of open nodes to conform to
+  the schema's content constraints, though it should be a valid
+  start/end/middle for such a node, depending on which sides are
+  open.
+  */
+  constructor(content, openStart, openEnd) {
+    this.content = content;
+    this.openStart = openStart;
+    this.openEnd = openEnd;
+  }
+  /**
+  The size this slice would add when inserted into a document.
+  */
+  get size() {
+    return this.content.size - this.openStart - this.openEnd;
+  }
+  /**
+  @internal
+  */
+  insertAt(pos, fragment) {
+    let content = insertInto(this.content, pos + this.openStart, fragment);
+    return content && new _Slice(content, this.openStart, this.openEnd);
+  }
+  /**
+  @internal
+  */
+  removeBetween(from, to) {
+    return new _Slice(removeRange(this.content, from + this.openStart, to + this.openStart), this.openStart, this.openEnd);
+  }
+  /**
+  Tests whether this slice is equal to another slice.
+  */
+  eq(other) {
+    return this.content.eq(other.content) && this.openStart == other.openStart && this.openEnd == other.openEnd;
+  }
+  /**
+  @internal
+  */
+  toString() {
+    return this.content + "(" + this.openStart + "," + this.openEnd + ")";
+  }
+  /**
+  Convert a slice to a JSON-serializable representation.
+  */
+  toJSON() {
+    if (!this.content.size)
+      return null;
+    let json = { content: this.content.toJSON() };
+    if (this.openStart > 0)
+      json.openStart = this.openStart;
+    if (this.openEnd > 0)
+      json.openEnd = this.openEnd;
+    return json;
+  }
+  /**
+  Deserialize a slice from its JSON representation.
+  */
+  static fromJSON(schema2, 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(schema2, json.content), openStart, openEnd);
+  }
+  /**
+  Create a slice from a fragment by taking the maximum possible
+  open value on both side of the fragment.
+  */
+  static maxOpen(fragment, openIsolating = true) {
+    let openStart = 0, openEnd = 0;
+    for (let n = fragment.firstChild; n && !n.isLeaf && (openIsolating || !n.type.spec.isolating); n = n.firstChild)
+      openStart++;
+    for (let n = fragment.lastChild; n && !n.isLeaf && (openIsolating || !n.type.spec.isolating); n = n.lastChild)
+      openEnd++;
+    return new _Slice(fragment, openStart, openEnd);
+  }
+};
+Slice.empty = new Slice(Fragment.empty, 0, 0);
+function removeRange(content, from, to) {
+  let { index, offset } = content.findIndex(from), child = content.maybeChild(index);
+  let { index: indexTo, offset: offsetTo } = content.findIndex(to);
+  if (offset == from || child.isText) {
+    if (offsetTo != to && !content.child(indexTo).isText)
+      throw new RangeError("Removing non-flat range");
+    return content.cut(0, from).append(content.cut(to));
+  }
+  if (index != indexTo)
+    throw new RangeError("Removing non-flat range");
+  return content.replaceChild(index, child.copy(removeRange(child.content, from - offset - 1, to - offset - 1)));
+}
+function insertInto(content, dist, insert, parent) {
+  let { index, offset } = content.findIndex(dist), child = content.maybeChild(index);
+  if (offset == dist || child.isText) {
+    if (parent && !parent.canReplace(index, index, insert))
+      return null;
+    return content.cut(0, dist).append(insert).append(content.cut(dist));
+  }
+  let inner = insertInto(child.content, dist - offset - 1, insert, child);
+  return inner && content.replaceChild(index, child.copy(inner));
+}
+function replace($from, $to, slice) {
+  if (slice.openStart > $from.depth)
+    throw new ReplaceError("Inserted content deeper than insertion position");
+  if ($from.depth - slice.openStart != $to.depth - slice.openEnd)
+    throw new ReplaceError("Inconsistent open depths");
+  return replaceOuter($from, $to, slice, 0);
+}
+function replaceOuter($from, $to, slice, depth) {
+  let index = $from.index(depth), node = $from.node(depth);
+  if (index == $to.index(depth) && depth < $from.depth - slice.openStart) {
+    let inner = replaceOuter($from, $to, slice, depth + 1);
+    return node.copy(node.content.replaceChild(index, inner));
+  } else if (!slice.content.size) {
+    return close(node, replaceTwoWay($from, $to, depth));
+  } else if (!slice.openStart && !slice.openEnd && $from.depth == depth && $to.depth == depth) {
+    let parent = $from.parent, content = parent.content;
+    return close(parent, content.cut(0, $from.parentOffset).append(slice.content).append(content.cut($to.parentOffset)));
+  } else {
+    let { start, end } = prepareSliceForReplace(slice, $from);
+    return close(node, replaceThreeWay($from, start, end, $to, depth));
+  }
+}
+function checkJoin(main, sub) {
+  if (!sub.type.compatibleContent(main.type))
+    throw new ReplaceError("Cannot join " + sub.type.name + " onto " + main.type.name);
+}
+function joinable($before, $after, depth) {
+  let node = $before.node(depth);
+  checkJoin(node, $after.node(depth));
+  return node;
+}
+function addNode(child, target) {
+  let last = target.length - 1;
+  if (last >= 0 && child.isText && child.sameMarkup(target[last]))
+    target[last] = child.withText(target[last].text + child.text);
+  else
+    target.push(child);
+}
+function addRange($start, $end, depth, target) {
+  let node = ($end || $start).node(depth);
+  let startIndex = 0, endIndex = $end ? $end.index(depth) : node.childCount;
+  if ($start) {
+    startIndex = $start.index(depth);
+    if ($start.depth > depth) {
+      startIndex++;
+    } else if ($start.textOffset) {
+      addNode($start.nodeAfter, target);
+      startIndex++;
+    }
+  }
+  for (let i = startIndex; i < endIndex; i++)
+    addNode(node.child(i), target);
+  if ($end && $end.depth == depth && $end.textOffset)
+    addNode($end.nodeBefore, target);
+}
+function close(node, content) {
+  node.type.checkContent(content);
+  return node.copy(content);
+}
+function replaceThreeWay($from, $start, $end, $to, depth) {
+  let openStart = $from.depth > depth && joinable($from, $start, depth + 1);
+  let openEnd = $to.depth > depth && joinable($end, $to, depth + 1);
+  let content = [];
+  addRange(null, $from, depth, content);
+  if (openStart && openEnd && $start.index(depth) == $end.index(depth)) {
+    checkJoin(openStart, openEnd);
+    addNode(close(openStart, replaceThreeWay($from, $start, $end, $to, depth + 1)), content);
+  } else {
+    if (openStart)
+      addNode(close(openStart, replaceTwoWay($from, $start, depth + 1)), content);
+    addRange($start, $end, depth, content);
+    if (openEnd)
+      addNode(close(openEnd, replaceTwoWay($end, $to, depth + 1)), content);
+  }
+  addRange($to, null, depth, content);
+  return new Fragment(content);
+}
+function replaceTwoWay($from, $to, depth) {
+  let content = [];
+  addRange(null, $from, depth, content);
+  if ($from.depth > depth) {
+    let type = joinable($from, $to, depth + 1);
+    addNode(close(type, replaceTwoWay($from, $to, depth + 1)), content);
+  }
+  addRange($to, null, depth, content);
+  return new Fragment(content);
+}
+function prepareSliceForReplace(slice, $along) {
+  let extra = $along.depth - slice.openStart, parent = $along.node(extra);
+  let node = parent.copy(slice.content);
+  for (let i = extra - 1; i >= 0; i--)
+    node = $along.node(i).copy(Fragment.from(node));
+  return {
+    start: node.resolveNoCache(slice.openStart + extra),
+    end: node.resolveNoCache(node.content.size - slice.openEnd - extra)
+  };
+}
+var ResolvedPos = class _ResolvedPos {
+  /**
+  @internal
+  */
+  constructor(pos, path, parentOffset) {
+    this.pos = pos;
+    this.path = path;
+    this.parentOffset = parentOffset;
+    this.depth = path.length / 3 - 1;
+  }
+  /**
+  @internal
+  */
+  resolveDepth(val) {
+    if (val == null)
+      return this.depth;
+    if (val < 0)
+      return this.depth + val;
+    return val;
+  }
+  /**
+  The parent node that the position points into. Note that even if
+  a position points into a text node, that node is not considered
+  the parent—text nodes are ‘flat’ in this model, and have no content.
+  */
+  get parent() {
+    return this.node(this.depth);
+  }
+  /**
+  The root node in which the position was resolved.
+  */
+  get doc() {
+    return this.node(0);
+  }
+  /**
+  The ancestor node at the given level. `p.node(p.depth)` is the
+  same as `p.parent`.
+  */
+  node(depth) {
+    return this.path[this.resolveDepth(depth) * 3];
+  }
+  /**
+  The index into the ancestor at the given level. If this points
+  at the 3rd node in the 2nd paragraph on the top level, for
+  example, `p.index(0)` is 1 and `p.index(1)` is 2.
+  */
+  index(depth) {
+    return this.path[this.resolveDepth(depth) * 3 + 1];
+  }
+  /**
+  The index pointing after this position into the ancestor at the
+  given level.
+  */
+  indexAfter(depth) {
+    depth = this.resolveDepth(depth);
+    return this.index(depth) + (depth == this.depth && !this.textOffset ? 0 : 1);
+  }
+  /**
+  The (absolute) position at the start of the node at the given
+  level.
+  */
+  start(depth) {
+    depth = this.resolveDepth(depth);
+    return depth == 0 ? 0 : this.path[depth * 3 - 1] + 1;
+  }
+  /**
+  The (absolute) position at the end of the node at the given
+  level.
+  */
+  end(depth) {
+    depth = this.resolveDepth(depth);
+    return this.start(depth) + this.node(depth).content.size;
+  }
+  /**
+  The (absolute) position directly before the wrapping node at the
+  given level, or, when `depth` is `this.depth + 1`, the original
+  position.
+  */
+  before(depth) {
+    depth = this.resolveDepth(depth);
+    if (!depth)
+      throw new RangeError("There is no position before the top-level node");
+    return depth == this.depth + 1 ? this.pos : this.path[depth * 3 - 1];
+  }
+  /**
+  The (absolute) position directly after the wrapping node at the
+  given level, or the original position when `depth` is `this.depth + 1`.
+  */
+  after(depth) {
+    depth = this.resolveDepth(depth);
+    if (!depth)
+      throw new RangeError("There is no position after the top-level node");
+    return depth == this.depth + 1 ? this.pos : this.path[depth * 3 - 1] + this.path[depth * 3].nodeSize;
+  }
+  /**
+  When this position points into a text node, this returns the
+  distance between the position and the start of the text node.
+  Will be zero for positions that point between nodes.
+  */
+  get textOffset() {
+    return this.pos - this.path[this.path.length - 1];
+  }
+  /**
+  Get the node directly after the position, if any. If the position
+  points into a text node, only the part of that node after the
+  position is returned.
+  */
+  get nodeAfter() {
+    let parent = this.parent, index = this.index(this.depth);
+    if (index == parent.childCount)
+      return null;
+    let dOff = this.pos - this.path[this.path.length - 1], child = parent.child(index);
+    return dOff ? parent.child(index).cut(dOff) : child;
+  }
+  /**
+  Get the node directly before the position, if any. If the
+  position points into a text node, only the part of that node
+  before the position is returned.
+  */
+  get nodeBefore() {
+    let index = this.index(this.depth);
+    let dOff = this.pos - this.path[this.path.length - 1];
+    if (dOff)
+      return this.parent.child(index).cut(0, dOff);
+    return index == 0 ? null : this.parent.child(index - 1);
+  }
+  /**
+  Get the position at the given index in the parent node at the
+  given depth (which defaults to `this.depth`).
+  */
+  posAtIndex(index, depth) {
+    depth = this.resolveDepth(depth);
+    let node = this.path[depth * 3], pos = depth == 0 ? 0 : this.path[depth * 3 - 1] + 1;
+    for (let i = 0; i < index; i++)
+      pos += node.child(i).nodeSize;
+    return pos;
+  }
+  /**
+  Get the marks at this position, factoring in the surrounding
+  marks' [`inclusive`](https://prosemirror.net/docs/ref/#model.MarkSpec.inclusive) property. If the
+  position is at the start of a non-empty node, the marks of the
+  node after it (if any) are returned.
+  */
+  marks() {
+    let parent = this.parent, index = this.index();
+    if (parent.content.size == 0)
+      return Mark.none;
+    if (this.textOffset)
+      return parent.child(index).marks;
+    let main = parent.maybeChild(index - 1), other = parent.maybeChild(index);
+    if (!main) {
+      let tmp = main;
+      main = other;
+      other = tmp;
+    }
+    let marks2 = main.marks;
+    for (var i = 0; i < marks2.length; i++)
+      if (marks2[i].type.spec.inclusive === false && (!other || !marks2[i].isInSet(other.marks)))
+        marks2 = marks2[i--].removeFromSet(marks2);
+    return marks2;
+  }
+  /**
+  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 marks2 = after.marks, next = $end.parent.maybeChild($end.index());
+    for (var i = 0; i < marks2.length; i++)
+      if (marks2[i].type.spec.inclusive === false && (!next || !marks2[i].isInSet(next.marks)))
+        marks2 = marks2[i--].removeFromSet(marks2);
+    return marks2;
+  }
+  /**
+  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(doc2, pos) {
+    if (!(pos >= 0 && pos <= doc2.content.size))
+      throw new RangeError("Position " + pos + " out of range");
+    let path = [];
+    let start = 0, parentOffset = pos;
+    for (let node = doc2; ; ) {
+      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(doc2, pos) {
+    let cache = resolveCache.get(doc2);
+    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(doc2, cache = new ResolveCache());
+    }
+    let result = cache.elts[cache.i] = _ResolvedPos.resolve(doc2, 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, marks2 = Mark.none) {
+    this.type = type;
+    this.attrs = attrs;
+    this.marks = marks2;
+    this.content = content || Fragment.empty;
+  }
+  /**
+  The array of this node's child nodes.
+  */
+  get children() {
+    return this.content.content;
+  }
+  /**
+  The size of this node, as defined by the integer-based [indexing
+  scheme](https://prosemirror.net/docs/guide/#doc.indexing). For text nodes, this is the
+  amount of characters. For other leaf nodes, it is one. For
+  non-leaf nodes, it is the size of the content plus two (the
+  start and end token).
+  */
+  get nodeSize() {
+    return this.isLeaf ? 1 : 2 + this.content.size;
+  }
+  /**
+  The number of children that the node has.
+  */
+  get childCount() {
+    return this.content.childCount;
+  }
+  /**
+  Get the child node at the given index. Raises an error when the
+  index is out of range.
+  */
+  child(index) {
+    return this.content.child(index);
+  }
+  /**
+  Get the child node at the given index, if it exists.
+  */
+  maybeChild(index) {
+    return this.content.maybeChild(index);
+  }
+  /**
+  Call `f` for every child node, passing the node, its offset
+  into this parent node, and its index.
+  */
+  forEach(f) {
+    this.content.forEach(f);
+  }
+  /**
+  Invoke a callback for all descendant nodes recursively between
+  the given two positions that are relative to start of this
+  node's content. The callback is invoked with the node, its
+  position relative to the original node (method receiver),
+  its parent node, and its child index. When the callback returns
+  false for a given node, that node's children will not be
+  recursed over. The last parameter can be used to specify a
+  starting position to count from.
+  */
+  nodesBetween(from, to, f, startPos = 0) {
+    this.content.nodesBetween(from, to, f, startPos, this);
+  }
+  /**
+  Call the given callback for every descendant node. Doesn't
+  descend into a node when the callback returns `false`.
+  */
+  descendants(f) {
+    this.nodesBetween(0, this.content.size, f);
+  }
+  /**
+  Concatenates all the text nodes found in this fragment and its
+  children.
+  */
+  get textContent() {
+    return this.isLeaf && this.type.spec.leafText ? this.type.spec.leafText(this) : this.textBetween(0, this.content.size, "");
+  }
+  /**
+  Get all text between positions `from` and `to`. When
+  `blockSeparator` is given, it will be inserted to separate text
+  from different block nodes. If `leafText` is given, it'll be
+  inserted for every non-text leaf node encountered, otherwise
+  [`leafText`](https://prosemirror.net/docs/ref/#model.NodeSpec.leafText) will be used.
+  */
+  textBetween(from, to, blockSeparator, leafText) {
+    return this.content.textBetween(from, to, blockSeparator, leafText);
+  }
+  /**
+  Returns this node's first child, or `null` if there are no
+  children.
+  */
+  get firstChild() {
+    return this.content.firstChild;
+  }
+  /**
+  Returns this node's last child, or `null` if there are no
+  children.
+  */
+  get lastChild() {
+    return this.content.lastChild;
+  }
+  /**
+  Test whether two nodes represent the same piece of document.
+  */
+  eq(other) {
+    return this == other || this.sameMarkup(other) && this.content.eq(other.content);
+  }
+  /**
+  Compare the markup (type, attributes, and marks) of this node to
+  those of another. Returns `true` if both have the same markup.
+  */
+  sameMarkup(other) {
+    return this.hasMarkup(other.type, other.attrs, other.marks);
+  }
+  /**
+  Check whether this node's markup correspond to the given type,
+  attributes, and marks.
+  */
+  hasMarkup(type, attrs, marks2) {
+    return this.type == type && compareDeep(this.attrs, attrs || type.defaultAttrs || emptyAttrs) && Mark.sameSet(this.marks, marks2 || 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(marks2) {
+    return marks2 == this.marks ? this : new _Node(this.type, this.attrs, this.content, marks2);
+  }
+  /**
+  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, marks2) {
+    if (marks2 && !this.type.allowsMarks(marks2))
+      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(schema2, json) {
+    if (!json)
+      throw new RangeError("Invalid input for Node.fromJSON");
+    let marks2 = void 0;
+    if (json.marks) {
+      if (!Array.isArray(json.marks))
+        throw new RangeError("Invalid mark data for Node.fromJSON");
+      marks2 = json.marks.map(schema2.markFromJSON);
+    }
+    if (json.type == "text") {
+      if (typeof json.text != "string")
+        throw new RangeError("Invalid text node in JSON");
+      return schema2.text(json.text, marks2);
+    }
+    let content = Fragment.fromJSON(schema2, json.content);
+    let node = schema2.nodeType(json.type).create(json.attrs, content, marks2);
+    node.type.checkAttrs(node.attrs);
+    return node;
+  }
+};
+Node.prototype.text = void 0;
+var TextNode = class _TextNode extends Node {
+  /**
+  @internal
+  */
+  constructor(type, attrs, content, marks2) {
+    super(type, attrs, null, marks2);
+    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(marks2) {
+    return marks2 == this.marks ? this : new _TextNode(this.type, this.attrs, this.text, marks2);
+  }
+  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(marks2, str) {
+  for (let i = marks2.length - 1; i >= 0; i--)
+    str = marks2[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, nodes2 = [];
+    for (let j = 0; j < state.next.length; j++) {
+      let { type, next } = state.next[j];
+      nodes2.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 (" + nodes2.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 name2 in values)
+    if (!(name2 in attrs))
+      throw new RangeError(`Unsupported attribute ${name2} for ${type} of type ${name2}`);
+  for (let name2 in attrs) {
+    let attr = attrs[name2];
+    if (attr.validate)
+      attr.validate(values[name2]);
+  }
+}
+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, schema2, spec) {
+    this.name = name;
+    this.schema = schema2;
+    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, marks2) {
+    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(marks2));
+  }
+  /**
+  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, marks2) {
+    content = Fragment.from(content);
+    this.checkContent(content);
+    return new Node(this, this.computeAttrs(attrs), content, Mark.setFrom(marks2));
+  }
+  /**
+  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, marks2) {
+    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(marks2));
+  }
+  /**
+  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(marks2) {
+    if (this.markSet == null)
+      return true;
+    for (let i = 0; i < marks2.length; i++)
+      if (!this.allowsMarkType(marks2[i].type))
+        return false;
+    return true;
+  }
+  /**
+  Removes the marks that are not allowed in this node from the given set.
+  */
+  allowedMarks(marks2) {
+    if (this.markSet == null)
+      return marks2;
+    let copy;
+    for (let i = 0; i < marks2.length; i++) {
+      if (!this.allowsMarkType(marks2[i].type)) {
+        if (!copy)
+          copy = marks2.slice(0, i);
+      } else if (copy) {
+        copy.push(marks2[i]);
+      }
+    }
+    return !copy ? marks2 : copy.length ? copy : Mark.none;
+  }
+  /**
+  @internal
+  */
+  static compile(nodes2, schema2) {
+    let result = /* @__PURE__ */ Object.create(null);
+    nodes2.forEach((name, spec) => result[name] = new _NodeType(name, schema2, spec));
+    let topType = schema2.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, schema2, spec) {
+    this.name = name;
+    this.rank = rank;
+    this.schema = schema2;
+    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(marks2, schema2) {
+    let result = /* @__PURE__ */ Object.create(null), rank = 0;
+    marks2.forEach((name, spec) => result[name] = new _MarkType(name, rank++, schema2, 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, marks2) {
+    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, marks2);
+  }
+  /**
+  Create a text node in the schema. Empty text nodes are not
+  allowed.
+  */
+  text(text, marks2) {
+    let type = this.nodes.text;
+    return new TextNode(type, type.defaultAttrs, text, Mark.setFrom(marks2));
+  }
+  /**
+  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(schema2, marks2) {
+  let found2 = [];
+  for (let i = 0; i < marks2.length; i++) {
+    let name = marks2[i], mark = schema2.marks[name], ok = mark;
+    if (mark) {
+      found2.push(mark);
+    } else {
+      for (let prop in schema2.marks) {
+        let mark2 = schema2.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: '" + marks2[i] + "'");
+  }
+  return found2;
+}
+var DOMSerializer = class _DOMSerializer {
+  /**
+  Create a serializer. `nodes` should map node names to functions
+  that take a node and return a description of the corresponding
+  DOM. `marks` does the same for mark names, but also gets an
+  argument that tells it whether the mark's content is block or
+  inline content (for typical use, it'll always be inline). A mark
+  serializer may be `null` to indicate that marks of that type
+  should not be serialized.
+  */
+  constructor(nodes2, marks2) {
+    this.nodes = nodes2;
+    this.marks = marks2;
+  }
+  /**
+  Serialize the content of this fragment to a DOM fragment. When
+  not in the browser, the `document` option, containing a DOM
+  document, should be passed so that the serializer can create
+  nodes.
+  */
+  serializeFragment(fragment, options = {}, target) {
+    if (!target)
+      target = doc(options).createDocumentFragment();
+    let top = target, active = [];
+    fragment.forEach((node) => {
+      if (active.length || node.marks.length) {
+        let keep = 0, rendered = 0;
+        while (keep < active.length && rendered < node.marks.length) {
+          let next = node.marks[rendered];
+          if (!this.marks[next.type.name]) {
+            rendered++;
+            continue;
+          }
+          if (!next.eq(active[keep][0]) || next.type.spec.spanning === false)
+            break;
+          keep++;
+          rendered++;
+        }
+        while (keep < active.length)
+          top = active.pop()[1];
+        while (rendered < node.marks.length) {
+          let add2 = node.marks[rendered++];
+          let markDOM = this.serializeMark(add2, node.isInline, options);
+          if (markDOM) {
+            active.push([add2, top]);
+            top.appendChild(markDOM.dom);
+            top = markDOM.contentDOM || markDOM.dom;
+          }
+        }
+      }
+      top.appendChild(this.serializeNodeInner(node, options));
+    });
+    return target;
+  }
+  /**
+  @internal
+  */
+  serializeNodeInner(node, options) {
+    let { dom, contentDOM } = renderSpec(doc(options), this.nodes[node.type.name](node), null, node.attrs);
+    if (contentDOM) {
+      if (node.isLeaf)
+        throw new RangeError("Content hole not allowed in a leaf node spec");
+      this.serializeFragment(node.content, options, contentDOM);
+    }
+    return dom;
+  }
+  /**
+  Serialize this node to a DOM node. This can be useful when you
+  need to serialize a part of a document, as opposed to the whole
+  document. To serialize a whole document, use
+  [`serializeFragment`](https://prosemirror.net/docs/ref/#model.DOMSerializer.serializeFragment) on
+  its [content](https://prosemirror.net/docs/ref/#model.Node.content).
+  */
+  serializeNode(node, options = {}) {
+    let dom = this.serializeNodeInner(node, options);
+    for (let i = node.marks.length - 1; i >= 0; i--) {
+      let wrap = this.serializeMark(node.marks[i], node.isInline, options);
+      if (wrap) {
+        (wrap.contentDOM || wrap.dom).appendChild(dom);
+        dom = wrap.dom;
+      }
+    }
+    return dom;
+  }
+  /**
+  @internal
+  */
+  serializeMark(mark, inline, options = {}) {
+    let toDOM = this.marks[mark.type.name];
+    return toDOM && renderSpec(doc(options), toDOM(mark, inline), null, mark.attrs);
+  }
+  static renderSpec(doc2, structure, xmlNS = null, blockArraysIn) {
+    return renderSpec(doc2, structure, xmlNS, blockArraysIn);
+  }
+  /**
+  Build a serializer using the [`toDOM`](https://prosemirror.net/docs/ref/#model.NodeSpec.toDOM)
+  properties in a schema's node and mark specs.
+  */
+  static fromSchema(schema2) {
+    return schema2.cached.domSerializer || (schema2.cached.domSerializer = new _DOMSerializer(this.nodesFromSchema(schema2), this.marksFromSchema(schema2)));
+  }
+  /**
+  Gather the serializers in a schema's node specs into an object.
+  This can be useful as a base to build a custom serializer from.
+  */
+  static nodesFromSchema(schema2) {
+    let result = gatherToDOM(schema2.nodes);
+    if (!result.text)
+      result.text = (node) => node.text;
+    return result;
+  }
+  /**
+  Gather the serializers in a schema's mark specs into an object.
+  */
+  static marksFromSchema(schema2) {
+    return gatherToDOM(schema2.marks);
+  }
+};
+function gatherToDOM(obj) {
+  let result = {};
+  for (let name in obj) {
+    let toDOM = obj[name].spec.toDOM;
+    if (toDOM)
+      result[name] = toDOM;
+  }
+  return result;
+}
+function doc(options) {
+  return options.document || window.document;
+}
+var suspiciousAttributeCache = /* @__PURE__ */ new WeakMap();
+function suspiciousAttributes(attrs) {
+  let value = suspiciousAttributeCache.get(attrs);
+  if (value === void 0)
+    suspiciousAttributeCache.set(attrs, value = suspiciousAttributesInner(attrs));
+  return value;
+}
+function suspiciousAttributesInner(attrs) {
+  let result = null;
+  function scan(value) {
+    if (value && typeof value == "object") {
+      if (Array.isArray(value)) {
+        if (typeof value[0] == "string") {
+          if (!result)
+            result = [];
+          result.push(value);
+        } else {
+          for (let i = 0; i < value.length; i++)
+            scan(value[i]);
+        }
+      } else {
+        for (let prop in value)
+          scan(value[prop]);
+      }
+    }
+  }
+  scan(attrs);
+  return result;
+}
+function renderSpec(doc2, structure, xmlNS, blockArraysIn) {
+  if (typeof structure == "string")
+    return { dom: doc2.createTextNode(structure) };
+  if (structure.nodeType != null)
+    return { dom: structure };
+  if (structure.dom && structure.dom.nodeType != null)
+    return structure;
+  let tagName = structure[0], suspicious;
+  if (typeof tagName != "string")
+    throw new RangeError("Invalid array passed to renderSpec");
+  if (blockArraysIn && (suspicious = suspiciousAttributes(blockArraysIn)) && suspicious.indexOf(structure) > -1)
+    throw new RangeError("Using an array from an attribute object as a DOM spec. This may be an attempted cross site scripting attack.");
+  let space = tagName.indexOf(" ");
+  if (space > 0) {
+    xmlNS = tagName.slice(0, space);
+    tagName = tagName.slice(space + 1);
+  }
+  let contentDOM;
+  let dom = xmlNS ? doc2.createElementNS(xmlNS, tagName) : doc2.createElement(tagName);
+  let attrs = structure[1], start = 1;
+  if (attrs && typeof attrs == "object" && attrs.nodeType == null && !Array.isArray(attrs)) {
+    start = 2;
+    for (let name in attrs)
+      if (attrs[name] != null) {
+        let space2 = name.indexOf(" ");
+        if (space2 > 0)
+          dom.setAttributeNS(name.slice(0, space2), name.slice(space2 + 1), attrs[name]);
+        else if (name == "style" && dom.style)
+          dom.style.cssText = attrs[name];
+        else
+          dom.setAttribute(name, attrs[name]);
+      }
+  }
+  for (let i = start; i < structure.length; i++) {
+    let child = structure[i];
+    if (child === 0) {
+      if (i < structure.length - 1 || i > start)
+        throw new RangeError("Content hole must be the only child of its parent node");
+      return { dom, contentDOM: dom };
+    } else {
+      let { dom: inner, contentDOM: innerContent } = renderSpec(doc2, child, xmlNS, blockArraysIn);
+      dom.appendChild(inner);
+      if (innerContent) {
+        if (contentDOM)
+          throw new RangeError("Multiple content holes");
+        contentDOM = innerContent;
+      }
+    }
+  }
+  return { dom, contentDOM };
+}
+
+// node_modules/prosemirror-schema-basic/dist/index.js
+var pDOM = ["p", 0];
+var blockquoteDOM = ["blockquote", 0];
+var hrDOM = ["hr"];
+var preDOM = ["pre", ["code", 0]];
+var brDOM = ["br"];
+var nodes = {
+  /**
+  NodeSpec The top level document node.
+  */
+  doc: {
+    content: "block+"
+  },
+  /**
+  A plain paragraph textblock. Represented in the DOM
+  as a `<p>` element.
+  */
+  paragraph: {
+    content: "inline*",
+    group: "block",
+    parseDOM: [{ tag: "p" }],
+    toDOM() {
+      return pDOM;
+    }
+  },
+  /**
+  A blockquote (`<blockquote>`) wrapping one or more blocks.
+  */
+  blockquote: {
+    content: "block+",
+    group: "block",
+    defining: true,
+    parseDOM: [{ tag: "blockquote" }],
+    toDOM() {
+      return blockquoteDOM;
+    }
+  },
+  /**
+  A horizontal rule (`<hr>`).
+  */
+  horizontal_rule: {
+    group: "block",
+    parseDOM: [{ tag: "hr" }],
+    toDOM() {
+      return hrDOM;
+    }
+  },
+  /**
+  A heading textblock, with a `level` attribute that
+  should hold the number 1 to 6. Parsed and serialized as `<h1>` to
+  `<h6>` elements.
+  */
+  heading: {
+    attrs: { level: { default: 1, validate: "number" } },
+    content: "inline*",
+    group: "block",
+    defining: true,
+    parseDOM: [
+      { tag: "h1", attrs: { level: 1 } },
+      { tag: "h2", attrs: { level: 2 } },
+      { tag: "h3", attrs: { level: 3 } },
+      { tag: "h4", attrs: { level: 4 } },
+      { tag: "h5", attrs: { level: 5 } },
+      { tag: "h6", attrs: { level: 6 } }
+    ],
+    toDOM(node) {
+      return ["h" + node.attrs.level, 0];
+    }
+  },
+  /**
+  A code listing. Disallows marks or non-text inline
+  nodes by default. Represented as a `<pre>` element with a
+  `<code>` element inside of it.
+  */
+  code_block: {
+    content: "text*",
+    marks: "",
+    group: "block",
+    code: true,
+    defining: true,
+    parseDOM: [{ tag: "pre", preserveWhitespace: "full" }],
+    toDOM() {
+      return preDOM;
+    }
+  },
+  /**
+  The text node.
+  */
+  text: {
+    group: "inline"
+  },
+  /**
+  An inline image (`<img>`) node. Supports `src`,
+  `alt`, and `href` attributes. The latter two default to the empty
+  string.
+  */
+  image: {
+    inline: true,
+    attrs: {
+      src: { validate: "string" },
+      alt: { default: null, validate: "string|null" },
+      title: { default: null, validate: "string|null" }
+    },
+    group: "inline",
+    draggable: true,
+    parseDOM: [{ tag: "img[src]", getAttrs(dom) {
+      return {
+        src: dom.getAttribute("src"),
+        title: dom.getAttribute("title"),
+        alt: dom.getAttribute("alt")
+      };
+    } }],
+    toDOM(node) {
+      let { src, alt, title } = node.attrs;
+      return ["img", { src, alt, title }];
+    }
+  },
+  /**
+  A hard line break, represented in the DOM as `<br>`.
+  */
+  hard_break: {
+    inline: true,
+    group: "inline",
+    selectable: false,
+    parseDOM: [{ tag: "br" }],
+    toDOM() {
+      return brDOM;
+    }
+  }
+};
+var emDOM = ["em", 0];
+var strongDOM = ["strong", 0];
+var codeDOM = ["code", 0];
+var marks = {
+  /**
+  A link. Has `href` and `title` attributes. `title`
+  defaults to the empty string. Rendered and parsed as an `<a>`
+  element.
+  */
+  link: {
+    attrs: {
+      href: { validate: "string" },
+      title: { default: null, validate: "string|null" }
+    },
+    inclusive: false,
+    parseDOM: [{ tag: "a[href]", getAttrs(dom) {
+      return { href: dom.getAttribute("href"), title: dom.getAttribute("title") };
+    } }],
+    toDOM(node) {
+      let { href, title } = node.attrs;
+      return ["a", { href, title }, 0];
+    }
+  },
+  /**
+  An emphasis mark. Rendered as an `<em>` element. Has parse rules
+  that also match `<i>` and `font-style: italic`.
+  */
+  em: {
+    parseDOM: [
+      { tag: "i" },
+      { tag: "em" },
+      { style: "font-style=italic" },
+      { style: "font-style=normal", clearMark: (m) => m.type.name == "em" }
+    ],
+    toDOM() {
+      return emDOM;
+    }
+  },
+  /**
+  A strong mark. Rendered as `<strong>`, parse rules also match
+  `<b>` and `font-weight: bold`.
+  */
+  strong: {
+    parseDOM: [
+      { tag: "strong" },
+      // This works around a Google Docs misbehavior where
+      // pasted content will be inexplicably wrapped in `<b>`
+      // tags with a font-weight normal.
+      { tag: "b", getAttrs: (node) => node.style.fontWeight != "normal" && null },
+      { style: "font-weight=400", clearMark: (m) => m.type.name == "strong" },
+      { style: "font-weight", getAttrs: (value) => /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null }
+    ],
+    toDOM() {
+      return strongDOM;
+    }
+  },
+  /**
+  Code font mark. Represented as a `<code>` element.
+  */
+  code: {
+    code: true,
+    parseDOM: [{ tag: "code" }],
+    toDOM() {
+      return codeDOM;
+    }
+  }
+};
+var schema = new Schema({ nodes, marks });
+
+// node_modules/prosemirror-schema-list/dist/index.js
+var olDOM = ["ol", 0];
+var ulDOM = ["ul", 0];
+var liDOM = ["li", 0];
+var orderedList = {
+  attrs: { order: { default: 1, validate: "number" } },
+  parseDOM: [{ tag: "ol", getAttrs(dom) {
+    return { order: dom.hasAttribute("start") ? +dom.getAttribute("start") : 1 };
+  } }],
+  toDOM(node) {
+    return node.attrs.order == 1 ? olDOM : ["ol", { start: node.attrs.order }, 0];
+  }
+};
+var bulletList = {
+  parseDOM: [{ tag: "ul" }],
+  toDOM() {
+    return ulDOM;
+  }
+};
+var listItem = {
+  parseDOM: [{ tag: "li" }],
+  toDOM() {
+    return liDOM;
+  },
+  defining: true
+};
+function add(obj, props) {
+  let copy = {};
+  for (let prop in obj)
+    copy[prop] = obj[prop];
+  for (let prop in props)
+    copy[prop] = props[prop];
+  return copy;
+}
+function addListNodes(nodes2, itemContent, listGroup) {
+  return nodes2.append({
+    ordered_list: add(orderedList, { content: "list_item+", group: listGroup }),
+    bullet_list: add(bulletList, { content: "list_item+", group: listGroup }),
+    list_item: add(listItem, { content: itemContent })
+  });
+}
+
+// src/objects/rich_text_object.ts
+function deepEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") {
+    return false;
+  }
+  if (Array.isArray(a) !== Array.isArray(b)) {
+    return false;
+  }
+  const objA = a;
+  const objB = b;
+  let countA = 0;
+  for (const key in objA) {
+    if (!Object.prototype.hasOwnProperty.call(objA, key)) {
+      continue;
+    }
+    countA++;
+    if (!Object.prototype.hasOwnProperty.call(objB, key)) {
+      return false;
+    }
+    if (!deepEqual(objA[key], objB[key])) {
+      return false;
+    }
+  }
+  let countB = 0;
+  for (const key in objB) {
+    if (Object.prototype.hasOwnProperty.call(objB, key)) {
+      countB++;
+    }
+  }
+  return countA === countB;
+}
+var richTextSchema = new Schema({
+  nodes: addListNodes(schema.spec.nodes, "paragraph block*", "block"),
+  marks: schema.spec.marks.addToEnd("strike", {
+    parseDOM: [{ tag: "s" }, { tag: "strike" }, { style: "text-decoration=line-through" }],
+    toDOM() {
+      return ["s", 0];
+    }
+  })
+});
+var _RSRichTextObject = class _RSRichTextObject {
+  constructor(state) {
+    this._innerNode = null;
+    this._state = {
+      doc: JSON.parse(JSON.stringify(state.doc))
+    };
+  }
+  isStateEqual(state) {
+    return deepEqual(this._state.doc, state.doc);
+  }
+  updateState(state) {
+    this._state = {
+      doc: JSON.parse(JSON.stringify(state.doc))
+    };
+  }
+  getStateSFCT(state) {
+    state.doc = this._state.doc;
+  }
+  renderSFCT(node) {
+    const doc2 = Node.fromJSON(richTextSchema, this._state.doc);
+    const fragment = _RSRichTextObject._DOM_SERIALIZER.serializeFragment(doc2.content);
+    if (!this._innerNode) {
+      this._innerNode = document.createElement("div");
+      this._innerNode.className = "rs-rich-text";
+      this._innerNode.style.cssText = "height:100%;width:100%;overflow:auto;box-sizing:border-box";
+      node.replaceChildren(this._innerNode);
+    }
+    this._innerNode.replaceChildren(fragment);
+  }
+  destroy() {
+    this._innerNode?.remove();
+    this._innerNode = null;
+  }
+};
+_RSRichTextObject._DOM_SERIALIZER = (() => {
+  const nodes2 = { ...DOMSerializer.nodesFromSchema(richTextSchema) };
+  const baseParagraph = nodes2.paragraph;
+  nodes2.paragraph = (node) => {
+    if (node.content.size === 0) {
+      return ["p", ["br"]];
+    }
+    return baseParagraph(node);
+  };
+  return new DOMSerializer(nodes2, DOMSerializer.marksFromSchema(richTextSchema));
+})();
+var RSRichTextObject = _RSRichTextObject;
+
+// src/controls/resize_control.ts
+var ResizeControl = class {
+  constructor(canvas) {
+    this._objectId = null;
+    this._lastViewX = 0;
+    this._lastViewY = 0;
+    this._canvas = canvas;
+  }
+  handleEvent(event) {
+    if (event.type === "mousedown") {
+      const objectId = this._canvas.objectIdAtLowerRightCorner(event.viewX ?? 0, event.viewY ?? 0);
+      if (!objectId) {
+        return null;
+      }
+      this._objectId = objectId;
+      this._lastViewX = event.viewX ?? 0;
+      this._lastViewY = event.viewY ?? 0;
+      this._canvas.changeCursor("se-resize");
+      return this;
+    }
+    if (event.type === "mouseup" || event.type === "mouseleave") {
+      this._objectId = null;
+      this._canvas.changeCursor("default");
+      return null;
+    }
+    if (event.type === "mousemove" && this._objectId) {
+      const viewX = event.viewX ?? 0;
+      const viewY = event.viewY ?? 0;
+      const scale = this._canvas.getScale();
+      const dw = (viewX - this._lastViewX) / scale;
+      const dh = (viewY - this._lastViewY) / scale;
+      this._lastViewX = viewX;
+      this._lastViewY = viewY;
+      this._canvas.resizeObject(this._objectId, dw, dh);
+      this._canvas.changeCursor("se-resize");
+      return this;
+    }
+    if (event.type === "mousemove") {
+      const overHandle = this._canvas.objectIdAtLowerRightCorner(event.viewX ?? 0, event.viewY ?? 0);
+      if (overHandle) {
+        this._canvas.changeCursor("se-resize");
+      }
+    }
+    return null;
+  }
+  render(_node) {
+  }
+  destroy() {
+  }
+};
+
+// src/controls/rotation_control.ts
+var ROTATION_HANDLE_SIZE = 14;
+var RotationControl = class {
+  constructor(canvas) {
+    this._cornerPosScratch = { worldX: 0, worldY: 0 };
+    this._objectId = null;
+    this._hoveredObjectId = null;
+    this._lastAngle = 0;
+    this._lastWorldX = 0;
+    this._lastWorldY = 0;
+    this._lineEl = null;
+    this._handlePath = null;
+    this._canvas = canvas;
+  }
+  handleEvent(event) {
+    if (event.type === "mousedown") {
+      const objectId = this._canvas.objectIdAtUpperRightCorner(event.viewX ?? 0, event.viewY ?? 0);
+      if (!objectId) {
+        return null;
+      }
+      this._objectId = objectId;
+      this._canvas.highlightObject(objectId);
+      const node = this._canvas.getObjectNode(objectId);
+      if (!node) {
+        return null;
+      }
+      const pivotX = node.getX() + node.getWidth() / 2;
+      const pivotY = node.getY() + node.getHeight() / 2;
+      const worldX = this._canvas.toWorldX(event.viewX ?? 0);
+      const worldY = this._canvas.toWorldY(event.viewY ?? 0);
+      this._lastAngle = Math.atan2(worldY - pivotY, worldX - pivotX);
+      this._lastWorldX = worldX;
+      this._lastWorldY = worldY;
+      this._canvas.changeCursor("grabbing");
+      return this;
+    }
+    if (event.type === "mouseup" || event.type === "mouseleave") {
+      this._objectId = null;
+      this._hoveredObjectId = null;
+      this._canvas.changeCursor("default");
+      return null;
+    }
+    if (event.type === "mousemove" && this._objectId) {
+      const node = this._canvas.getObjectNode(this._objectId);
+      if (!node) {
+        return this;
+      }
+      const pivotX = node.getX() + node.getWidth() / 2;
+      const pivotY = node.getY() + node.getHeight() / 2;
+      const worldX = this._canvas.toWorldX(event.viewX ?? 0);
+      const worldY = this._canvas.toWorldY(event.viewY ?? 0);
+      const currentAngle = Math.atan2(worldY - pivotY, worldX - pivotX);
+      let dAngle = currentAngle - this._lastAngle;
+      if (dAngle > Math.PI) {
+        dAngle -= 2 * Math.PI;
+      }
+      if (dAngle < -Math.PI) {
+        dAngle += 2 * Math.PI;
+      }
+      this._lastAngle = currentAngle;
+      this._lastWorldX = worldX;
+      this._lastWorldY = worldY;
+      this._canvas.rotateObject(this._objectId, dAngle);
+      this._canvas.changeCursor("grabbing");
+      return this;
+    }
+    if (event.type === "mousemove") {
+      const overHandle = this._canvas.objectIdAtUpperRightCorner(event.viewX ?? 0, event.viewY ?? 0);
+      if (overHandle !== this._hoveredObjectId) {
+        this._hoveredObjectId = overHandle;
+      }
+      if (overHandle) {
+        this._canvas.changeCursor("grab");
+      }
+    }
+    return null;
+  }
+  render(node) {
+    const objectId = this._objectId ?? this._hoveredObjectId;
+    const isActive = this._objectId !== null;
+    const fill = isActive ? "#4a90d9" : "#888";
+    if (!objectId) {
+      if (this._lineEl?.parentElement) {
+        this._lineEl.parentElement.remove();
+        this._lineEl = null;
+      }
+      if (this._handlePath?.parentElement) {
+        this._handlePath.parentElement.remove();
+        this._handlePath = null;
+      }
+      return;
+    }
+    this._canvas.getCornerWorldXYSFCT(objectId, "top-right", this._cornerPosScratch);
+    const { worldX: x, worldY: y } = this._cornerPosScratch;
+    const half = ROTATION_HANDLE_SIZE / 2;
+    if (isActive) {
+      if (!this._lineEl) {
+        const lineSvg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+        lineSvg.setAttribute("width", "100%");
+        lineSvg.setAttribute("height", "100%");
+        lineSvg.setAttribute("viewBox", `0 0 ${this._canvas.getCanvasWidth()} ${this._canvas.getCanvasHeight()}`);
+        lineSvg.style.position = "absolute";
+        lineSvg.style.top = "0";
+        lineSvg.style.left = "0";
+        lineSvg.style.pointerEvents = "none";
+        this._lineEl = document.createElementNS("http://www.w3.org/2000/svg", "line");
+        this._lineEl.setAttribute("stroke", "#4a90d9");
+        this._lineEl.setAttribute("stroke-width", "1.5");
+        this._lineEl.setAttribute("stroke-linecap", "round");
+        lineSvg.appendChild(this._lineEl);
+      }
+      this._lineEl.setAttribute("x1", String(x));
+      this._lineEl.setAttribute("y1", String(y));
+      this._lineEl.setAttribute("x2", String(this._lastWorldX));
+      this._lineEl.setAttribute("y2", String(this._lastWorldY));
+      node.appendChild(this._lineEl.parentElement);
+    } else {
+      if (this._lineEl?.parentElement) {
+        this._lineEl.parentElement.remove();
+        this._lineEl = null;
+      }
+    }
+    if (!this._handlePath) {
+      const handleSvg2 = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+      handleSvg2.setAttribute("width", String(ROTATION_HANDLE_SIZE));
+      handleSvg2.setAttribute("height", String(ROTATION_HANDLE_SIZE));
+      handleSvg2.setAttribute("viewBox", "0 0 24 24");
+      handleSvg2.style.position = "absolute";
+      handleSvg2.style.pointerEvents = "none";
+      this._handlePath = document.createElementNS("http://www.w3.org/2000/svg", "path");
+      this._handlePath.setAttribute("d", "M12 2v4l3-3-3-3v2c-4.4 0-8 3.6-8 8s3.6 8 8 8 8-3.6 8-8h2c0 5.5-4.5 10-10 10S2 17.5 2 12 6.5 2 12 2z");
+      this._handlePath.setAttribute("stroke", "#fff");
+      this._handlePath.setAttribute("stroke-width", "1.5");
+      handleSvg2.appendChild(this._handlePath);
+    }
+    const handleSvg = this._handlePath.parentElement;
+    handleSvg.style.left = `${x - half}px`;
+    handleSvg.style.top = `${y - half}px`;
+    this._handlePath.setAttribute("fill", fill);
+    node.appendChild(handleSvg);
+  }
+  destroy() {
+    this._objectId = null;
+    this._hoveredObjectId = null;
+    if (this._lineEl?.parentElement) {
+      this._lineEl.parentElement.remove();
+    }
+    this._lineEl = null;
+    if (this._handlePath?.parentElement) {
+      this._handlePath.parentElement.remove();
+    }
+    this._handlePath = null;
+  }
+};
+
+// src/controls/zoom_control.ts
+var ZoomControl = class {
+  constructor(canvas) {
+    this._modifierHeld = false;
+    this._canvas = canvas;
+  }
+  handleEvent(event) {
+    if (event.type === "keydown" && (event.key === "Meta" || event.key === "Control")) {
+      this._modifierHeld = true;
+      this._canvas.changeCursor("zoom-in");
+      return this;
+    }
+    if (event.type === "keyup" && (event.key === "Meta" || event.key === "Control")) {
+      this._modifierHeld = false;
+      this._canvas.changeCursor("default");
+      return null;
+    }
+    if (this._modifierHeld && event.type === "scroll") {
+      event.preventDefault?.();
+      const scaleFactor = (event.deltaY ?? 0) > 0 ? 0.95 : 1.05;
+      this._canvas.scaleAtXY(scaleFactor, event.viewX ?? 0, event.viewY ?? 0);
+      return this;
+    }
+    return null;
+  }
+  render(_node) {
+  }
+  destroy() {
+  }
+};
+
+// src/controls/pan_control.ts
+var PanControl = class {
+  constructor(canvas) {
+    this._active = false;
+    this._lastViewX = 0;
+    this._lastViewY = 0;
+    this._canvas = canvas;
+  }
+  handleEvent(event) {
+    if (event.type === "mousedown") {
+      const objectId = this._canvas.objectIdAtXY(event.viewX ?? 0, event.viewY ?? 0);
+      if (objectId) {
+        return null;
+      }
+      this._active = true;
+      this._lastViewX = event.viewX ?? 0;
+      this._lastViewY = event.viewY ?? 0;
+      this._canvas.changeCursor("grabbing");
+      return this;
+    }
+    if (event.type === "mouseup" || event.type === "mouseleave") {
+      this._active = false;
+      this._canvas.changeCursor("default");
+      return null;
+    }
+    if (event.type === "mousemove" && this._active) {
+      const viewX = event.viewX ?? 0;
+      const viewY = event.viewY ?? 0;
+      const dx = viewX - this._lastViewX;
+      const dy = viewY - this._lastViewY;
+      this._lastViewX = viewX;
+      this._lastViewY = viewY;
+      this._canvas.translate(dx, dy);
+      this._canvas.changeCursor("grabbing");
+      return this;
+    }
+    if (event.type === "mousemove") {
+      const objectId = this._canvas.objectIdAtXY(event.viewX ?? 0, event.viewY ?? 0);
+      if (!objectId) {
+        this._canvas.changeCursor("grab");
+      }
+    }
+    return null;
+  }
+  render(_node) {
+  }
+  destroy() {
+  }
+};
+
+// src/controls/drag_control.ts
+var DragControl = class {
+  constructor(canvas) {
+    this._objectId = null;
+    this._lastViewX = 0;
+    this._lastViewY = 0;
+    this._canvas = canvas;
+  }
+  handleEvent(event) {
+    if (event.type === "mousedown") {
+      const objectId = this._canvas.objectIdAtXY(event.viewX ?? 0, event.viewY ?? 0);
+      if (!objectId) {
+        return null;
+      }
+      this._objectId = objectId;
+      this._lastViewX = event.viewX ?? 0;
+      this._lastViewY = event.viewY ?? 0;
+      this._canvas.changeCursor("grabbing");
+      return this;
+    }
+    if (event.type === "mouseup" || event.type === "mouseleave") {
+      this._objectId = null;
+      this._canvas.changeCursor("default");
+      return null;
+    }
+    if (event.type === "mousemove" && this._objectId) {
+      const viewX = event.viewX ?? 0;
+      const viewY = event.viewY ?? 0;
+      const scale = this._canvas.getScale();
+      const dx = (viewX - this._lastViewX) / scale;
+      const dy = (viewY - this._lastViewY) / scale;
+      this._lastViewX = viewX;
+      this._lastViewY = viewY;
+      this._canvas.translateObject(this._objectId, dx, dy);
+      this._canvas.changeCursor("grabbing");
+      return this;
+    }
+    if (event.type === "mousemove") {
+      if (this._canvas.objectIdAtLowerRightCorner(event.viewX ?? 0, event.viewY ?? 0) || this._canvas.objectIdAtUpperRightCorner(event.viewX ?? 0, event.viewY ?? 0)) {
+        return null;
+      }
+      const objectId = this._canvas.objectIdAtXY(event.viewX ?? 0, event.viewY ?? 0);
+      if (objectId) {
+        this._canvas.changeCursor("grab");
+      }
+    }
+    return null;
+  }
+  render(_node) {
+  }
+  destroy() {
+  }
+};
+
+// src/controls/highlight_control.ts
+var HighlightControl = class {
+  constructor(canvas) {
+    this._canvas = canvas;
+  }
+  handleEvent(event) {
+    if (event.type === "mousemove") {
+      const id = this._canvas.objectIdAtXY(event.viewX ?? 0, event.viewY ?? 0);
+      if (id) {
+        this._canvas.highlightObject(id);
+        if (!this._canvas.objectIdAtLowerRightCorner(event.viewX ?? 0, event.viewY ?? 0) && !this._canvas.objectIdAtUpperRightCorner(event.viewX ?? 0, event.viewY ?? 0)) {
+          this._canvas.changeCursor("pointer");
+        }
+      } else {
+        this._canvas.clearHighlight();
+      }
+      return null;
+    }
+    if (event.type === "mouseleave") {
+      this._canvas.clearHighlight();
+      return null;
+    }
+    return null;
+  }
+  render(_node) {
+  }
+  destroy() {
+  }
+};
+
+// src/controls/edit_control.ts
+var DEFAULT_HIGHLIGHT_COLOR = "#00d4aa";
+var EditControl = class {
+  constructor(canvas) {
+    this._lockedObjectId = null;
+    this._editingObjectId = null;
+    this._canvas = canvas;
+  }
+  handleEvent(event) {
+    if (this._editingObjectId) {
+      return this;
+    }
+    if (event.type === "mouseleave") {
+      if (this._lockedObjectId) {
+        this._canvas.clearHighlight();
+        this._canvas.setHighlightColor(DEFAULT_HIGHLIGHT_COLOR);
+        this._canvas.changeCursor("default");
+        this._lockedObjectId = null;
+      }
+      return null;
+    }
+    if (event.type === "dblclick") {
+      if (this._lockedObjectId) {
+        this._canvas.clearHighlight();
+        this._canvas.setHighlightColor(DEFAULT_HIGHLIGHT_COLOR);
+        this._canvas.changeCursor("default");
+        this._lockedObjectId = null;
+        return null;
+      }
+      const objectId = this._canvas.objectIdAtXY(event.viewX ?? 0, event.viewY ?? 0);
+      if (objectId && this._canvas.canEditObject(objectId)) {
+        this._canvas.setHighlightColor("#4a90d9");
+        this._lockedObjectId = objectId;
+        this._canvas.highlightObject(objectId);
+        this._canvas.changeCursor("text");
+        return this;
+      }
+    }
+    if ((event.type === "click" || event.type === "keydown" && event.key === "Enter") && this._lockedObjectId) {
+      const objectId = this._lockedObjectId;
+      this._canvas.setHighlightColor("#4a90d9");
+      this._canvas.highlightObject(objectId);
+      const handle = {
+        onEnd: () => {
+          this._editingObjectId = null;
+          this._canvas.setHighlightColor(DEFAULT_HIGHLIGHT_COLOR);
+        }
+      };
+      const started = this._canvas.startEditSession(objectId, handle);
+      if (started) {
+        this._editingObjectId = objectId;
+        this._lockedObjectId = null;
+        return this;
+      }
+      this._canvas.clearHighlight();
+      this._canvas.setHighlightColor(DEFAULT_HIGHLIGHT_COLOR);
+      this._canvas.changeCursor("default");
+      this._lockedObjectId = null;
+    }
+    if (this._lockedObjectId) {
+      this._canvas.changeCursor("text");
+      return this;
+    }
+    return null;
+  }
+  render(_node) {
+  }
+  destroy() {
+  }
+};
+
+// src/controls/delete_control.ts
+var DeleteControl = class {
+  constructor(canvas) {
+    this._canvas = canvas;
+  }
+  handleEvent(event) {
+    if (event.type === "keydown" && event.key === "Backspace") {
+      const id = this._canvas.getHighlightedObjectId();
+      if (id) {
+        this._canvas.deleteObject(id);
+        event.preventDefault?.();
+      }
+      return null;
+    }
+    return null;
+  }
+  render(_node) {
+  }
+  destroy() {
+  }
+};
+
+// src/controls/keyboard_move_control.ts
+var ARROW_KEY_STEP = 8;
+var KeyboardMoveControl = class {
+  constructor(canvas) {
+    this._canvas = canvas;
+  }
+  handleEvent(event) {
+    if (event.type !== "keydown") {
+      return null;
+    }
+    const id = this._canvas.getHighlightedObjectId();
+    if (!id) {
+      return null;
+    }
+    let dx = 0;
+    let dy = 0;
+    if (event.key === "ArrowLeft") {
+      dx = -ARROW_KEY_STEP;
+    } else if (event.key === "ArrowRight") {
+      dx = ARROW_KEY_STEP;
+    } else if (event.key === "ArrowUp") {
+      dy = -ARROW_KEY_STEP;
+    } else if (event.key === "ArrowDown") {
+      dy = ARROW_KEY_STEP;
+    } else {
+      return null;
+    }
+    this._canvas.translateObject(id, dx, dy);
+    event.preventDefault?.();
+    return null;
+  }
+  render(_node) {
+  }
+  destroy() {
+  }
+};
+
+// src/editors/text_object_editor.ts
+var RSTextObjectEditor = class {
+  constructor(_canvas, state, container, handle) {
+    this._editContainer = null;
+    this._destroyed = false;
+    this._state = state;
+    const editable = container;
+    this._editContainer = editable;
+    editable.contentEditable = "true";
+    editable.focus({ preventScroll: true });
+    const sel = window.getSelection();
+    if (sel) {
+      sel.selectAllChildren(editable);
+      sel.collapseToEnd();
+    }
+    const finish = (commit) => {
+      editable.contentEditable = "false";
+      if (commit) {
+        const text = editable.textContent ?? "";
+        this._state = { text };
+        handle.onCommit(this._state);
+      } else {
+        editable.textContent = state.text;
+      }
+      handle.onEnd();
+      this._editContainer = null;
+    };
+    const keyHandler = (e) => {
+      if (e.key === "Enter") {
+        e.preventDefault();
+        editable.blur();
+      } else if (e.key === "Escape") {
+        e.preventDefault();
+        finish(false);
+      }
+    };
+    editable.addEventListener("blur", () => finish(true), { once: true });
+    editable.addEventListener("keydown", keyHandler);
+  }
+  destroy() {
+    if (this._destroyed) {
+      return;
+    }
+    this._destroyed = true;
+    if (this._editContainer) {
+      this._editContainer.blur();
+    }
+  }
+};
+
+// src/canvas.ts
+var import_html2canvas = __toESM(require("html2canvas"));
+var RESIZE_HANDLE_SIZE = 12;
+var ROTATION_HANDLE_SIZE2 = 14;
+var RSCanvas = class {
+  constructor(container, options) {
+    this._scale = 1;
+    this._translateX = 0;
+    this._translateY = 0;
+    this._objects = {};
+    this._objectConstructors = /* @__PURE__ */ new Map();
+    this._objectEditorConstructors = /* @__PURE__ */ new Map();
+    this._editingObjectId = null;
+    this._highlightedObjectId = null;
+    this._highlightColor = "#00d4aa";
+    this._activeControl = null;
+    this._rafId = null;
+    this._listeners = /* @__PURE__ */ new Map();
+    this._destroyed = false;
+    this._dirtyTransform = true;
+    this._pendingState = null;
+    this._internalStateVersion = 0;
+    this._pendingStateVersion = -1;
+    this._cornerPosScratch = { worldX: 0, worldY: 0 };
+    this._boundingClientRect = { left: 0, top: 0 };
+    this._controls = [];
+    this._onMouseDown = (e) => {
+      if (this._destroyed || this._editingObjectId) {
+        return;
+      }
+      const event = this._createPointerEvent("mousedown", e);
+      this._dispatchToControls(event);
+      if (this._activeControl && !this._editingObjectId) {
+        this._containerNode.focus();
+        e.preventDefault();
+        e.stopPropagation();
+      }
+    };
+    this._onMouseUp = (e) => {
+      if (this._destroyed || this._editingObjectId) {
+        return;
+      }
+      const hadActive = !!this._activeControl;
+      const event = this._createPointerEvent("mouseup", e);
+      this._dispatchToControls(event);
+      if (hadActive || this._activeControl) {
+        e.preventDefault();
+        e.stopPropagation();
+      }
+    };
+    this._onMouseEnter = (e) => {
+      if (this._destroyed || this._editingObjectId) {
+        return;
+      }
+      const event = this._createPointerEvent("mouseenter", e);
+      this._emit("mouseenter", event);
+    };
+    this._onMouseLeave = (e) => {
+      if (this._destroyed || this._editingObjectId) {
+        return;
+      }
+      const hadActive = !!this._activeControl;
+      const event = this._createPointerEvent("mouseleave", e);
+      this._dispatchToControls(event);
+      if (hadActive || this._activeControl) {
+        e.preventDefault();
+        e.stopPropagation();
+      }
+    };
+    this._onMouseMove = (e) => {
+      if (this._destroyed || this._editingObjectId) {
+        return;
+      }
+      const hadActive = !!this._activeControl;
+      const event = this._createPointerEvent("mousemove", e);
+      this._dispatchToControls(event);
+      if (hadActive || this._activeControl) {
+        e.preventDefault();
+        e.stopPropagation();
+      }
+    };
+    this._onClick = (e) => {
+      if (this._destroyed || this._editingObjectId) {
+        return;
+      }
+      const event = this._createPointerEvent("click", e);
+      this._dispatchToControls(event);
+      this._emit("click", event);
+    };
+    this._onDblClick = (e) => {
+      if (this._destroyed || this._editingObjectId) {
+        return;
+      }
+      const event = this._createPointerEvent("dblclick", e);
+      this._dispatchToControls(event);
+    };
+    this._onScroll = (e) => {
+      if (this._destroyed || this._editingObjectId) {
+        return;
+      }
+      const event = this._createPointerEvent("scroll", e);
+      this._dispatchToControls(event);
+    };
+    this._onKeyDown = (e) => {
+      if (this._destroyed || this._editingObjectId) {
+        return;
+      }
+      const event = {
+        type: "keydown",
+        viewX: 0,
+        viewY: 0,
+        deltaY: null,
+        preventDefault: () => e.preventDefault(),
+        key: e.key
+      };
+      this._dispatchToControls(event);
+    };
+    this._onKeyUp = (e) => {
+      if (this._destroyed || this._editingObjectId) {
+        return;
+      }
+      const event = {
+        type: "keyup",
+        viewX: 0,
+        viewY: 0,
+        deltaY: null,
+        preventDefault: () => e.preventDefault(),
+        key: e.key
+      };
+      this._dispatchToControls(event);
+    };
+    this._localInvalidate = () => this._invalidate();
+    this._onPaint = () => this._paint();
+    this._containerNode = container;
+    this._width = options?.width ?? 1200;
+    this._height = options?.height ?? 800;
+    this._containerNode.style.overflow = "hidden";
+    this._containerNode.tabIndex = 0;
+    this._containerNode.style.userSelect = "none";
+    this._containerNode.style.webkitUserSelect = "none";
+    this._containerNode.style.background = "#e0e0e0";
+    this._innerContainerNode = document.createElement("div");
+    this._innerContainerNode.style.position = "relative";
+    this._innerContainerNode.style.userSelect = "none";
+    this._innerContainerNode.style.webkitUserSelect = "none";
+    this._innerContainerNode.style.width = `${this._width}px`;
+    this._innerContainerNode.style.height = `${this._height}px`;
+    this._innerContainerNode.style.transformOrigin = "0 0";
+    this._innerContainerNode.style.background = "#ffffff";
+    this._containerNode.appendChild(this._innerContainerNode);
+    this._overlayNode = document.createElement("div");
+    this._overlayNode.style.position = "absolute";
+    this._overlayNode.style.top = "0";
+    this._overlayNode.style.left = "0";
+    this._overlayNode.style.width = "100%";
+    this._overlayNode.style.height = "100%";
+    this._overlayNode.style.pointerEvents = "none";
+    this._overlayNode.style.zIndex = "10";
+    this._innerContainerNode.appendChild(this._overlayNode);
+    this._updateBoundingClientRect();
+    this._resizeObserver = new ResizeObserver(() => {
+      this._updateBoundingClientRect();
+      this._invalidate();
+    });
+    this._resizeObserver.observe(this._containerNode);
+    this.center();
+    this._setupEventListeners();
+    this._controls.push(
+      new ResizeControl(this),
+      new RotationControl(this),
+      new DragControl(this),
+      new PanControl(this),
+      new ZoomControl(this),
+      new EditControl(this),
+      new HighlightControl(this),
+      new KeyboardMoveControl(this),
+      new DeleteControl(this)
+    );
+    this.registerObjectType(
+      "text",
+      (state) => new RSTextObject(state)
+    );
+    this.registerObjectType(
+      "image",
+      (state) => new RSImageObject(state)
+    );
+    this.registerObjectType(
+      "rich-text",
+      (state) => new RSRichTextObject(state)
+    );
+    this.registerObjectTypeEditor(
+      "text",
+      RSTextObjectEditor
+    );
+  }
+  _setupEventListeners() {
+    this._containerNode.addEventListener("mousedown", this._onMouseDown);
+    this._containerNode.addEventListener("mouseup", this._onMouseUp);
+    this._containerNode.addEventListener("mouseenter", this._onMouseEnter);
+    this._containerNode.addEventListener("mouseleave", this._onMouseLeave);
+    this._containerNode.addEventListener("mousemove", this._onMouseMove);
+    this._containerNode.addEventListener("click", this._onClick);
+    this._containerNode.addEventListener("dblclick", this._onDblClick);
+    this._containerNode.addEventListener("wheel", this._onScroll, {
+      passive: false
+    });
+    this._containerNode.addEventListener("keydown", this._onKeyDown);
+    this._containerNode.addEventListener("keyup", this._onKeyUp);
+  }
+  _updateBoundingClientRect() {
+    const rect = this._containerNode.getBoundingClientRect();
+    this._boundingClientRect.left = rect.left;
+    this._boundingClientRect.top = rect.top;
+  }
+  _viewXFromEvent(e) {
+    return e.clientX - this._boundingClientRect.left;
+  }
+  _viewYFromEvent(e) {
+    return e.clientY - this._boundingClientRect.top;
+  }
+  _emit(type, event) {
+    const listeners = this._listeners.get(type);
+    if (listeners) {
+      const fullEvent = { type, ...event };
+      for (const fn of listeners) {
+        fn(fullEvent);
+      }
+    }
+  }
+  _paint() {
+    this._rafId = null;
+    if (this._pendingState) {
+      if (this._pendingStateVersion >= this._internalStateVersion) {
+        this._updateObjectTree(this._pendingState);
+      }
+      this._pendingState = null;
+    }
+    if (this._dirtyTransform) {
+      this._dirtyTransform = false;
+      this._innerContainerNode.style.transform = `translate(${this._translateX}px, ${this._translateY}px) scale(${this._scale})`;
+    }
+    for (const id in this._objects) {
+      this._objects[id].render();
+    }
+    for (const ctrl of this._controls) {
+      ctrl.render(this._overlayNode);
+    }
+  }
+  _invalidate() {
+    if (this._rafId != null) {
+      return;
+    }
+    this._rafId = requestAnimationFrame(this._onPaint);
+  }
+  _cornerWorldPosSFCT(node, corner, out) {
+    const sx = corner === "top-left" || corner === "bottom-left" ? 0 : 1;
+    const sy = corner === "top-left" || corner === "top-right" ? 0 : 1;
+    const x = node.getX();
+    const y = node.getY();
+    const w = node.getWidth();
+    const h = node.getHeight();
+    const r = node.getRotation();
+    const cx = x + w / 2;
+    const cy = y + h / 2;
+    const lx = (sx - 0.5) * w;
+    const ly = (sy - 0.5) * h;
+    const c = Math.cos(r);
+    const s = Math.sin(r);
+    out.worldX = cx + lx * c - ly * s;
+    out.worldY = cy + lx * s + ly * c;
+  }
+  _emitStateChanged() {
+    this._internalStateVersion++;
+    this._emit("stateChanged", {});
+  }
+  _dispatchToControls(event) {
+    if (event.type === "mouseleave") {
+      if (this._activeControl) {
+        this._activeControl.handleEvent(event);
+        this._activeControl = null;
+      } else {
+        for (const ctrl of this._controls) {
+          ctrl.handleEvent(event);
+        }
+      }
+      this.changeCursor("default");
+      this._emit(event.type, event);
+      return;
+    }
+    if (this._activeControl) {
+      const next = this._activeControl.handleEvent(event);
+      if (next !== null) {
+        this._activeControl = next;
+        this._emit(event.type, event);
+        return;
+      }
+      this._activeControl = null;
+    }
+    if (event.type === "mousemove") {
+      this.changeCursor("default");
+    }
+    for (const ctrl of this._controls) {
+      const next = ctrl.handleEvent(event);
+      if (next !== null) {
+        this._activeControl = next;
+        break;
+      }
+    }
+    this._emit(event.type, event);
+  }
+  _createPointerEvent(type, e) {
+    const viewX = this._viewXFromEvent(e);
+    const viewY = this._viewYFromEvent(e);
+    const we = type === "scroll" ? e : null;
+    return {
+      type,
+      viewX,
+      viewY,
+      deltaY: we ? we.deltaY : null,
+      preventDefault: () => e.preventDefault(),
+      metaKey: we?.metaKey,
+      ctrlKey: we?.ctrlKey
+    };
+  }
+  _on(type, fn) {
+    let list = this._listeners.get(type);
+    if (!list) {
+      list = [];
+      this._listeners.set(type, list);
+    }
+    list.push(fn);
+  }
+  _getObjectEditorConstructor(objectType) {
+    return this._objectEditorConstructors.get(objectType) ?? null;
+  }
+  _updateObjectTree(objects) {
+    for (const id in this._objects) {
+      if (!(id in objects)) {
+        this._objects[id].destroy();
+        if (id === this._highlightedObjectId) {
+          this._highlightedObjectId = null;
+        }
+        delete this._objects[id];
+      }
+    }
+    for (const id in objects) {
+      const cfg = objects[id];
+      const existing = this._objects[id];
+      if (existing) {
+        if (existing.getType() !== cfg.type) {
+          throw new Error(`Object "${id}" type changed from "${existing.getType()}" to "${cfg.type}". Type changes are not allowed.`);
+        }
+        existing.move(cfg.x, cfg.y);
+        existing.resize(cfg.width, cfg.height);
+        existing.rotate(cfg.rotation ?? 0);
+        existing.updateState(cfg.options);
+        continue;
+      }
+      const ctor = this._objectConstructors.get(cfg.type);
+      if (!ctor) {
+        console.warn(`No constructor registered for object type "${cfg.type}"`);
+        continue;
+      }
+      const obj = ctor(cfg.options, this._localInvalidate);
+      const node = new RSObjectNode(this._innerContainerNode, obj, cfg.x, cfg.y, cfg.width, cfg.height, cfg.type, id, (oid) => this._editingObjectId === oid, cfg.rotation ?? 0);
+      this._objects[id] = node;
+    }
+  }
+  onHighlight(fn) {
+    this._on("highlight", (e) => fn(e.objectId ?? null));
+  }
+  onStateChanged(fn) {
+    this._on("stateChanged", () => fn(this));
+  }
+  registerObjectType(objectType, constructor) {
+    this._objectConstructors.set(objectType, constructor);
+  }
+  registerObjectTypeEditor(objectType, constructor) {
+    this._objectEditorConstructors.set(objectType, constructor);
+  }
+  setState(state) {
+    this._pendingState = state.objects ?? {};
+    this._pendingStateVersion = this._internalStateVersion;
+    this._invalidate();
+  }
+  getStateSFCT(state) {
+    if (!state.objects) {
+      state.objects = {};
+    }
+    for (const id in this._objects) {
+      const node = this._objects[id];
+      const cfg = state.objects[id];
+      if (cfg) {
+        cfg.type = node.getType();
+        cfg.x = node.getX();
+        cfg.y = node.getY();
+        cfg.width = node.getWidth();
+        cfg.height = node.getHeight();
+        cfg.rotation = node.getRotation();
+        if (!cfg.options) {
+          cfg.options = {};
+        }
+        node.getOptionsSFCT(cfg.options);
+      } else {
+        const options = {};
+        node.getOptionsSFCT(options);
+        state.objects[id] = {
+          type: node.getType(),
+          x: node.getX(),
+          y: node.getY(),
+          width: node.getWidth(),
+          height: node.getHeight(),
+          rotation: node.getRotation(),
+          options
+        };
+      }
+    }
+    for (const id in state.objects) {
+      if (!(id in this._objects)) {
+        delete state.objects[id];
+      }
+    }
+  }
+  changeCursor(cursor) {
+    this._containerNode.style.cursor = cursor;
+  }
+  addControlToFront(ControlCtor) {
+    const control = new ControlCtor(this);
+    this._controls.unshift(control);
+    return control;
+  }
+  getScale() {
+    return this._scale;
+  }
+  toWorldX(viewX) {
+    return (viewX - this._translateX) / this._scale;
+  }
+  toWorldY(viewY) {
+    return (viewY - this._translateY) / this._scale;
+  }
+  toViewX(worldX) {
+    return this._translateX + worldX * this._scale;
+  }
+  toViewY(worldY) {
+    return this._translateY + worldY * this._scale;
+  }
+  objectIdAtXY(viewX, viewY) {
+    const worldX = this.toWorldX(viewX);
+    const worldY = this.toWorldY(viewY);
+    for (const id in this._objects) {
+      if (this._objects[id].interacts(worldX, worldY)) {
+        return id;
+      }
+    }
+    return null;
+  }
+  objectIdAtLowerRightCorner(viewX, viewY) {
+    const worldX = this.toWorldX(viewX);
+    const worldY = this.toWorldY(viewY);
+    const threshold = RESIZE_HANDLE_SIZE / this._scale;
+    const out = this._cornerPosScratch;
+    for (const id in this._objects) {
+      this._cornerWorldPosSFCT(this._objects[id], "bottom-right", out);
+      if (Math.abs(worldX - out.worldX) <= threshold && Math.abs(worldY - out.worldY) <= threshold) {
+        return this._objects[id].getId();
+      }
+    }
+    return null;
+  }
+  objectIdAtUpperRightCorner(viewX, viewY) {
+    const worldX = this.toWorldX(viewX);
+    const worldY = this.toWorldY(viewY);
+    const threshold = ROTATION_HANDLE_SIZE2 / this._scale;
+    const out = this._cornerPosScratch;
+    for (const id in this._objects) {
+      this._cornerWorldPosSFCT(this._objects[id], "top-right", out);
+      if (Math.abs(worldX - out.worldX) <= threshold && Math.abs(worldY - out.worldY) <= threshold) {
+        return this._objects[id].getId();
+      }
+    }
+    return null;
+  }
+  getCornerWorldXYSFCT(objectId, corner, out) {
+    const node = this._objects[objectId];
+    if (!node) {
+      return false;
+    }
+    this._cornerWorldPosSFCT(node, corner, out);
+    return true;
+  }
+  getCanvasWidth() {
+    return this._width;
+  }
+  getCanvasHeight() {
+    return this._height;
+  }
+  getObjectNode(objectId) {
+    return this._objects[objectId] ?? null;
+  }
+  resizeObject(objectId, dw, dh) {
+    const node = this._objects[objectId];
+    if (!node) {
+      return;
+    }
+    const w = node.getWidth();
+    const h = node.getHeight();
+    node.resize(Math.max(1, w + dw), Math.max(1, h + dh));
+    this._emitStateChanged();
+    this._invalidate();
+  }
+  rotateObject(objectId, dAngle) {
+    const node = this._objects[objectId];
+    if (!node) {
+      return;
+    }
+    node.rotate(node.getRotation() + dAngle);
+    this._emitStateChanged();
+    this._invalidate();
+  }
+  translateObject(objectId, dx, dy) {
+    const node = this._objects[objectId];
+    if (!node) {
+      return;
+    }
+    node.translate(dx, dy);
+    this._emitStateChanged();
+    this._invalidate();
+  }
+  translate(dx, dy) {
+    this._translateX += dx;
+    this._translateY += dy;
+    this._dirtyTransform = true;
+    this._invalidate();
+  }
+  scaleAtXY(scaleFactor, viewX, viewY) {
+    const worldX = this.toWorldX(viewX);
+    const worldY = this.toWorldY(viewY);
+    this._scale *= scaleFactor;
+    this._translateX = viewX - worldX * this._scale;
+    this._translateY = viewY - worldY * this._scale;
+    this._dirtyTransform = true;
+    this._invalidate();
+  }
+  center() {
+    const padding = 8;
+    const cw = this._containerNode.clientWidth - padding * 2;
+    const ch = this._containerNode.clientHeight - padding * 2;
+    this._scale = Math.min(cw / this._width, ch / this._height);
+    this._translateX = (this._containerNode.clientWidth - this._width * this._scale) / 2;
+    this._translateY = (this._containerNode.clientHeight - this._height * this._scale) / 2;
+    this._dirtyTransform = true;
+    this._invalidate();
+  }
+  highlightObject(id) {
+    if (!(id in this._objects)) {
+      return;
+    }
+    if (this._highlightedObjectId && this._highlightedObjectId !== id) {
+      this._objects[this._highlightedObjectId]?.unhighlight();
+      this._invalidate();
+    }
+    if (id !== this._highlightedObjectId) {
+      this._highlightedObjectId = id;
+      this._objects[id]?.highlight(this._highlightColor);
+      this._containerNode.focus();
+      this._invalidate();
+      this._emit("highlight", { objectId: id });
+    }
+  }
+  clearHighlight() {
+    if (!this._highlightedObjectId) {
+      return;
+    }
+    this._objects[this._highlightedObjectId]?.unhighlight();
+    this._emit("highlight", { objectId: null });
+    this._highlightedObjectId = null;
+    this._invalidate();
+  }
+  setHighlightColor(color) {
+    this._highlightColor = color;
+    if (this._highlightedObjectId) {
+      this._objects[this._highlightedObjectId]?.highlight(color);
+      this._invalidate();
+    }
+  }
+  getHighlightedObjectId() {
+    return this._highlightedObjectId;
+  }
+  canEditObject(objectId) {
+    const node = this._objects[objectId];
+    return node ? this._objectEditorConstructors.has(node.getType()) : false;
+  }
+  startEditSession(objectId, hostHandle) {
+    const node = this._objects[objectId];
+    if (!node) {
+      return false;
+    }
+    const EditorCtor = this._getObjectEditorConstructor(node.getType());
+    if (!EditorCtor) {
+      return false;
+    }
+    this._editingObjectId = objectId;
+    const container = node.getContainerNode();
+    const options = {};
+    node.getOptionsSFCT(options);
+    const editorHandle = {
+      onCommit: (newState) => {
+        node.updateState(newState);
+        this._emitStateChanged();
+        this._invalidate();
+      },
+      onEnd: () => {
+        this._editingObjectId = null;
+        hostHandle.onEnd();
+        this._invalidate();
+      }
+    };
+    const editor = new EditorCtor(this, options, container, editorHandle);
+    editor._sessionHandle = hostHandle;
+    return true;
+  }
+  deleteObject(objectId) {
+    const node = this._objects[objectId];
+    if (!node) {
+      return;
+    }
+    node.destroy();
+    delete this._objects[objectId];
+    if (this._highlightedObjectId === objectId) {
+      this._highlightedObjectId = null;
+    }
+    this._emitStateChanged();
+    this._invalidate();
+  }
+  async saveToImage(callback) {
+    const clone = this._innerContainerNode.cloneNode(true);
+    clone.style.transform = "none";
+    clone.style.position = "fixed";
+    clone.style.left = "-9999px";
+    clone.style.top = "0";
+    clone.style.zIndex = "-1";
+    const overlayClone = clone.lastElementChild;
+    if (overlayClone) {
+      overlayClone.style.visibility = "hidden";
+    }
+    document.body.appendChild(clone);
+    const imgs = clone.querySelectorAll("img");
+    await Promise.all(
+      Array.from(imgs).map(async (img) => {
+        const src = img.getAttribute("src") ?? "";
+        if (src.startsWith("blob:")) {
+          try {
+            const blob = await fetch(src).then((r) => r.blob());
+            const dataUrl = await new Promise((resolve, reject) => {
+              const r = new FileReader();
+              r.onload = () => resolve(r.result);
+              r.onerror = reject;
+              r.readAsDataURL(blob);
+            });
+            img.src = dataUrl;
+          } catch {
+          }
+        } else if (src.startsWith("http://") || src.startsWith("https://")) {
+          img.setAttribute("crossorigin", "anonymous");
+        }
+      })
+    );
+    await Promise.all(
+      Array.from(clone.querySelectorAll("img")).map(
+        (img) => new Promise((resolve) => {
+          if (img.complete) {
+            resolve();
+            return;
+          }
+          img.onload = () => resolve();
+          img.onerror = () => resolve();
+          setTimeout(resolve, 5e3);
+        })
+      )
+    );
+    try {
+      const canvas = await (0, import_html2canvas.default)(clone, {
+        scale: 1,
+        useCORS: true
+      });
+      const blob = await new Promise((resolve) => {
+        canvas.toBlob((b) => resolve(b), "image/png");
+      });
+      if (blob) {
+        callback(blob);
+      }
+    } finally {
+      clone.remove();
+    }
+  }
+  destroy() {
+    if (this._destroyed) {
+      return;
+    }
+    this._destroyed = true;
+    this._resizeObserver.disconnect();
+    if (this._rafId != null) {
+      cancelAnimationFrame(this._rafId);
+      this._rafId = null;
+    }
+    this._activeControl = null;
+    this._dispatchToControls({
+      type: "mouseleave",
+      viewX: 0,
+      viewY: 0,
+      deltaY: null,
+      preventDefault: () => {
+      }
+    });
+    this._containerNode.removeEventListener("mousedown", this._onMouseDown);
+    this._containerNode.removeEventListener("mouseup", this._onMouseUp);
+    this._containerNode.removeEventListener("mouseenter", this._onMouseEnter);
+    this._containerNode.removeEventListener("mouseleave", this._onMouseLeave);
+    this._containerNode.removeEventListener("mousemove", this._onMouseMove);
+    this._containerNode.removeEventListener("click", this._onClick);
+    this._containerNode.removeEventListener("dblclick", this._onDblClick);
+    this._containerNode.removeEventListener("wheel", this._onScroll);
+    this._containerNode.removeEventListener("keydown", this._onKeyDown);
+    this._containerNode.removeEventListener("keyup", this._onKeyUp);
+    for (const ctrl of this._controls) {
+      ctrl.destroy();
+    }
+    for (const id in this._objects) {
+      this._objects[id].destroy();
+    }
+    this._objects = {};
+    this._innerContainerNode.remove();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RSCanvas,
+  richTextSchema
+});
+//# sourceMappingURL=index.js.map