@youcan/celeste 0.6.38 → 0.6.39

package/dist/cjs/chunks/index2.js

@@ -1,1457 +1,44 @@
 "use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const index = require("./index3.js");
-const index$1 = require("./index.js");
 const Mo = require("vue");
-var readFromCache;
-var addToCache;
-if (typeof WeakMap != "undefined") {
-  let cache = /* @__PURE__ */ new WeakMap();
-  readFromCache = (key) => cache.get(key);
-  addToCache = (key, value) => {
-    cache.set(key, value);
-    return value;
-  };
-} else {
-  const cache = [];
-  const cacheSize = 10;
-  let cachePos = 0;
-  readFromCache = (key) => {
-    for (let i = 0; i < cache.length; i += 2)
-      if (cache[i] == key) return cache[i + 1];
-  };
-  addToCache = (key, value) => {
-    if (cachePos == cacheSize) cachePos = 0;
-    cache[cachePos++] = key;
-    return cache[cachePos++] = value;
-  };
-}
-var TableMap = class {
-  constructor(width, height, map, problems) {
-    this.width = width;
-    this.height = height;
-    this.map = map;
-    this.problems = problems;
-  }
-  // Find the dimensions of the cell at the given position.
-  findCell(pos) {
-    for (let i = 0; i < this.map.length; i++) {
-      const curPos = this.map[i];
-      if (curPos != pos) continue;
-      const left = i % this.width;
-      const top = i / this.width | 0;
-      let right = left + 1;
-      let bottom = top + 1;
-      for (let j = 1; right < this.width && this.map[i + j] == curPos; j++) {
-        right++;
-      }
-      for (let j = 1; bottom < this.height && this.map[i + this.width * j] == curPos; j++) {
-        bottom++;
-      }
-      return { left, top, right, bottom };
-    }
-    throw new RangeError(`No cell with offset ${pos} found`);
-  }
-  // Find the left side of the cell at the given position.
-  colCount(pos) {
-    for (let i = 0; i < this.map.length; i++) {
-      if (this.map[i] == pos) {
-        return i % this.width;
-      }
-    }
-    throw new RangeError(`No cell with offset ${pos} found`);
-  }
-  // Find the next cell in the given direction, starting from the cell
-  // at `pos`, if any.
-  nextCell(pos, axis, dir) {
-    const { left, right, top, bottom } = this.findCell(pos);
-    if (axis == "horiz") {
-      if (dir < 0 ? left == 0 : right == this.width) return null;
-      return this.map[top * this.width + (dir < 0 ? left - 1 : right)];
-    } else {
-      if (dir < 0 ? top == 0 : bottom == this.height) return null;
-      return this.map[left + this.width * (dir < 0 ? top - 1 : bottom)];
-    }
-  }
-  // Get the rectangle spanning the two given cells.
-  rectBetween(a, b) {
-    const {
-      left: leftA,
-      right: rightA,
-      top: topA,
-      bottom: bottomA
-    } = this.findCell(a);
-    const {
-      left: leftB,
-      right: rightB,
-      top: topB,
-      bottom: bottomB
-    } = this.findCell(b);
-    return {
-      left: Math.min(leftA, leftB),
-      top: Math.min(topA, topB),
-      right: Math.max(rightA, rightB),
-      bottom: Math.max(bottomA, bottomB)
-    };
-  }
-  // Return the position of all cells that have the top left corner in
-  // the given rectangle.
-  cellsInRect(rect) {
-    const result = [];
-    const seen = {};
-    for (let row = rect.top; row < rect.bottom; row++) {
-      for (let col = rect.left; col < rect.right; col++) {
-        const index2 = row * this.width + col;
-        const pos = this.map[index2];
-        if (seen[pos]) continue;
-        seen[pos] = true;
-        if (col == rect.left && col && this.map[index2 - 1] == pos || row == rect.top && row && this.map[index2 - this.width] == pos) {
-          continue;
-        }
-        result.push(pos);
-      }
-    }
-    return result;
-  }
-  // Return the position at which the cell at the given row and column
-  // starts, or would start, if a cell started there.
-  positionAt(row, col, table) {
-    for (let i = 0, rowStart = 0; ; i++) {
-      const rowEnd = rowStart + table.child(i).nodeSize;
-      if (i == row) {
-        let index2 = col + row * this.width;
-        const rowEndIndex = (row + 1) * this.width;
-        while (index2 < rowEndIndex && this.map[index2] < rowStart) index2++;
-        return index2 == rowEndIndex ? rowEnd - 1 : this.map[index2];
-      }
-      rowStart = rowEnd;
-    }
-  }
-  // Find the table map for the given table node.
-  static get(table) {
-    return readFromCache(table) || addToCache(table, computeMap(table));
-  }
-};
-function computeMap(table) {
-  if (table.type.spec.tableRole != "table")
-    throw new RangeError("Not a table node: " + table.type.name);
-  const width = findWidth(table), height = table.childCount;
-  const map = [];
-  let mapPos = 0;
-  let problems = null;
-  const colWidths = [];
-  for (let i = 0, e = width * height; i < e; i++) map[i] = 0;
-  for (let row = 0, pos = 0; row < height; row++) {
-    const rowNode = table.child(row);
-    pos++;
-    for (let i = 0; ; i++) {
-      while (mapPos < map.length && map[mapPos] != 0) mapPos++;
-      if (i == rowNode.childCount) break;
-      const cellNode = rowNode.child(i);
-      const { colspan, rowspan, colwidth } = cellNode.attrs;
-      for (let h = 0; h < rowspan; h++) {
-        if (h + row >= height) {
-          (problems || (problems = [])).push({
-            type: "overlong_rowspan",
-            pos,
-            n: rowspan - h
-          });
-          break;
-        }
-        const start = mapPos + h * width;
-        for (let w = 0; w < colspan; w++) {
-          if (map[start + w] == 0) map[start + w] = pos;
-          else
-            (problems || (problems = [])).push({
-              type: "collision",
-              row,
-              pos,
-              n: colspan - w
-            });
-          const colW = colwidth && colwidth[w];
-          if (colW) {
-            const widthIndex = (start + w) % width * 2, prev = colWidths[widthIndex];
-            if (prev == null || prev != colW && colWidths[widthIndex + 1] == 1) {
-              colWidths[widthIndex] = colW;
-              colWidths[widthIndex + 1] = 1;
-            } else if (prev == colW) {
-              colWidths[widthIndex + 1]++;
-            }
-          }
-        }
-      }
-      mapPos += colspan;
-      pos += cellNode.nodeSize;
-    }
-    const expectedPos = (row + 1) * width;
-    let missing = 0;
-    while (mapPos < expectedPos) if (map[mapPos++] == 0) missing++;
-    if (missing)
-      (problems || (problems = [])).push({ type: "missing", row, n: missing });
-    pos++;
-  }
-  if (width === 0 || height === 0)
-    (problems || (problems = [])).push({ type: "zero_sized" });
-  const tableMap = new TableMap(width, height, map, problems);
-  let badWidths = false;
-  for (let i = 0; !badWidths && i < colWidths.length; i += 2)
-    if (colWidths[i] != null && colWidths[i + 1] < height) badWidths = true;
-  if (badWidths) findBadColWidths(tableMap, colWidths, table);
-  return tableMap;
-}
-function findWidth(table) {
-  let width = -1;
-  let hasRowSpan = false;
-  for (let row = 0; row < table.childCount; row++) {
-    const rowNode = table.child(row);
-    let rowWidth = 0;
-    if (hasRowSpan)
-      for (let j = 0; j < row; j++) {
-        const prevRow = table.child(j);
-        for (let i = 0; i < prevRow.childCount; i++) {
-          const cell = prevRow.child(i);
-          if (j + cell.attrs.rowspan > row) rowWidth += cell.attrs.colspan;
-        }
-      }
-    for (let i = 0; i < rowNode.childCount; i++) {
-      const cell = rowNode.child(i);
-      rowWidth += cell.attrs.colspan;
-      if (cell.attrs.rowspan > 1) hasRowSpan = true;
-    }
-    if (width == -1) width = rowWidth;
-    else if (width != rowWidth) width = Math.max(width, rowWidth);
-  }
-  return width;
-}
-function findBadColWidths(map, colWidths, table) {
-  if (!map.problems) map.problems = [];
-  const seen = {};
-  for (let i = 0; i < map.map.length; i++) {
-    const pos = map.map[i];
-    if (seen[pos]) continue;
-    seen[pos] = true;
-    const node = table.nodeAt(pos);
-    if (!node) {
-      throw new RangeError(`No cell with offset ${pos} found`);
-    }
-    let updated = null;
-    const attrs = node.attrs;
-    for (let j = 0; j < attrs.colspan; j++) {
-      const col = (i + j) % map.width;
-      const colWidth = colWidths[col * 2];
-      if (colWidth != null && (!attrs.colwidth || attrs.colwidth[j] != colWidth))
-        (updated || (updated = freshColWidth(attrs)))[j] = colWidth;
-    }
-    if (updated)
-      map.problems.unshift({
-        type: "colwidth mismatch",
-        pos,
-        colwidth: updated
-      });
-  }
-}
-function freshColWidth(attrs) {
-  if (attrs.colwidth) return attrs.colwidth.slice();
-  const result = [];
-  for (let i = 0; i < attrs.colspan; i++) result.push(0);
-  return result;
-}
-function tableNodeTypes(schema) {
-  let result = schema.cached.tableNodeTypes;
-  if (!result) {
-    result = schema.cached.tableNodeTypes = {};
-    for (const name in schema.nodes) {
-      const type = schema.nodes[name], role = type.spec.tableRole;
-      if (role) result[role] = type;
-    }
-  }
-  return result;
-}
-new index.PluginKey("selectingCells");
-function cellAround($pos) {
-  for (let d = $pos.depth - 1; d > 0; d--)
-    if ($pos.node(d).type.spec.tableRole == "row")
-      return $pos.node(0).resolve($pos.before(d + 1));
-  return null;
-}
-function isInTable(state) {
-  const $head = state.selection.$head;
-  for (let d = $head.depth; d > 0; d--)
-    if ($head.node(d).type.spec.tableRole == "row") return true;
-  return false;
-}
-function selectionCell(state) {
-  const sel = state.selection;
-  if ("$anchorCell" in sel && sel.$anchorCell) {
-    return sel.$anchorCell.pos > sel.$headCell.pos ? sel.$anchorCell : sel.$headCell;
-  } else if ("node" in sel && sel.node && sel.node.type.spec.tableRole == "cell") {
-    return sel.$anchor;
-  }
-  const $cell = cellAround(sel.$head) || cellNear(sel.$head);
-  if ($cell) {
-    return $cell;
-  }
-  throw new RangeError(`No cell found around position ${sel.head}`);
-}
-function cellNear($pos) {
-  for (let after = $pos.nodeAfter, pos = $pos.pos; after; after = after.firstChild, pos++) {
-    const role = after.type.spec.tableRole;
-    if (role == "cell" || role == "header_cell") return $pos.doc.resolve(pos);
-  }
-  for (let before = $pos.nodeBefore, pos = $pos.pos; before; before = before.lastChild, pos--) {
-    const role = before.type.spec.tableRole;
-    if (role == "cell" || role == "header_cell")
-      return $pos.doc.resolve(pos - before.nodeSize);
-  }
-}
-function pointsAtCell($pos) {
-  return $pos.parent.type.spec.tableRole == "row" && !!$pos.nodeAfter;
-}
-function inSameTable($cellA, $cellB) {
-  return $cellA.depth == $cellB.depth && $cellA.pos >= $cellB.start(-1) && $cellA.pos <= $cellB.end(-1);
-}
-function nextCell($pos, axis, dir) {
-  const table = $pos.node(-1);
-  const map = TableMap.get(table);
-  const tableStart = $pos.start(-1);
-  const moved = map.nextCell($pos.pos - tableStart, axis, dir);
-  return moved == null ? null : $pos.node(0).resolve(tableStart + moved);
-}
-function removeColSpan(attrs, pos, n = 1) {
-  const result = { ...attrs, colspan: attrs.colspan - n };
-  if (result.colwidth) {
-    result.colwidth = result.colwidth.slice();
-    result.colwidth.splice(pos, n);
-    if (!result.colwidth.some((w) => w > 0)) result.colwidth = null;
-  }
-  return result;
-}
-var CellSelection = class _CellSelection extends index.Selection {
-  // A table selection is identified by its anchor and head cells. The
-  // positions given to this constructor should point _before_ two
-  // cells in the same table. They may be the same, to select a single
-  // cell.
-  constructor($anchorCell, $headCell = $anchorCell) {
-    const table = $anchorCell.node(-1);
-    const map = TableMap.get(table);
-    const tableStart = $anchorCell.start(-1);
-    const rect = map.rectBetween(
-      $anchorCell.pos - tableStart,
-      $headCell.pos - tableStart
-    );
-    const doc = $anchorCell.node(0);
-    const cells = map.cellsInRect(rect).filter((p) => p != $headCell.pos - tableStart);
-    cells.unshift($headCell.pos - tableStart);
-    const ranges = cells.map((pos) => {
-      const cell = table.nodeAt(pos);
-      if (!cell) {
-        throw RangeError(`No cell with offset ${pos} found`);
-      }
-      const from = tableStart + pos + 1;
-      return new index.SelectionRange(
-        doc.resolve(from),
-        doc.resolve(from + cell.content.size)
-      );
-    });
-    super(ranges[0].$from, ranges[0].$to, ranges);
-    this.$anchorCell = $anchorCell;
-    this.$headCell = $headCell;
-  }
-  map(doc, mapping) {
-    const $anchorCell = doc.resolve(mapping.map(this.$anchorCell.pos));
-    const $headCell = doc.resolve(mapping.map(this.$headCell.pos));
-    if (pointsAtCell($anchorCell) && pointsAtCell($headCell) && inSameTable($anchorCell, $headCell)) {
-      const tableChanged = this.$anchorCell.node(-1) != $anchorCell.node(-1);
-      if (tableChanged && this.isRowSelection())
-        return _CellSelection.rowSelection($anchorCell, $headCell);
-      else if (tableChanged && this.isColSelection())
-        return _CellSelection.colSelection($anchorCell, $headCell);
-      else return new _CellSelection($anchorCell, $headCell);
-    }
-    return index.TextSelection.between($anchorCell, $headCell);
-  }
-  // Returns a rectangular slice of table rows containing the selected
-  // cells.
-  content() {
-    const table = this.$anchorCell.node(-1);
-    const map = TableMap.get(table);
-    const tableStart = this.$anchorCell.start(-1);
-    const rect = map.rectBetween(
-      this.$anchorCell.pos - tableStart,
-      this.$headCell.pos - tableStart
-    );
-    const seen = {};
-    const rows = [];
-    for (let row = rect.top; row < rect.bottom; row++) {
-      const rowContent = [];
-      for (let index2 = row * map.width + rect.left, col = rect.left; col < rect.right; col++, index2++) {
-        const pos = map.map[index2];
-        if (seen[pos]) continue;
-        seen[pos] = true;
-        const cellRect = map.findCell(pos);
-        let cell = table.nodeAt(pos);
-        if (!cell) {
-          throw RangeError(`No cell with offset ${pos} found`);
-        }
-        const extraLeft = rect.left - cellRect.left;
-        const extraRight = cellRect.right - rect.right;
-        if (extraLeft > 0 || extraRight > 0) {
-          let attrs = cell.attrs;
-          if (extraLeft > 0) {
-            attrs = removeColSpan(attrs, 0, extraLeft);
-          }
-          if (extraRight > 0) {
-            attrs = removeColSpan(
-              attrs,
-              attrs.colspan - extraRight,
-              extraRight
-            );
-          }
-          if (cellRect.left < rect.left) {
-            cell = cell.type.createAndFill(attrs);
-            if (!cell) {
-              throw RangeError(
-                `Could not create cell with attrs ${JSON.stringify(attrs)}`
-              );
-            }
-          } else {
-            cell = cell.type.create(attrs, cell.content);
-          }
-        }
-        if (cellRect.top < rect.top || cellRect.bottom > rect.bottom) {
-          const attrs = {
-            ...cell.attrs,
-            rowspan: Math.min(cellRect.bottom, rect.bottom) - Math.max(cellRect.top, rect.top)
-          };
-          if (cellRect.top < rect.top) {
-            cell = cell.type.createAndFill(attrs);
-          } else {
-            cell = cell.type.create(attrs, cell.content);
-          }
-        }
-        rowContent.push(cell);
-      }
-      rows.push(table.child(row).copy(index.Fragment.from(rowContent)));
-    }
-    const fragment = this.isColSelection() && this.isRowSelection() ? table : rows;
-    return new index.Slice(index.Fragment.from(fragment), 1, 1);
-  }
-  replace(tr, content = index.Slice.empty) {
-    const mapFrom = tr.steps.length, ranges = this.ranges;
-    for (let i = 0; i < ranges.length; i++) {
-      const { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);
-      tr.replace(
-        mapping.map($from.pos),
-        mapping.map($to.pos),
-        i ? index.Slice.empty : content
-      );
-    }
-    const sel = index.Selection.findFrom(
-      tr.doc.resolve(tr.mapping.slice(mapFrom).map(this.to)),
-      -1
-    );
-    if (sel) tr.setSelection(sel);
-  }
-  replaceWith(tr, node) {
-    this.replace(tr, new index.Slice(index.Fragment.from(node), 0, 0));
-  }
-  forEachCell(f) {
-    const table = this.$anchorCell.node(-1);
-    const map = TableMap.get(table);
-    const tableStart = this.$anchorCell.start(-1);
-    const cells = map.cellsInRect(
-      map.rectBetween(
-        this.$anchorCell.pos - tableStart,
-        this.$headCell.pos - tableStart
-      )
-    );
-    for (let i = 0; i < cells.length; i++) {
-      f(table.nodeAt(cells[i]), tableStart + cells[i]);
-    }
-  }
-  // True if this selection goes all the way from the top to the
-  // bottom of the table.
-  isColSelection() {
-    const anchorTop = this.$anchorCell.index(-1);
-    const headTop = this.$headCell.index(-1);
-    if (Math.min(anchorTop, headTop) > 0) return false;
-    const anchorBottom = anchorTop + this.$anchorCell.nodeAfter.attrs.rowspan;
-    const headBottom = headTop + this.$headCell.nodeAfter.attrs.rowspan;
-    return Math.max(anchorBottom, headBottom) == this.$headCell.node(-1).childCount;
-  }
-  // Returns the smallest column selection that covers the given anchor
-  // and head cell.
-  static colSelection($anchorCell, $headCell = $anchorCell) {
-    const table = $anchorCell.node(-1);
-    const map = TableMap.get(table);
-    const tableStart = $anchorCell.start(-1);
-    const anchorRect = map.findCell($anchorCell.pos - tableStart);
-    const headRect = map.findCell($headCell.pos - tableStart);
-    const doc = $anchorCell.node(0);
-    if (anchorRect.top <= headRect.top) {
-      if (anchorRect.top > 0)
-        $anchorCell = doc.resolve(tableStart + map.map[anchorRect.left]);
-      if (headRect.bottom < map.height)
-        $headCell = doc.resolve(
-          tableStart + map.map[map.width * (map.height - 1) + headRect.right - 1]
-        );
-    } else {
-      if (headRect.top > 0)
-        $headCell = doc.resolve(tableStart + map.map[headRect.left]);
-      if (anchorRect.bottom < map.height)
-        $anchorCell = doc.resolve(
-          tableStart + map.map[map.width * (map.height - 1) + anchorRect.right - 1]
-        );
-    }
-    return new _CellSelection($anchorCell, $headCell);
-  }
-  // True if this selection goes all the way from the left to the
-  // right of the table.
-  isRowSelection() {
-    const table = this.$anchorCell.node(-1);
-    const map = TableMap.get(table);
-    const tableStart = this.$anchorCell.start(-1);
-    const anchorLeft = map.colCount(this.$anchorCell.pos - tableStart);
-    const headLeft = map.colCount(this.$headCell.pos - tableStart);
-    if (Math.min(anchorLeft, headLeft) > 0) return false;
-    const anchorRight = anchorLeft + this.$anchorCell.nodeAfter.attrs.colspan;
-    const headRight = headLeft + this.$headCell.nodeAfter.attrs.colspan;
-    return Math.max(anchorRight, headRight) == map.width;
-  }
-  eq(other) {
-    return other instanceof _CellSelection && other.$anchorCell.pos == this.$anchorCell.pos && other.$headCell.pos == this.$headCell.pos;
-  }
-  // Returns the smallest row selection that covers the given anchor
-  // and head cell.
-  static rowSelection($anchorCell, $headCell = $anchorCell) {
-    const table = $anchorCell.node(-1);
-    const map = TableMap.get(table);
-    const tableStart = $anchorCell.start(-1);
-    const anchorRect = map.findCell($anchorCell.pos - tableStart);
-    const headRect = map.findCell($headCell.pos - tableStart);
-    const doc = $anchorCell.node(0);
-    if (anchorRect.left <= headRect.left) {
-      if (anchorRect.left > 0)
-        $anchorCell = doc.resolve(
-          tableStart + map.map[anchorRect.top * map.width]
-        );
-      if (headRect.right < map.width)
-        $headCell = doc.resolve(
-          tableStart + map.map[map.width * (headRect.top + 1) - 1]
-        );
-    } else {
-      if (headRect.left > 0)
-        $headCell = doc.resolve(tableStart + map.map[headRect.top * map.width]);
-      if (anchorRect.right < map.width)
-        $anchorCell = doc.resolve(
-          tableStart + map.map[map.width * (anchorRect.top + 1) - 1]
-        );
-    }
-    return new _CellSelection($anchorCell, $headCell);
-  }
-  toJSON() {
-    return {
-      type: "cell",
-      anchor: this.$anchorCell.pos,
-      head: this.$headCell.pos
-    };
-  }
-  static fromJSON(doc, json) {
-    return new _CellSelection(doc.resolve(json.anchor), doc.resolve(json.head));
-  }
-  static create(doc, anchorCell, headCell = anchorCell) {
-    return new _CellSelection(doc.resolve(anchorCell), doc.resolve(headCell));
-  }
-  getBookmark() {
-    return new CellBookmark(this.$anchorCell.pos, this.$headCell.pos);
-  }
-};
-CellSelection.prototype.visible = false;
-index.Selection.jsonID("cell", CellSelection);
-var CellBookmark = class _CellBookmark {
-  constructor(anchor, head) {
-    this.anchor = anchor;
-    this.head = head;
-  }
-  map(mapping) {
-    return new _CellBookmark(mapping.map(this.anchor), mapping.map(this.head));
-  }
-  resolve(doc) {
-    const $anchorCell = doc.resolve(this.anchor), $headCell = doc.resolve(this.head);
-    if ($anchorCell.parent.type.spec.tableRole == "row" && $headCell.parent.type.spec.tableRole == "row" && $anchorCell.index() < $anchorCell.parent.childCount && $headCell.index() < $headCell.parent.childCount && inSameTable($anchorCell, $headCell))
-      return new CellSelection($anchorCell, $headCell);
-    else return index.Selection.near($headCell, 1);
-  }
-};
-new index.PluginKey("fix-tables");
-function selectedRect(state) {
-  const sel = state.selection;
-  const $pos = selectionCell(state);
-  const table = $pos.node(-1);
-  const tableStart = $pos.start(-1);
-  const map = TableMap.get(table);
-  const rect = sel instanceof CellSelection ? map.rectBetween(
-    sel.$anchorCell.pos - tableStart,
-    sel.$headCell.pos - tableStart
-  ) : map.findCell($pos.pos - tableStart);
-  return { ...rect, tableStart, map, table };
-}
-function deprecated_toggleHeader(type) {
-  return function(state, dispatch) {
-    if (!isInTable(state)) return false;
-    if (dispatch) {
-      const types = tableNodeTypes(state.schema);
-      const rect = selectedRect(state), tr = state.tr;
-      const cells = rect.map.cellsInRect(
-        type == "column" ? {
-          left: rect.left,
-          top: 0,
-          right: rect.right,
-          bottom: rect.map.height
-        } : type == "row" ? {
-          left: 0,
-          top: rect.top,
-          right: rect.map.width,
-          bottom: rect.bottom
-        } : rect
-      );
-      const nodes = cells.map((pos) => rect.table.nodeAt(pos));
-      for (let i = 0; i < cells.length; i++)
-        if (nodes[i].type == types.header_cell)
-          tr.setNodeMarkup(
-            rect.tableStart + cells[i],
-            types.cell,
-            nodes[i].attrs
-          );
-      if (tr.steps.length == 0)
-        for (let i = 0; i < cells.length; i++)
-          tr.setNodeMarkup(
-            rect.tableStart + cells[i],
-            types.header_cell,
-            nodes[i].attrs
-          );
-      dispatch(tr);
-    }
-    return true;
-  };
-}
-function isHeaderEnabledByType(type, rect, types) {
-  const cellPositions = rect.map.cellsInRect({
-    left: 0,
-    top: 0,
-    right: type == "row" ? rect.map.width : 1,
-    bottom: type == "column" ? rect.map.height : 1
-  });
-  for (let i = 0; i < cellPositions.length; i++) {
-    const cell = rect.table.nodeAt(cellPositions[i]);
-    if (cell && cell.type !== types.header_cell) {
-      return false;
-    }
-  }
-  return true;
-}
-function toggleHeader(type, options) {
-  options = options || { useDeprecatedLogic: false };
-  if (options.useDeprecatedLogic) return deprecated_toggleHeader(type);
-  return function(state, dispatch) {
-    if (!isInTable(state)) return false;
-    if (dispatch) {
-      const types = tableNodeTypes(state.schema);
-      const rect = selectedRect(state), tr = state.tr;
-      const isHeaderRowEnabled = isHeaderEnabledByType("row", rect, types);
-      const isHeaderColumnEnabled = isHeaderEnabledByType(
-        "column",
-        rect,
-        types
-      );
-      const isHeaderEnabled = type === "column" ? isHeaderRowEnabled : type === "row" ? isHeaderColumnEnabled : false;
-      const selectionStartsAt = isHeaderEnabled ? 1 : 0;
-      const cellsRect = type == "column" ? {
-        left: 0,
-        top: selectionStartsAt,
-        right: 1,
-        bottom: rect.map.height
-      } : type == "row" ? {
-        left: selectionStartsAt,
-        top: 0,
-        right: rect.map.width,
-        bottom: 1
-      } : rect;
-      const newType = type == "column" ? isHeaderColumnEnabled ? types.cell : types.header_cell : type == "row" ? isHeaderRowEnabled ? types.cell : types.header_cell : types.cell;
-      rect.map.cellsInRect(cellsRect).forEach((relativeCellPos) => {
-        const cellPos = relativeCellPos + rect.tableStart;
-        const cell = tr.doc.nodeAt(cellPos);
-        if (cell) {
-          tr.setNodeMarkup(cellPos, newType, cell.attrs);
-        }
-      });
-      dispatch(tr);
-    }
-    return true;
-  };
-}
-toggleHeader("row", {
-  useDeprecatedLogic: true
-});
-toggleHeader("column", {
-  useDeprecatedLogic: true
-});
-toggleHeader("cell", {
-  useDeprecatedLogic: true
-});
-function deleteCellSelection(state, dispatch) {
-  const sel = state.selection;
-  if (!(sel instanceof CellSelection)) return false;
-  if (dispatch) {
-    const tr = state.tr;
-    const baseContent = tableNodeTypes(state.schema).cell.createAndFill().content;
-    sel.forEachCell((cell, pos) => {
-      if (!cell.content.eq(baseContent))
-        tr.replace(
-          tr.mapping.map(pos + 1),
-          tr.mapping.map(pos + cell.nodeSize - 1),
-          new index.Slice(baseContent, 0, 0)
-        );
-    });
-    if (tr.docChanged) dispatch(tr);
-  }
-  return true;
-}
-index.keydownHandler({
-  ArrowLeft: arrow("horiz", -1),
-  ArrowRight: arrow("horiz", 1),
-  ArrowUp: arrow("vert", -1),
-  ArrowDown: arrow("vert", 1),
-  "Shift-ArrowLeft": shiftArrow("horiz", -1),
-  "Shift-ArrowRight": shiftArrow("horiz", 1),
-  "Shift-ArrowUp": shiftArrow("vert", -1),
-  "Shift-ArrowDown": shiftArrow("vert", 1),
-  Backspace: deleteCellSelection,
-  "Mod-Backspace": deleteCellSelection,
-  Delete: deleteCellSelection,
-  "Mod-Delete": deleteCellSelection
-});
-function maybeSetSelection(state, dispatch, selection) {
-  if (selection.eq(state.selection)) return false;
-  if (dispatch) dispatch(state.tr.setSelection(selection).scrollIntoView());
-  return true;
-}
-function arrow(axis, dir) {
-  return (state, dispatch, view) => {
-    if (!view) return false;
-    const sel = state.selection;
-    if (sel instanceof CellSelection) {
-      return maybeSetSelection(
-        state,
-        dispatch,
-        index.Selection.near(sel.$headCell, dir)
-      );
-    }
-    if (axis != "horiz" && !sel.empty) return false;
-    const end = atEndOfCell(view, axis, dir);
-    if (end == null) return false;
-    if (axis == "horiz") {
-      return maybeSetSelection(
-        state,
-        dispatch,
-        index.Selection.near(state.doc.resolve(sel.head + dir), dir)
-      );
-    } else {
-      const $cell = state.doc.resolve(end);
-      const $next = nextCell($cell, axis, dir);
-      let newSel;
-      if ($next) newSel = index.Selection.near($next, 1);
-      else if (dir < 0)
-        newSel = index.Selection.near(state.doc.resolve($cell.before(-1)), -1);
-      else newSel = index.Selection.near(state.doc.resolve($cell.after(-1)), 1);
-      return maybeSetSelection(state, dispatch, newSel);
-    }
-  };
-}
-function shiftArrow(axis, dir) {
-  return (state, dispatch, view) => {
-    if (!view) return false;
-    const sel = state.selection;
-    let cellSel;
-    if (sel instanceof CellSelection) {
-      cellSel = sel;
-    } else {
-      const end = atEndOfCell(view, axis, dir);
-      if (end == null) return false;
-      cellSel = new CellSelection(state.doc.resolve(end));
-    }
-    const $head = nextCell(cellSel.$headCell, axis, dir);
-    if (!$head) return false;
-    return maybeSetSelection(
-      state,
-      dispatch,
-      new CellSelection(cellSel.$anchorCell, $head)
-    );
-  };
-}
-function atEndOfCell(view, axis, dir) {
-  if (!(view.state.selection instanceof index.TextSelection)) return null;
-  const { $head } = view.state.selection;
-  for (let d = $head.depth - 1; d >= 0; d--) {
-    const parent = $head.node(d), index2 = dir < 0 ? $head.index(d) : $head.indexAfter(d);
-    if (index2 != (dir < 0 ? 0 : parent.childCount)) return null;
-    if (parent.type.spec.tableRole == "cell" || parent.type.spec.tableRole == "header_cell") {
-      const cellPos = $head.before(d);
-      const dirStr = axis == "vert" ? dir > 0 ? "down" : "up" : dir > 0 ? "right" : "left";
-      return view.endOfTextblock(dirStr) ? cellPos : null;
-    }
-  }
-  return null;
-}
-new index.PluginKey(
-  "tableColumnResizing"
-);
-function combineDOMRects(rect1, rect2) {
-  const top = Math.min(rect1.top, rect2.top);
-  const bottom = Math.max(rect1.bottom, rect2.bottom);
-  const left = Math.min(rect1.left, rect2.left);
-  const right = Math.max(rect1.right, rect2.right);
-  const width = right - left;
-  const height = bottom - top;
-  const x = left;
-  const y = top;
-  return new DOMRect(x, y, width, height);
-}
-var BubbleMenuView = class {
-  constructor({
-    editor,
-    element,
-    view,
-    updateDelay = 250,
-    resizeDelay = 60,
-    shouldShow,
-    options
-  }) {
-    this.preventHide = false;
-    this.isVisible = false;
-    this.floatingUIOptions = {
-      strategy: "absolute",
-      placement: "top",
-      offset: 8,
-      flip: {},
-      shift: {},
-      arrow: false,
-      size: false,
-      autoPlacement: false,
-      hide: false,
-      inline: false,
-      onShow: void 0,
-      onHide: void 0,
-      onUpdate: void 0,
-      onDestroy: void 0
-    };
-    this.shouldShow = ({ view: view2, state, from, to }) => {
-      const { doc, selection } = state;
-      const { empty } = selection;
-      const isEmptyTextBlock = !doc.textBetween(from, to).length && index.isTextSelection(state.selection);
-      const isChildOfMenu = this.element.contains(document.activeElement);
-      const hasEditorFocus = view2.hasFocus() || isChildOfMenu;
-      if (!hasEditorFocus || empty || isEmptyTextBlock || !this.editor.isEditable) {
-        return false;
-      }
+function toReactive(objectRef) {
+  if (!Mo.isRef(objectRef))
+    return Mo.reactive(objectRef);
+  const proxy = new Proxy({}, {
+    get(_, p, receiver) {
+      return Mo.unref(Reflect.get(objectRef.value, p, receiver));
+    },
+    set(_, p, value) {
+      if (Mo.isRef(objectRef.value[p]) && !Mo.isRef(value))
+        objectRef.value[p].value = value;
+      else
+        objectRef.value[p] = value;
       return true;
-    };
-    this.mousedownHandler = () => {
-      this.preventHide = true;
-    };
-    this.dragstartHandler = () => {
-      this.hide();
-    };
-    this.resizeHandler = () => {
-      if (this.resizeDebounceTimer) {
-        clearTimeout(this.resizeDebounceTimer);
-      }
-      this.resizeDebounceTimer = window.setTimeout(() => {
-        this.updatePosition();
-      }, this.resizeDelay);
-    };
-    this.focusHandler = () => {
-      setTimeout(() => this.update(this.editor.view));
-    };
-    this.blurHandler = ({ event }) => {
-      var _a;
-      if (this.preventHide) {
-        this.preventHide = false;
-        return;
-      }
-      if ((event == null ? void 0 : event.relatedTarget) && ((_a = this.element.parentNode) == null ? void 0 : _a.contains(event.relatedTarget))) {
-        return;
-      }
-      if ((event == null ? void 0 : event.relatedTarget) === this.editor.view.dom) {
-        return;
-      }
-      this.hide();
-    };
-    this.handleDebouncedUpdate = (view2, oldState) => {
-      const selectionChanged = !(oldState == null ? void 0 : oldState.selection.eq(view2.state.selection));
-      const docChanged = !(oldState == null ? void 0 : oldState.doc.eq(view2.state.doc));
-      if (!selectionChanged && !docChanged) {
-        return;
-      }
-      if (this.updateDebounceTimer) {
-        clearTimeout(this.updateDebounceTimer);
-      }
-      this.updateDebounceTimer = window.setTimeout(() => {
-        this.updateHandler(view2, selectionChanged, docChanged, oldState);
-      }, this.updateDelay);
-    };
-    this.updateHandler = (view2, selectionChanged, docChanged, oldState) => {
-      const { composing } = view2;
-      const isSame = !selectionChanged && !docChanged;
-      if (composing || isSame) {
-        return;
-      }
-      const shouldShow2 = this.getShouldShow(oldState);
-      if (!shouldShow2) {
-        this.hide();
-        return;
-      }
-      this.updatePosition();
-      this.show();
-    };
-    this.editor = editor;
-    this.element = element;
-    this.view = view;
-    this.updateDelay = updateDelay;
-    this.resizeDelay = resizeDelay;
-    this.floatingUIOptions = {
-      ...this.floatingUIOptions,
-      ...options
-    };
-    this.element.tabIndex = 0;
-    if (shouldShow) {
-      this.shouldShow = shouldShow;
-    }
-    this.element.addEventListener("mousedown", this.mousedownHandler, { capture: true });
-    this.view.dom.addEventListener("dragstart", this.dragstartHandler);
-    this.editor.on("focus", this.focusHandler);
-    this.editor.on("blur", this.blurHandler);
-    window.addEventListener("resize", this.resizeHandler);
-    this.update(view, view.state);
-    if (this.getShouldShow()) {
-      this.show();
-    }
-  }
-  get middlewares() {
-    const middlewares = [];
-    if (this.floatingUIOptions.flip) {
-      middlewares.push(index$1.flip(typeof this.floatingUIOptions.flip !== "boolean" ? this.floatingUIOptions.flip : void 0));
-    }
-    if (this.floatingUIOptions.shift) {
-      middlewares.push(
-        index$1.shift(typeof this.floatingUIOptions.shift !== "boolean" ? this.floatingUIOptions.shift : void 0)
-      );
-    }
-    if (this.floatingUIOptions.offset) {
-      middlewares.push(
-        index$1.offset(typeof this.floatingUIOptions.offset !== "boolean" ? this.floatingUIOptions.offset : void 0)
-      );
-    }
-    if (this.floatingUIOptions.arrow) {
-      middlewares.push(index$1.arrow(this.floatingUIOptions.arrow));
-    }
-    if (this.floatingUIOptions.size) {
-      middlewares.push(index$1.size(typeof this.floatingUIOptions.size !== "boolean" ? this.floatingUIOptions.size : void 0));
-    }
-    if (this.floatingUIOptions.autoPlacement) {
-      middlewares.push(
-        index$1.autoPlacement(
-          typeof this.floatingUIOptions.autoPlacement !== "boolean" ? this.floatingUIOptions.autoPlacement : void 0
-        )
-      );
-    }
-    if (this.floatingUIOptions.hide) {
-      middlewares.push(index$1.hide(typeof this.floatingUIOptions.hide !== "boolean" ? this.floatingUIOptions.hide : void 0));
-    }
-    if (this.floatingUIOptions.inline) {
-      middlewares.push(
-        index$1.inline(typeof this.floatingUIOptions.inline !== "boolean" ? this.floatingUIOptions.inline : void 0)
-      );
-    }
-    return middlewares;
-  }
-  updatePosition() {
-    const { selection } = this.editor.state;
-    const domRect = index.posToDOMRect(this.view, selection.from, selection.to);
-    let virtualElement = {
-      getBoundingClientRect: () => domRect,
-      getClientRects: () => [domRect]
-    };
-    if (selection instanceof CellSelection) {
-      const { $anchorCell, $headCell } = selection;
-      const from = $anchorCell ? $anchorCell.pos : $headCell.pos;
-      const to = $headCell ? $headCell.pos : $anchorCell.pos;
-      const fromDOM = this.view.nodeDOM(from);
-      const toDOM = this.view.nodeDOM(to);
-      if (!fromDOM || !toDOM) {
-        return;
-      }
-      const clientRect = fromDOM === toDOM ? fromDOM.getBoundingClientRect() : combineDOMRects(
-        fromDOM.getBoundingClientRect(),
-        toDOM.getBoundingClientRect()
-      );
-      virtualElement = {
-        getBoundingClientRect: () => clientRect,
-        getClientRects: () => [clientRect]
-      };
-    }
-    index$1.computePosition(virtualElement, this.element, {
-      placement: this.floatingUIOptions.placement,
-      strategy: this.floatingUIOptions.strategy,
-      middleware: this.middlewares
-    }).then(({ x, y, strategy }) => {
-      this.element.style.width = "max-content";
-      this.element.style.position = strategy;
-      this.element.style.left = `${x}px`;
-      this.element.style.top = `${y}px`;
-      if (this.isVisible && this.floatingUIOptions.onUpdate) {
-        this.floatingUIOptions.onUpdate();
-      }
-    });
-  }
-  update(view, oldState) {
-    const { state } = view;
-    const hasValidSelection = state.selection.from !== state.selection.to;
-    if (this.updateDelay > 0 && hasValidSelection) {
-      this.handleDebouncedUpdate(view, oldState);
-      return;
-    }
-    const selectionChanged = !(oldState == null ? void 0 : oldState.selection.eq(view.state.selection));
-    const docChanged = !(oldState == null ? void 0 : oldState.doc.eq(view.state.doc));
-    this.updateHandler(view, selectionChanged, docChanged, oldState);
-  }
-  getShouldShow(oldState) {
-    var _a;
-    const { state } = this.view;
-    const { selection } = state;
-    const { ranges } = selection;
-    const from = Math.min(...ranges.map((range) => range.$from.pos));
-    const to = Math.max(...ranges.map((range) => range.$to.pos));
-    const shouldShow = (_a = this.shouldShow) == null ? void 0 : _a.call(this, {
-      editor: this.editor,
-      element: this.element,
-      view: this.view,
-      state,
-      oldState,
-      from,
-      to
-    });
-    return shouldShow;
-  }
-  show() {
-    var _a;
-    if (this.isVisible) {
-      return;
-    }
-    this.element.style.visibility = "visible";
-    this.element.style.opacity = "1";
-    (_a = this.view.dom.parentElement) == null ? void 0 : _a.appendChild(this.element);
-    if (this.floatingUIOptions.onShow) {
-      this.floatingUIOptions.onShow();
-    }
-    this.isVisible = true;
-  }
-  hide() {
-    if (!this.isVisible) {
-      return;
-    }
-    this.element.style.visibility = "hidden";
-    this.element.style.opacity = "0";
-    this.element.remove();
-    if (this.floatingUIOptions.onHide) {
-      this.floatingUIOptions.onHide();
-    }
-    this.isVisible = false;
-  }
-  destroy() {
-    this.hide();
-    this.element.removeEventListener("mousedown", this.mousedownHandler, { capture: true });
-    this.view.dom.removeEventListener("dragstart", this.dragstartHandler);
-    window.removeEventListener("resize", this.resizeHandler);
-    this.editor.off("focus", this.focusHandler);
-    this.editor.off("blur", this.blurHandler);
-    if (this.floatingUIOptions.onDestroy) {
-      this.floatingUIOptions.onDestroy();
-    }
-  }
-};
-var BubbleMenuPlugin = (options) => {
-  return new index.Plugin({
-    key: typeof options.pluginKey === "string" ? new index.PluginKey(options.pluginKey) : options.pluginKey,
-    view: (view) => new BubbleMenuView({ view, ...options })
-  });
-};
-index.Extension.create({
-  name: "bubbleMenu",
-  addOptions() {
-    return {
-      element: null,
-      pluginKey: "bubbleMenu",
-      updateDelay: void 0,
-      shouldShow: null
-    };
-  },
-  addProseMirrorPlugins() {
-    if (!this.options.element) {
-      return [];
-    }
-    return [
-      BubbleMenuPlugin({
-        pluginKey: this.options.pluginKey,
-        editor: this.editor,
-        element: this.options.element,
-        updateDelay: this.options.updateDelay,
-        options: this.options.options,
-        shouldShow: this.options.shouldShow
-      })
-    ];
-  }
-});
-var BubbleMenu2 = Mo.defineComponent({
-  name: "BubbleMenu",
-  props: {
-    pluginKey: {
-      type: [String, Object],
-      default: "bubbleMenu"
     },
-    editor: {
-      type: Object,
-      required: true
+    deleteProperty(_, p) {
+      return Reflect.deleteProperty(objectRef.value, p);
     },
-    updateDelay: {
-      type: Number,
-      default: void 0
+    has(_, p) {
+      return Reflect.has(objectRef.value, p);
     },
-    resizeDelay: {
-      type: Number,
-      default: void 0
+    ownKeys() {
+      return Object.keys(objectRef.value);
     },
-    options: {
-      type: Object,
-      default: () => ({})
-    },
-    shouldShow: {
-      type: Function,
-      default: null
-    }
-  },
-  setup(props, { slots }) {
-    const root = Mo.ref(null);
-    Mo.onMounted(() => {
-      const { editor, options, pluginKey, resizeDelay, shouldShow, updateDelay } = props;
-      if (!root.value) {
-        return;
-      }
-      root.value.style.visibility = "hidden";
-      root.value.style.position = "absolute";
-      root.value.remove();
-      editor.registerPlugin(
-        BubbleMenuPlugin({
-          editor,
-          element: root.value,
-          options,
-          pluginKey,
-          resizeDelay,
-          shouldShow,
-          updateDelay
-        })
-      );
-    });
-    Mo.onBeforeUnmount(() => {
-      const { pluginKey, editor } = props;
-      editor.unregisterPlugin(pluginKey);
-    });
-    return () => {
-      var _a;
-      return Mo.h(Mo.Teleport, { to: "body" }, Mo.h("div", { ref: root }, (_a = slots.default) == null ? void 0 : _a.call(slots)));
-    };
-  }
-});
-var FloatingMenuView = class {
-  constructor({ editor, element, view, options, shouldShow }) {
-    this.preventHide = false;
-    this.isVisible = false;
-    this.shouldShow = ({ view: view2, state }) => {
-      const { selection } = state;
-      const { $anchor, empty } = selection;
-      const isRootDepth = $anchor.depth === 1;
-      const isEmptyTextBlock = $anchor.parent.isTextblock && !$anchor.parent.type.spec.code && !$anchor.parent.textContent && $anchor.parent.childCount === 0 && !this.getTextContent($anchor.parent);
-      if (!view2.hasFocus() || !empty || !isRootDepth || !isEmptyTextBlock || !this.editor.isEditable) {
-        return false;
-      }
-      return true;
-    };
-    this.floatingUIOptions = {
-      strategy: "absolute",
-      placement: "right",
-      offset: 8,
-      flip: {},
-      shift: {},
-      arrow: false,
-      size: false,
-      autoPlacement: false,
-      hide: false,
-      inline: false
-    };
-    this.updateHandler = (view2, selectionChanged, docChanged, oldState) => {
-      const { composing } = view2;
-      const isSame = !selectionChanged && !docChanged;
-      if (composing || isSame) {
-        return;
-      }
-      const shouldShow2 = this.getShouldShow(oldState);
-      if (!shouldShow2) {
-        this.hide();
-        return;
-      }
-      this.updatePosition();
-      this.show();
-    };
-    this.mousedownHandler = () => {
-      this.preventHide = true;
-    };
-    this.focusHandler = () => {
-      setTimeout(() => this.update(this.editor.view));
-    };
-    this.blurHandler = ({ event }) => {
-      var _a;
-      if (this.preventHide) {
-        this.preventHide = false;
-        return;
-      }
-      if ((event == null ? void 0 : event.relatedTarget) && ((_a = this.element.parentNode) == null ? void 0 : _a.contains(event.relatedTarget))) {
-        return;
-      }
-      if ((event == null ? void 0 : event.relatedTarget) === this.editor.view.dom) {
-        return;
-      }
-      this.hide();
-    };
-    this.editor = editor;
-    this.element = element;
-    this.view = view;
-    this.floatingUIOptions = {
-      ...this.floatingUIOptions,
-      ...options
-    };
-    this.element.tabIndex = 0;
-    if (shouldShow) {
-      this.shouldShow = shouldShow;
-    }
-    this.element.addEventListener("mousedown", this.mousedownHandler, { capture: true });
-    this.editor.on("focus", this.focusHandler);
-    this.editor.on("blur", this.blurHandler);
-    this.update(view, view.state);
-    if (this.getShouldShow()) {
-      this.show();
-    }
-  }
-  getTextContent(node) {
-    return index.getText(node, { textSerializers: index.getTextSerializersFromSchema(this.editor.schema) });
-  }
-  get middlewares() {
-    const middlewares = [];
-    if (this.floatingUIOptions.flip) {
-      middlewares.push(index$1.flip(typeof this.floatingUIOptions.flip !== "boolean" ? this.floatingUIOptions.flip : void 0));
-    }
-    if (this.floatingUIOptions.shift) {
-      middlewares.push(
-        index$1.shift(typeof this.floatingUIOptions.shift !== "boolean" ? this.floatingUIOptions.shift : void 0)
-      );
-    }
-    if (this.floatingUIOptions.offset) {
-      middlewares.push(
-        index$1.offset(typeof this.floatingUIOptions.offset !== "boolean" ? this.floatingUIOptions.offset : void 0)
-      );
-    }
-    if (this.floatingUIOptions.arrow) {
-      middlewares.push(index$1.arrow(this.floatingUIOptions.arrow));
-    }
-    if (this.floatingUIOptions.size) {
-      middlewares.push(index$1.size(typeof this.floatingUIOptions.size !== "boolean" ? this.floatingUIOptions.size : void 0));
-    }
-    if (this.floatingUIOptions.autoPlacement) {
-      middlewares.push(
-        index$1.autoPlacement(
-          typeof this.floatingUIOptions.autoPlacement !== "boolean" ? this.floatingUIOptions.autoPlacement : void 0
-        )
-      );
-    }
-    if (this.floatingUIOptions.hide) {
-      middlewares.push(index$1.hide(typeof this.floatingUIOptions.hide !== "boolean" ? this.floatingUIOptions.hide : void 0));
-    }
-    if (this.floatingUIOptions.inline) {
-      middlewares.push(
-        index$1.inline(typeof this.floatingUIOptions.inline !== "boolean" ? this.floatingUIOptions.inline : void 0)
-      );
-    }
-    return middlewares;
-  }
-  getShouldShow(oldState) {
-    var _a;
-    const { state } = this.view;
-    const { selection } = state;
-    const { ranges } = selection;
-    const from = Math.min(...ranges.map((range) => range.$from.pos));
-    const to = Math.max(...ranges.map((range) => range.$to.pos));
-    const shouldShow = (_a = this.shouldShow) == null ? void 0 : _a.call(this, {
-      editor: this.editor,
-      view: this.view,
-      state,
-      oldState,
-      from,
-      to
-    });
-    return shouldShow;
-  }
-  updatePosition() {
-    const { selection } = this.editor.state;
-    const domRect = index.posToDOMRect(this.view, selection.from, selection.to);
-    const virtualElement = {
-      getBoundingClientRect: () => domRect,
-      getClientRects: () => [domRect]
-    };
-    index$1.computePosition(virtualElement, this.element, {
-      placement: this.floatingUIOptions.placement,
-      strategy: this.floatingUIOptions.strategy,
-      middleware: this.middlewares
-    }).then(({ x, y, strategy }) => {
-      this.element.style.width = "max-content";
-      this.element.style.position = strategy;
-      this.element.style.left = `${x}px`;
-      this.element.style.top = `${y}px`;
-      if (this.isVisible && this.floatingUIOptions.onUpdate) {
-        this.floatingUIOptions.onUpdate();
-      }
-    });
-  }
-  update(view, oldState) {
-    const selectionChanged = !(oldState == null ? void 0 : oldState.selection.eq(view.state.selection));
-    const docChanged = !(oldState == null ? void 0 : oldState.doc.eq(view.state.doc));
-    this.updateHandler(view, selectionChanged, docChanged, oldState);
-  }
-  show() {
-    var _a;
-    if (this.isVisible) {
-      return;
-    }
-    this.element.style.visibility = "visible";
-    this.element.style.opacity = "1";
-    (_a = this.view.dom.parentElement) == null ? void 0 : _a.appendChild(this.element);
-    if (this.floatingUIOptions.onShow) {
-      this.floatingUIOptions.onShow();
-    }
-    this.isVisible = true;
-  }
-  hide() {
-    if (!this.isVisible) {
-      return;
-    }
-    this.element.style.visibility = "hidden";
-    this.element.style.opacity = "0";
-    this.element.remove();
-    if (this.floatingUIOptions.onHide) {
-      this.floatingUIOptions.onHide();
-    }
-    this.isVisible = false;
-  }
-  destroy() {
-    this.hide();
-    this.element.removeEventListener("mousedown", this.mousedownHandler, { capture: true });
-    this.editor.off("focus", this.focusHandler);
-    this.editor.off("blur", this.blurHandler);
-    if (this.floatingUIOptions.onDestroy) {
-      this.floatingUIOptions.onDestroy();
+    getOwnPropertyDescriptor() {
+      return {
+        enumerable: true,
+        configurable: true
+      };
     }
-  }
-};
-var FloatingMenuPlugin = (options) => {
-  return new index.Plugin({
-    key: typeof options.pluginKey === "string" ? new index.PluginKey(options.pluginKey) : options.pluginKey,
-    view: (view) => new FloatingMenuView({ view, ...options })
   });
-};
-index.Extension.create({
-  name: "floatingMenu",
-  addOptions() {
-    return {
-      element: null,
-      options: {},
-      pluginKey: "floatingMenu",
-      shouldShow: null
-    };
-  },
-  addProseMirrorPlugins() {
-    if (!this.options.element) {
-      return [];
-    }
-    return [
-      FloatingMenuPlugin({
-        pluginKey: this.options.pluginKey,
-        editor: this.editor,
-        element: this.options.element,
-        options: this.options.options,
-        shouldShow: this.options.shouldShow
-      })
-    ];
-  }
-});
-var FloatingMenu2 = Mo.defineComponent({
-  name: "FloatingMenu",
-  props: {
-    pluginKey: {
-      // TODO: TypeScript breaks :(
-      // type: [String, Object as PropType<Exclude<FloatingMenuPluginProps['pluginKey'], string>>],
-      type: null,
-      default: "floatingMenu"
-    },
-    editor: {
-      type: Object,
-      required: true
-    },
-    options: {
-      type: Object,
-      default: () => ({})
-    },
-    shouldShow: {
-      type: Function,
-      default: null
-    }
-  },
-  setup(props, { slots }) {
-    const root = Mo.ref(null);
-    Mo.onMounted(() => {
-      const { pluginKey, editor, options, shouldShow } = props;
-      if (!root.value) {
-        return;
-      }
-      root.value.style.visibility = "hidden";
-      root.value.style.position = "absolute";
-      root.value.remove();
-      editor.registerPlugin(
-        FloatingMenuPlugin({
-          pluginKey,
-          editor,
-          element: root.value,
-          options,
-          shouldShow
-        })
-      );
-    });
-    Mo.onBeforeUnmount(() => {
-      const { pluginKey, editor } = props;
-      editor.unregisterPlugin(pluginKey);
-    });
-    return () => {
-      var _a;
-      return Mo.h(Mo.Teleport, { to: "body" }, Mo.h("div", { ref: root }, (_a = slots.default) == null ? void 0 : _a.call(slots)));
-    };
-  }
-});
-exports.BubbleMenu = BubbleMenu2;
-exports.FloatingMenu = FloatingMenu2;
+  return Mo.reactive(proxy);
+}
+function reactiveComputed(fn) {
+  return toReactive(Mo.computed(fn));
+}
+function reactiveOmit(obj, ...keys) {
+  const flatKeys = keys.flat();
+  const predicate = flatKeys[0];
+  return reactiveComputed(() => typeof predicate === "function" ? Object.fromEntries(Object.entries(Mo.toRefs(obj)).filter(([k, v]) => !predicate(Mo.toValue(v), k))) : Object.fromEntries(Object.entries(Mo.toRefs(obj)).filter((e) => !flatKeys.includes(e[0]))));
+}
+typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+exports.reactiveOmit = reactiveOmit;