@youcan/celeste 0.6.57 → 0.6.60

package/dist/es/chunks/index3.js

@@ -1,1457 +1,273 @@
-import { P as PluginKey, S as Selection, k as keydownHandler, a as SelectionRange, T as TextSelection, F as Fragment, b as Slice, E as Extension, c as Plugin, i as isTextSelection, p as posToDOMRect, g as getText, d as getTextSerializersFromSchema } from "./index4.js";
-import { s as flip, u as shift, v as offset, w as arrow$1, B as size, C as autoPlacement, D as hide, E as inline, H as computePosition } from "./index.js";
-import { defineComponent, ref, onMounted, onBeforeUnmount, h, Teleport } from "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 index = row * this.width + col;
-        const pos = this.map[index];
-        if (seen[pos]) continue;
-        seen[pos] = true;
-        if (col == rect.left && col && this.map[index - 1] == pos || row == rect.top && row && this.map[index - 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 index = col + row * this.width;
-        const rowEndIndex = (row + 1) * this.width;
-        while (index < rowEndIndex && this.map[index] < rowStart) index++;
-        return index == rowEndIndex ? rowEnd - 1 : this.map[index];
-      }
-      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 h2 = 0; h2 < rowspan; h2++) {
-        if (h2 + row >= height) {
-          (problems || (problems = [])).push({
-            type: "overlong_rowspan",
-            pos,
-            n: rowspan - h2
-          });
-          break;
-        }
-        const start = mapPos + h2 * 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 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 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 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 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 index = row * map.width + rect.left, col = rect.left; col < rect.right; col++, index++) {
-        const pos = map.map[index];
-        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(Fragment.from(rowContent)));
-    }
-    const fragment = this.isColSelection() && this.isRowSelection() ? table : rows;
-    return new Slice(Fragment.from(fragment), 1, 1);
-  }
-  replace(tr, content = 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 ? Slice.empty : content
-      );
-    }
-    const sel = 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 Slice(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;
-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 Selection.near($headCell, 1);
-  }
-};
-new 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 };
+import { i as isClient, t as toArray, w as watchImmediate, a as tryOnScopeDispose, p as pxValue, b as isObject, c as isDef, d as injectLocal } from "./index2.js";
+import { computed, toValue, shallowRef, watchEffect, getCurrentInstance, ref, watch, nextTick, unref, hasInjectionContext, onMounted } from "vue";
+const defaultWindow = isClient ? window : void 0;
+const defaultDocument = isClient ? window.document : void 0;
+function unrefElement(elRef) {
+  var _a;
+  const plain = toValue(elRef);
+  return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
 }
-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 useEventListener(...args) {
+  const cleanups = [];
+  const cleanup = () => {
+    cleanups.forEach((fn) => fn());
+    cleanups.length = 0;
   };
-}
-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
+  const register = (el, event, listener, options) => {
+    el.addEventListener(event, listener, options);
+    return () => el.removeEventListener(event, listener, options);
+  };
+  const firstParamTargets = computed(() => {
+    const test = toArray(toValue(args[0])).filter((e) => e != null);
+    return test.every((e) => typeof e !== "string") ? test : void 0;
   });
-  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 stopWatch = watchImmediate(
+    () => {
+      var _a, _b;
+      return [
+        (_b = (_a = firstParamTargets.value) == null ? void 0 : _a.map((e) => unrefElement(e))) != null ? _b : [defaultWindow].filter((e) => e != null),
+        toArray(toValue(firstParamTargets.value ? args[1] : args[0])),
+        toArray(unref(firstParamTargets.value ? args[2] : args[1])),
+        // @ts-expect-error - TypeScript gets the correct types, but somehow still complains
+        toValue(firstParamTargets.value ? args[3] : args[2])
+      ];
+    },
+    ([raw_targets, raw_events, raw_listeners, raw_options]) => {
+      cleanup();
+      if (!(raw_targets == null ? void 0 : raw_targets.length) || !(raw_events == null ? void 0 : raw_events.length) || !(raw_listeners == null ? void 0 : raw_listeners.length))
+        return;
+      const optionsClone = isObject(raw_options) ? { ...raw_options } : raw_options;
+      cleanups.push(
+        ...raw_targets.flatMap(
+          (el) => raw_events.flatMap(
+            (event) => raw_listeners.map((listener) => register(el, event, listener, optionsClone))
+          )
+        )
       );
-      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;
+    },
+    { flush: "post" }
+  );
+  const stop = () => {
+    stopWatch();
+    cleanup();
   };
+  tryOnScopeDispose(cleanup);
+  return stop;
 }
-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 Slice(baseContent, 0, 0)
-        );
-    });
-    if (tr.docChanged) dispatch(tr);
+// @__NO_SIDE_EFFECTS__
+function useMounted() {
+  const isMounted = shallowRef(false);
+  const instance = getCurrentInstance();
+  if (instance) {
+    onMounted(() => {
+      isMounted.value = true;
+    }, instance);
   }
-  return true;
+  return isMounted;
 }
-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;
+// @__NO_SIDE_EFFECTS__
+function useSupported(callback) {
+  const isMounted = /* @__PURE__ */ useMounted();
+  return computed(() => {
+    isMounted.value;
+    return Boolean(callback());
+  });
 }
-function arrow(axis, dir) {
-  return (state, dispatch, view) => {
-    if (!view) return false;
-    const sel = state.selection;
-    if (sel instanceof CellSelection) {
-      return maybeSetSelection(
-        state,
-        dispatch,
-        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,
-        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 = Selection.near($next, 1);
-      else if (dir < 0)
-        newSel = Selection.near(state.doc.resolve($cell.before(-1)), -1);
-      else newSel = Selection.near(state.doc.resolve($cell.after(-1)), 1);
-      return maybeSetSelection(state, dispatch, newSel);
-    }
-  };
+const ssrWidthSymbol = Symbol("vueuse-ssr-width");
+// @__NO_SIDE_EFFECTS__
+function useSSRWidth() {
+  const ssrWidth = hasInjectionContext() ? injectLocal(ssrWidthSymbol, null) : null;
+  return typeof ssrWidth === "number" ? ssrWidth : void 0;
 }
-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 useMediaQuery(query, options = {}) {
+  const { window: window2 = defaultWindow, ssrWidth = /* @__PURE__ */ useSSRWidth() } = options;
+  const isSupported = /* @__PURE__ */ useSupported(() => window2 && "matchMedia" in window2 && typeof window2.matchMedia === "function");
+  const ssrSupport = shallowRef(typeof ssrWidth === "number");
+  const mediaQuery = shallowRef();
+  const matches = shallowRef(false);
+  const handler = (event) => {
+    matches.value = event.matches;
   };
-}
-function atEndOfCell(view, axis, dir) {
-  if (!(view.state.selection instanceof TextSelection)) return null;
-  const { $head } = view.state.selection;
-  for (let d = $head.depth - 1; d >= 0; d--) {
-    const parent = $head.node(d), index = dir < 0 ? $head.index(d) : $head.indexAfter(d);
-    if (index != (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 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 && isTextSelection(state.selection);
-      const isChildOfMenu = this.element.contains(document.activeElement);
-      const hasEditorFocus = view2.hasFocus() || isChildOfMenu;
-      if (!hasEditorFocus || empty || isEmptyTextBlock || !this.editor.isEditable) {
-        return false;
-      }
-      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(flip(typeof this.floatingUIOptions.flip !== "boolean" ? this.floatingUIOptions.flip : void 0));
-    }
-    if (this.floatingUIOptions.shift) {
-      middlewares.push(
-        shift(typeof this.floatingUIOptions.shift !== "boolean" ? this.floatingUIOptions.shift : void 0)
-      );
-    }
-    if (this.floatingUIOptions.offset) {
-      middlewares.push(
-        offset(typeof this.floatingUIOptions.offset !== "boolean" ? this.floatingUIOptions.offset : void 0)
-      );
-    }
-    if (this.floatingUIOptions.arrow) {
-      middlewares.push(arrow$1(this.floatingUIOptions.arrow));
-    }
-    if (this.floatingUIOptions.size) {
-      middlewares.push(size(typeof this.floatingUIOptions.size !== "boolean" ? this.floatingUIOptions.size : void 0));
-    }
-    if (this.floatingUIOptions.autoPlacement) {
-      middlewares.push(
-        autoPlacement(
-          typeof this.floatingUIOptions.autoPlacement !== "boolean" ? this.floatingUIOptions.autoPlacement : void 0
-        )
-      );
-    }
-    if (this.floatingUIOptions.hide) {
-      middlewares.push(hide(typeof this.floatingUIOptions.hide !== "boolean" ? this.floatingUIOptions.hide : void 0));
-    }
-    if (this.floatingUIOptions.inline) {
-      middlewares.push(
-        inline(typeof this.floatingUIOptions.inline !== "boolean" ? this.floatingUIOptions.inline : void 0)
-      );
-    }
-    return middlewares;
-  }
-  updatePosition() {
-    const { selection } = this.editor.state;
-    const domRect = 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]
-      };
-    }
-    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) {
+  watchEffect(() => {
+    if (ssrSupport.value) {
+      ssrSupport.value = !isSupported.value;
+      const queryStrings = toValue(query).split(",");
+      matches.value = queryStrings.some((queryString) => {
+        const not = queryString.includes("not all");
+        const minWidth = queryString.match(/\(\s*min-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/);
+        const maxWidth = queryString.match(/\(\s*max-width:\s*(-?\d+(?:\.\d*)?[a-z]+\s*)\)/);
+        let res = Boolean(minWidth || maxWidth);
+        if (minWidth && res) {
+          res = ssrWidth >= pxValue(minWidth[1]);
+        }
+        if (maxWidth && res) {
+          res = ssrWidth <= pxValue(maxWidth[1]);
+        }
+        return not ? !res : res;
+      });
       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) {
+    if (!isSupported.value)
       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 Plugin({
-    key: typeof options.pluginKey === "string" ? new PluginKey(options.pluginKey) : options.pluginKey,
-    view: (view) => new BubbleMenuView({ view, ...options })
+    mediaQuery.value = window2.matchMedia(toValue(query));
+    matches.value = mediaQuery.value.matches;
   });
-};
-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 = defineComponent({
-  name: "BubbleMenu",
-  props: {
-    pluginKey: {
-      type: [String, Object],
-      default: "bubbleMenu"
-    },
-    editor: {
-      type: Object,
-      required: true
-    },
-    updateDelay: {
-      type: Number,
-      default: void 0
-    },
-    resizeDelay: {
-      type: Number,
-      default: void 0
-    },
-    options: {
-      type: Object,
-      default: () => ({})
-    },
-    shouldShow: {
-      type: Function,
-      default: null
-    }
-  },
-  setup(props, { slots }) {
-    const root = ref(null);
-    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
-        })
-      );
-    });
-    onBeforeUnmount(() => {
-      const { pluginKey, editor } = props;
-      editor.unregisterPlugin(pluginKey);
-    });
-    return () => {
-      var _a;
-      return h(Teleport, { to: "body" }, h("div", { ref: root }, (_a = slots.default) == null ? void 0 : _a.call(slots)));
+  useEventListener(mediaQuery, "change", handler, { passive: true });
+  return computed(() => matches.value);
+}
+function cloneFnJSON(source) {
+  return JSON.parse(JSON.stringify(source));
+}
+function useDropZone(target, options = {}) {
+  var _a, _b;
+  const isOverDropZone = shallowRef(false);
+  const files = shallowRef(null);
+  let counter = 0;
+  let isValid = true;
+  if (isClient) {
+    const _options = typeof options === "function" ? { onDrop: options } : options;
+    const multiple = (_a = _options.multiple) != null ? _a : true;
+    const preventDefaultForUnhandled = (_b = _options.preventDefaultForUnhandled) != null ? _b : false;
+    const getFiles = (event) => {
+      var _a2, _b2;
+      const list = Array.from((_b2 = (_a2 = event.dataTransfer) == null ? void 0 : _a2.files) != null ? _b2 : []);
+      return list.length === 0 ? null : multiple ? list : [list[0]];
     };
-  }
-});
-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) {
+    const checkDataTypes = (types) => {
+      const dataTypes = unref(_options.dataTypes);
+      if (typeof dataTypes === "function")
+        return dataTypes(types);
+      if (!(dataTypes == null ? void 0 : dataTypes.length))
+        return true;
+      if (types.length === 0)
         return false;
-      }
-      return true;
+      return types.every(
+        (type) => dataTypes.some((allowedType) => type.includes(allowedType))
+      );
     };
-    this.floatingUIOptions = {
-      strategy: "absolute",
-      placement: "right",
-      offset: 8,
-      flip: {},
-      shift: {},
-      arrow: false,
-      size: false,
-      autoPlacement: false,
-      hide: false,
-      inline: false
+    const checkValidity = (items) => {
+      const types = Array.from(items != null ? items : []).map((item) => item.type);
+      const dataTypesValid = checkDataTypes(types);
+      const multipleFilesValid = multiple || items.length <= 1;
+      return dataTypesValid && multipleFilesValid;
     };
-    this.updateHandler = (view2, selectionChanged, docChanged, oldState) => {
-      const { composing } = view2;
-      const isSame = !selectionChanged && !docChanged;
-      if (composing || isSame) {
-        return;
+    const isSafari = () => /^(?:(?!chrome|android).)*safari/i.test(navigator.userAgent) && !("chrome" in window);
+    const handleDragEvent = (event, eventType) => {
+      var _a2, _b2, _c, _d, _e, _f;
+      const dataTransferItemList = (_a2 = event.dataTransfer) == null ? void 0 : _a2.items;
+      isValid = (_b2 = dataTransferItemList && checkValidity(dataTransferItemList)) != null ? _b2 : false;
+      if (preventDefaultForUnhandled) {
+        event.preventDefault();
       }
-      const shouldShow2 = this.getShouldShow(oldState);
-      if (!shouldShow2) {
-        this.hide();
+      if (!isSafari() && !isValid) {
+        if (event.dataTransfer) {
+          event.dataTransfer.dropEffect = "none";
+        }
         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;
+      event.preventDefault();
+      if (event.dataTransfer) {
+        event.dataTransfer.dropEffect = "copy";
       }
-      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;
+      const currentFiles = getFiles(event);
+      switch (eventType) {
+        case "enter":
+          counter += 1;
+          isOverDropZone.value = true;
+          (_c = _options.onEnter) == null ? void 0 : _c.call(_options, null, event);
+          break;
+        case "over":
+          (_d = _options.onOver) == null ? void 0 : _d.call(_options, null, event);
+          break;
+        case "leave":
+          counter -= 1;
+          if (counter === 0)
+            isOverDropZone.value = false;
+          (_e = _options.onLeave) == null ? void 0 : _e.call(_options, null, event);
+          break;
+        case "drop":
+          counter = 0;
+          isOverDropZone.value = false;
+          if (isValid) {
+            files.value = currentFiles;
+            (_f = _options.onDrop) == null ? void 0 : _f.call(_options, currentFiles, event);
+          }
+          break;
       }
-      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 getText(node, { textSerializers: getTextSerializersFromSchema(this.editor.schema) });
-  }
-  get middlewares() {
-    const middlewares = [];
-    if (this.floatingUIOptions.flip) {
-      middlewares.push(flip(typeof this.floatingUIOptions.flip !== "boolean" ? this.floatingUIOptions.flip : void 0));
-    }
-    if (this.floatingUIOptions.shift) {
-      middlewares.push(
-        shift(typeof this.floatingUIOptions.shift !== "boolean" ? this.floatingUIOptions.shift : void 0)
-      );
-    }
-    if (this.floatingUIOptions.offset) {
-      middlewares.push(
-        offset(typeof this.floatingUIOptions.offset !== "boolean" ? this.floatingUIOptions.offset : void 0)
-      );
-    }
-    if (this.floatingUIOptions.arrow) {
-      middlewares.push(arrow$1(this.floatingUIOptions.arrow));
-    }
-    if (this.floatingUIOptions.size) {
-      middlewares.push(size(typeof this.floatingUIOptions.size !== "boolean" ? this.floatingUIOptions.size : void 0));
-    }
-    if (this.floatingUIOptions.autoPlacement) {
-      middlewares.push(
-        autoPlacement(
-          typeof this.floatingUIOptions.autoPlacement !== "boolean" ? this.floatingUIOptions.autoPlacement : void 0
-        )
-      );
-    }
-    if (this.floatingUIOptions.hide) {
-      middlewares.push(hide(typeof this.floatingUIOptions.hide !== "boolean" ? this.floatingUIOptions.hide : void 0));
-    }
-    if (this.floatingUIOptions.inline) {
-      middlewares.push(
-        inline(typeof this.floatingUIOptions.inline !== "boolean" ? this.floatingUIOptions.inline : void 0)
-      );
+    useEventListener(target, "dragenter", (event) => handleDragEvent(event, "enter"));
+    useEventListener(target, "dragover", (event) => handleDragEvent(event, "over"));
+    useEventListener(target, "dragleave", (event) => handleDragEvent(event, "leave"));
+    useEventListener(target, "drop", (event) => handleDragEvent(event, "drop"));
+  }
+  return {
+    files,
+    isOverDropZone
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function useVModel(props, key, emit, options = {}) {
+  var _a, _b, _c;
+  const {
+    clone = false,
+    passive = false,
+    eventName,
+    deep = false,
+    defaultValue,
+    shouldEmit
+  } = options;
+  const vm = getCurrentInstance();
+  const _emit = emit || (vm == null ? void 0 : vm.emit) || ((_a = vm == null ? void 0 : vm.$emit) == null ? void 0 : _a.bind(vm)) || ((_c = (_b = vm == null ? void 0 : vm.proxy) == null ? void 0 : _b.$emit) == null ? void 0 : _c.bind(vm == null ? void 0 : vm.proxy));
+  let event = eventName;
+  event = event || `update:${key.toString()}`;
+  const cloneFn = (val) => !clone ? val : typeof clone === "function" ? clone(val) : cloneFnJSON(val);
+  const getValue = () => isDef(props[key]) ? cloneFn(props[key]) : defaultValue;
+  const triggerEmit = (value) => {
+    if (shouldEmit) {
+      if (shouldEmit(value))
+        _emit(event, value);
+    } else {
+      _emit(event, value);
     }
-    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 = posToDOMRect(this.view, selection.from, selection.to);
-    const virtualElement = {
-      getBoundingClientRect: () => domRect,
-      getClientRects: () => [domRect]
-    };
-    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();
+  };
+  if (passive) {
+    const initialValue = getValue();
+    const proxy = ref(initialValue);
+    let isUpdating = false;
+    watch(
+      () => props[key],
+      (v) => {
+        if (!isUpdating) {
+          isUpdating = true;
+          proxy.value = cloneFn(v);
+          nextTick(() => isUpdating = false);
+        }
       }
-    });
-  }
-  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();
-    }
-  }
-};
-var FloatingMenuPlugin = (options) => {
-  return new Plugin({
-    key: typeof options.pluginKey === "string" ? new PluginKey(options.pluginKey) : options.pluginKey,
-    view: (view) => new FloatingMenuView({ view, ...options })
-  });
-};
-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 = 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 = ref(null);
-    onMounted(() => {
-      const { pluginKey, editor, options, shouldShow } = props;
-      if (!root.value) {
-        return;
+    );
+    watch(
+      proxy,
+      (v) => {
+        if (!isUpdating && (v !== props[key] || deep))
+          triggerEmit(v);
+      },
+      { deep }
+    );
+    return proxy;
+  } else {
+    return computed({
+      get() {
+        return getValue();
+      },
+      set(value) {
+        triggerEmit(value);
       }
-      root.value.style.visibility = "hidden";
-      root.value.style.position = "absolute";
-      root.value.remove();
-      editor.registerPlugin(
-        FloatingMenuPlugin({
-          pluginKey,
-          editor,
-          element: root.value,
-          options,
-          shouldShow
-        })
-      );
-    });
-    onBeforeUnmount(() => {
-      const { pluginKey, editor } = props;
-      editor.unregisterPlugin(pluginKey);
     });
-    return () => {
-      var _a;
-      return h(Teleport, { to: "body" }, h("div", { ref: root }, (_a = slots.default) == null ? void 0 : _a.call(slots)));
-    };
   }
-});
+}
 export {
-  BubbleMenu2 as BubbleMenu,
-  FloatingMenu2 as FloatingMenu
+  useVModel as a,
+  useEventListener as b,
+  useDropZone as c,
+  defaultDocument as d,
+  useMediaQuery as u
 };