@bagelink/vue 0.0.398 → 0.0.400

package/dist/index.cjs

@@ -317,7 +317,7 @@ async function detectOverflow$1(state2, options) {
     right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
   };
 }
-const arrow$3 = (options) => ({
+const arrow$4 = (options) => ({
   name: "arrow",
   options,
   async fn(state2) {
@@ -1508,7 +1508,7 @@ const q = "__floating-vue__popper", Q = () => vue.defineComponent({
       })), !t && this.flip && e.middleware.push(flip$2({
         padding: this.overflowPadding,
         boundary: this.boundary
-      }))), e.middleware.push(arrow$3({
+      }))), e.middleware.push(arrow$4({
         element: this.$_arrowNode,
         padding: this.arrowPadding
       })), this.arrowOverflow && e.middleware.push({
@@ -17945,7 +17945,7 @@ const _sfc_main$g = /* @__PURE__ */ vue.defineComponent({
       rows[index2][fieldname] = value;
       emits("update:modelValue", rows);
     }
-    function addRow() {
+    function addRow2() {
       const rows = [...props2.modelValue];
       const entry = {
         idx: rows.length
@@ -17962,7 +17962,7 @@ const _sfc_main$g = /* @__PURE__ */ vue.defineComponent({
       rows.push(entry);
       emits("update:modelValue", rows);
     }
-    function removeRow(idx) {
+    function removeRow2(idx) {
       const rows = [...props2.modelValue];
       rows.splice(idx, 1);
       emits("update:modelValue", rows);
@@ -18034,7 +18034,7 @@ const _sfc_main$g = /* @__PURE__ */ vue.defineComponent({
                       vue.createElementVNode("div", _hoisted_6$4, [
                         vue.createVNode(vue.unref(_sfc_main$H), {
                           icon: "delete",
-                          onClick: ($event) => removeRow(index2)
+                          onClick: ($event) => removeRow2(index2)
                         }, null, 8, ["onClick"])
                       ])
                     ]);
@@ -18051,7 +18051,7 @@ const _sfc_main$g = /* @__PURE__ */ vue.defineComponent({
           flat: "",
           icon: "add",
           color: "light",
-          onClick: addRow
+          onClick: addRow2
         }, {
           default: vue.withCtx(() => [
             vue.createTextVNode(" New ")
@@ -27413,7 +27413,7 @@ function handleSingleClick(view, pos, inside, event, selectNode) {
 function handleDoubleClick(view, pos, inside, event) {
   return runHandlerOnContext(view, "handleDoubleClickOn", pos, inside, event) || view.someProp("handleDoubleClick", (f2) => f2(view, pos, event));
 }
-function handleTripleClick(view, pos, inside, event) {
+function handleTripleClick$1(view, pos, inside, event) {
   return runHandlerOnContext(view, "handleTripleClickOn", pos, inside, event) || view.someProp("handleTripleClick", (f2) => f2(view, pos, event)) || defaultTripleClick(view, inside, event);
 }
 function defaultTripleClick(view, inside, event) {
@@ -27463,7 +27463,7 @@ handlers.mousedown = (view, _event) => {
     if (view.input.mouseDown)
       view.input.mouseDown.done();
     view.input.mouseDown = new MouseDown(view, pos, event, !!flushed);
-  } else if ((type3 == "doubleClick" ? handleDoubleClick : handleTripleClick)(view, pos.pos, pos.inside, event)) {
+  } else if ((type3 == "doubleClick" ? handleDoubleClick : handleTripleClick$1)(view, pos.pos, pos.inside, event)) {
     event.preventDefault();
   } else {
     setSelectionOrigin(view, "pointer");
@@ -32974,8 +32974,8 @@ const Keymap = Extension.create({
           if (empty2 || !allWasSelected) {
             return;
           }
-          const isEmpty = newState.doc.textBetween(0, newState.doc.content.size, " ", " ").length === 0;
-          if (!isEmpty) {
+          const isEmpty2 = newState.doc.textBetween(0, newState.doc.content.size, " ", " ").length === 0;
+          if (!isEmpty2) {
             return;
           }
           const tr2 = newState.tr;
@@ -34711,18 +34711,18 @@ function gapCursor() {
         return $anchor.pos == $head.pos && GapCursor.valid($head) ? new GapCursor($head) : null;
       },
       handleClick,
-      handleKeyDown,
+      handleKeyDown: handleKeyDown$1,
       handleDOMEvents: { beforeinput }
     }
   });
 }
-const handleKeyDown = keydownHandler({
-  "ArrowLeft": arrow$2("horiz", -1),
-  "ArrowRight": arrow$2("horiz", 1),
-  "ArrowUp": arrow$2("vert", -1),
-  "ArrowDown": arrow$2("vert", 1)
+const handleKeyDown$1 = keydownHandler({
+  "ArrowLeft": arrow$3("horiz", -1),
+  "ArrowRight": arrow$3("horiz", 1),
+  "ArrowUp": arrow$3("vert", -1),
+  "ArrowDown": arrow$3("vert", 1)
 });
-function arrow$2(axis2, dir) {
+function arrow$3(axis2, dir) {
   const dirStr = axis2 == "vert" ? dir > 0 ? "down" : "up" : dir > 0 ? "right" : "left";
   return function(state2, dispatch, view) {
     let sel = state2.selection;
@@ -36255,7 +36255,7 @@ var toPaddingObject = function toPaddingObject2(padding, state2) {
   })) : padding;
   return mergePaddingObject(typeof padding !== "number" ? padding : expandToHashMap(padding, basePlacements));
 };
-function arrow(_ref) {
+function arrow$1(_ref) {
   var _state$modifiersData$;
   var state2 = _ref.state, name = _ref.name, options = _ref.options;
   var arrowElement = state2.elements.arrow;
@@ -36300,11 +36300,11 @@ function effect$1(_ref2) {
   }
   state2.elements.arrow = arrowElement;
 }
-const arrow$1 = {
+const arrow$2 = {
   name: "arrow",
   enabled: true,
   phase: "main",
-  fn: arrow,
+  fn: arrow$1,
   effect: effect$1,
   requires: ["popperOffsets"],
   requiresIfExists: ["preventOverflow"]
@@ -37296,7 +37296,7 @@ function popperGenerator(generatorOptions) {
     return instance;
   };
 }
-var defaultModifiers = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1, offset$1, flip$1, preventOverflow$1, arrow$1, hide$1];
+var defaultModifiers = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1, offset$1, flip$1, preventOverflow$1, arrow$2, hide$1];
 var createPopper = /* @__PURE__ */ popperGenerator({
   defaultModifiers
 });
@@ -39442,6 +39442,2633 @@ const Youtube = Node$2.create({
     ];
   }
 });
+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 i2 = 0; i2 < cache.length; i2 += 2)
+      if (cache[i2] == key)
+        return cache[i2 + 1];
+  };
+  addToCache = (key, value) => {
+    if (cachePos == cacheSize)
+      cachePos = 0;
+    cache[cachePos++] = key;
+    return cache[cachePos++] = value;
+  };
+}
+var TableMap = class {
+  constructor(width, height, map4, problems) {
+    this.width = width;
+    this.height = height;
+    this.map = map4;
+    this.problems = problems;
+  }
+  // Find the dimensions of the cell at the given position.
+  findCell(pos) {
+    for (let i2 = 0; i2 < this.map.length; i2++) {
+      const curPos = this.map[i2];
+      if (curPos != pos)
+        continue;
+      const left2 = i2 % this.width;
+      const top2 = i2 / this.width | 0;
+      let right2 = left2 + 1;
+      let bottom2 = top2 + 1;
+      for (let j = 1; right2 < this.width && this.map[i2 + j] == curPos; j++) {
+        right2++;
+      }
+      for (let j = 1; bottom2 < this.height && this.map[i2 + this.width * j] == curPos; j++) {
+        bottom2++;
+      }
+      return { left: left2, top: top2, right: right2, bottom: bottom2 };
+    }
+    throw new RangeError(`No cell with offset ${pos} found`);
+  }
+  // Find the left side of the cell at the given position.
+  colCount(pos) {
+    for (let i2 = 0; i2 < this.map.length; i2++) {
+      if (this.map[i2] == pos) {
+        return i2 % 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, axis2, dir) {
+    const { left: left2, right: right2, top: top2, bottom: bottom2 } = this.findCell(pos);
+    if (axis2 == "horiz") {
+      if (dir < 0 ? left2 == 0 : right2 == this.width)
+        return null;
+      return this.map[top2 * this.width + (dir < 0 ? left2 - 1 : right2)];
+    } else {
+      if (dir < 0 ? top2 == 0 : bottom2 == this.height)
+        return null;
+      return this.map[left2 + this.width * (dir < 0 ? top2 - 1 : bottom2)];
+    }
+  }
+  // Get the rectangle spanning the two given cells.
+  rectBetween(a2, b2) {
+    const {
+      left: leftA,
+      right: rightA,
+      top: topA,
+      bottom: bottomA
+    } = this.findCell(a2);
+    const {
+      left: leftB,
+      right: rightB,
+      top: topB,
+      bottom: bottomB
+    } = this.findCell(b2);
+    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 i2 = 0, rowStart = 0; ; i2++) {
+      const rowEnd = rowStart + table.child(i2).nodeSize;
+      if (i2 == 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 map4 = [];
+  let mapPos = 0;
+  let problems = null;
+  const colWidths = [];
+  for (let i2 = 0, e = width * height; i2 < e; i2++)
+    map4[i2] = 0;
+  for (let row = 0, pos = 0; row < height; row++) {
+    const rowNode = table.child(row);
+    pos++;
+    for (let i2 = 0; ; i2++) {
+      while (mapPos < map4.length && map4[mapPos] != 0)
+        mapPos++;
+      if (i2 == rowNode.childCount)
+        break;
+      const cellNode = rowNode.child(i2);
+      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 start2 = mapPos + h2 * width;
+        for (let w2 = 0; w2 < colspan; w2++) {
+          if (map4[start2 + w2] == 0)
+            map4[start2 + w2] = pos;
+          else
+            (problems || (problems = [])).push({
+              type: "collision",
+              row,
+              pos,
+              n: colspan - w2
+            });
+          const colW = colwidth && colwidth[w2];
+          if (colW) {
+            const widthIndex = (start2 + w2) % 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 (map4[mapPos++] == 0)
+        missing++;
+    if (missing)
+      (problems || (problems = [])).push({ type: "missing", row, n: missing });
+    pos++;
+  }
+  const tableMap = new TableMap(width, height, map4, problems);
+  let badWidths = false;
+  for (let i2 = 0; !badWidths && i2 < colWidths.length; i2 += 2)
+    if (colWidths[i2] != null && colWidths[i2 + 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 i2 = 0; i2 < prevRow.childCount; i2++) {
+          const cell = prevRow.child(i2);
+          if (j + cell.attrs.rowspan > row)
+            rowWidth += cell.attrs.colspan;
+        }
+      }
+    for (let i2 = 0; i2 < rowNode.childCount; i2++) {
+      const cell = rowNode.child(i2);
+      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(map4, colWidths, table) {
+  if (!map4.problems)
+    map4.problems = [];
+  const seen = {};
+  for (let i2 = 0; i2 < map4.map.length; i2++) {
+    const pos = map4.map[i2];
+    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 = (i2 + j) % map4.width;
+      const colWidth = colWidths[col * 2];
+      if (colWidth != null && (!attrs.colwidth || attrs.colwidth[j] != colWidth))
+        (updated || (updated = freshColWidth(attrs)))[j] = colWidth;
+    }
+    if (updated)
+      map4.problems.unshift({
+        type: "colwidth mismatch",
+        pos,
+        colwidth: updated
+      });
+  }
+}
+function freshColWidth(attrs) {
+  if (attrs.colwidth)
+    return attrs.colwidth.slice();
+  const result = [];
+  for (let i2 = 0; i2 < attrs.colspan; i2++)
+    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 type3 = schema.nodes[name], role = type3.spec.tableRole;
+      if (role)
+        result[role] = type3;
+    }
+  }
+  return result;
+}
+var tableEditingKey = new PluginKey("selectingCells");
+function cellAround($pos) {
+  for (let d2 = $pos.depth - 1; d2 > 0; d2--)
+    if ($pos.node(d2).type.spec.tableRole == "row")
+      return $pos.node(0).resolve($pos.before(d2 + 1));
+  return null;
+}
+function cellWrapping($pos) {
+  for (let d2 = $pos.depth; d2 > 0; d2--) {
+    const role = $pos.node(d2).type.spec.tableRole;
+    if (role === "cell" || role === "header_cell")
+      return $pos.node(d2);
+  }
+  return null;
+}
+function isInTable(state2) {
+  const $head = state2.selection.$head;
+  for (let d2 = $head.depth; d2 > 0; d2--)
+    if ($head.node(d2).type.spec.tableRole == "row")
+      return true;
+  return false;
+}
+function selectionCell(state2) {
+  const sel = state2.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 moveCellForward($pos) {
+  return $pos.node(0).resolve($pos.pos + $pos.nodeAfter.nodeSize);
+}
+function inSameTable($cellA, $cellB) {
+  return $cellA.depth == $cellB.depth && $cellA.pos >= $cellB.start(-1) && $cellA.pos <= $cellB.end(-1);
+}
+function nextCell($pos, axis2, dir) {
+  const table = $pos.node(-1);
+  const map4 = TableMap.get(table);
+  const tableStart = $pos.start(-1);
+  const moved2 = map4.nextCell($pos.pos - tableStart, axis2, dir);
+  return moved2 == null ? null : $pos.node(0).resolve(tableStart + moved2);
+}
+function removeColSpan(attrs, pos, n2 = 1) {
+  const result = { ...attrs, colspan: attrs.colspan - n2 };
+  if (result.colwidth) {
+    result.colwidth = result.colwidth.slice();
+    result.colwidth.splice(pos, n2);
+    if (!result.colwidth.some((w2) => w2 > 0))
+      result.colwidth = null;
+  }
+  return result;
+}
+function addColSpan(attrs, pos, n2 = 1) {
+  const result = { ...attrs, colspan: attrs.colspan + n2 };
+  if (result.colwidth) {
+    result.colwidth = result.colwidth.slice();
+    for (let i2 = 0; i2 < n2; i2++)
+      result.colwidth.splice(pos, 0, 0);
+  }
+  return result;
+}
+function columnIsHeader(map4, table, col) {
+  const headerCell = tableNodeTypes(table.type.schema).header_cell;
+  for (let row = 0; row < map4.height; row++)
+    if (table.nodeAt(map4.map[col + row * map4.width]).type != headerCell)
+      return false;
+  return true;
+}
+var CellSelection = class _CellSelection extends Selection$1 {
+  // 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 map4 = TableMap.get(table);
+    const tableStart = $anchorCell.start(-1);
+    const rect = map4.rectBetween(
+      $anchorCell.pos - tableStart,
+      $headCell.pos - tableStart
+    );
+    const doc2 = $anchorCell.node(0);
+    const cells = map4.cellsInRect(rect).filter((p2) => p2 != $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 from2 = tableStart + pos + 1;
+      return new SelectionRange(
+        doc2.resolve(from2),
+        doc2.resolve(from2 + cell.content.size)
+      );
+    });
+    super(ranges[0].$from, ranges[0].$to, ranges);
+    this.$anchorCell = $anchorCell;
+    this.$headCell = $headCell;
+  }
+  map(doc2, mapping) {
+    const $anchorCell = doc2.resolve(mapping.map(this.$anchorCell.pos));
+    const $headCell = doc2.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 map4 = TableMap.get(table);
+    const tableStart = this.$anchorCell.start(-1);
+    const rect = map4.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 * map4.width + rect.left, col = rect.left; col < rect.right; col++, index2++) {
+        const pos = map4.map[index2];
+        if (seen[pos])
+          continue;
+        seen[pos] = true;
+        const cellRect = map4.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(tr2, content = Slice.empty) {
+    const mapFrom = tr2.steps.length, ranges = this.ranges;
+    for (let i2 = 0; i2 < ranges.length; i2++) {
+      const { $from, $to } = ranges[i2], mapping = tr2.mapping.slice(mapFrom);
+      tr2.replace(
+        mapping.map($from.pos),
+        mapping.map($to.pos),
+        i2 ? Slice.empty : content
+      );
+    }
+    const sel = Selection$1.findFrom(
+      tr2.doc.resolve(tr2.mapping.slice(mapFrom).map(this.to)),
+      -1
+    );
+    if (sel)
+      tr2.setSelection(sel);
+  }
+  replaceWith(tr2, node) {
+    this.replace(tr2, new Slice(Fragment.from(node), 0, 0));
+  }
+  forEachCell(f2) {
+    const table = this.$anchorCell.node(-1);
+    const map4 = TableMap.get(table);
+    const tableStart = this.$anchorCell.start(-1);
+    const cells = map4.cellsInRect(
+      map4.rectBetween(
+        this.$anchorCell.pos - tableStart,
+        this.$headCell.pos - tableStart
+      )
+    );
+    for (let i2 = 0; i2 < cells.length; i2++) {
+      f2(table.nodeAt(cells[i2]), tableStart + cells[i2]);
+    }
+  }
+  // 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 map4 = TableMap.get(table);
+    const tableStart = $anchorCell.start(-1);
+    const anchorRect = map4.findCell($anchorCell.pos - tableStart);
+    const headRect = map4.findCell($headCell.pos - tableStart);
+    const doc2 = $anchorCell.node(0);
+    if (anchorRect.top <= headRect.top) {
+      if (anchorRect.top > 0)
+        $anchorCell = doc2.resolve(tableStart + map4.map[anchorRect.left]);
+      if (headRect.bottom < map4.height)
+        $headCell = doc2.resolve(
+          tableStart + map4.map[map4.width * (map4.height - 1) + headRect.right - 1]
+        );
+    } else {
+      if (headRect.top > 0)
+        $headCell = doc2.resolve(tableStart + map4.map[headRect.left]);
+      if (anchorRect.bottom < map4.height)
+        $anchorCell = doc2.resolve(
+          tableStart + map4.map[map4.width * (map4.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 map4 = TableMap.get(table);
+    const tableStart = this.$anchorCell.start(-1);
+    const anchorLeft = map4.colCount(this.$anchorCell.pos - tableStart);
+    const headLeft = map4.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) == map4.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 map4 = TableMap.get(table);
+    const tableStart = $anchorCell.start(-1);
+    const anchorRect = map4.findCell($anchorCell.pos - tableStart);
+    const headRect = map4.findCell($headCell.pos - tableStart);
+    const doc2 = $anchorCell.node(0);
+    if (anchorRect.left <= headRect.left) {
+      if (anchorRect.left > 0)
+        $anchorCell = doc2.resolve(
+          tableStart + map4.map[anchorRect.top * map4.width]
+        );
+      if (headRect.right < map4.width)
+        $headCell = doc2.resolve(
+          tableStart + map4.map[map4.width * (headRect.top + 1) - 1]
+        );
+    } else {
+      if (headRect.left > 0)
+        $headCell = doc2.resolve(tableStart + map4.map[headRect.top * map4.width]);
+      if (anchorRect.right < map4.width)
+        $anchorCell = doc2.resolve(
+          tableStart + map4.map[map4.width * (anchorRect.top + 1) - 1]
+        );
+    }
+    return new _CellSelection($anchorCell, $headCell);
+  }
+  toJSON() {
+    return {
+      type: "cell",
+      anchor: this.$anchorCell.pos,
+      head: this.$headCell.pos
+    };
+  }
+  static fromJSON(doc2, json) {
+    return new _CellSelection(doc2.resolve(json.anchor), doc2.resolve(json.head));
+  }
+  static create(doc2, anchorCell, headCell = anchorCell) {
+    return new _CellSelection(doc2.resolve(anchorCell), doc2.resolve(headCell));
+  }
+  getBookmark() {
+    return new CellBookmark(this.$anchorCell.pos, this.$headCell.pos);
+  }
+};
+CellSelection.prototype.visible = false;
+Selection$1.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(doc2) {
+    const $anchorCell = doc2.resolve(this.anchor), $headCell = doc2.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$1.near($headCell, 1);
+  }
+};
+function drawCellSelection(state2) {
+  if (!(state2.selection instanceof CellSelection))
+    return null;
+  const cells = [];
+  state2.selection.forEachCell((node, pos) => {
+    cells.push(
+      Decoration.node(pos, pos + node.nodeSize, { class: "selectedCell" })
+    );
+  });
+  return DecorationSet.create(state2.doc, cells);
+}
+function isCellBoundarySelection({ $from, $to }) {
+  if ($from.pos == $to.pos || $from.pos < $from.pos - 6)
+    return false;
+  let afterFrom = $from.pos;
+  let beforeTo = $to.pos;
+  let depth = $from.depth;
+  for (; depth >= 0; depth--, afterFrom++)
+    if ($from.after(depth + 1) < $from.end(depth))
+      break;
+  for (let d2 = $to.depth; d2 >= 0; d2--, beforeTo--)
+    if ($to.before(d2 + 1) > $to.start(d2))
+      break;
+  return afterFrom == beforeTo && /row|table/.test($from.node(depth).type.spec.tableRole);
+}
+function isTextSelectionAcrossCells({ $from, $to }) {
+  let fromCellBoundaryNode;
+  let toCellBoundaryNode;
+  for (let i2 = $from.depth; i2 > 0; i2--) {
+    const node = $from.node(i2);
+    if (node.type.spec.tableRole === "cell" || node.type.spec.tableRole === "header_cell") {
+      fromCellBoundaryNode = node;
+      break;
+    }
+  }
+  for (let i2 = $to.depth; i2 > 0; i2--) {
+    const node = $to.node(i2);
+    if (node.type.spec.tableRole === "cell" || node.type.spec.tableRole === "header_cell") {
+      toCellBoundaryNode = node;
+      break;
+    }
+  }
+  return fromCellBoundaryNode !== toCellBoundaryNode && $to.parentOffset === 0;
+}
+function normalizeSelection(state2, tr2, allowTableNodeSelection) {
+  const sel = (tr2 || state2).selection;
+  const doc2 = (tr2 || state2).doc;
+  let normalize2;
+  let role;
+  if (sel instanceof NodeSelection && (role = sel.node.type.spec.tableRole)) {
+    if (role == "cell" || role == "header_cell") {
+      normalize2 = CellSelection.create(doc2, sel.from);
+    } else if (role == "row") {
+      const $cell = doc2.resolve(sel.from + 1);
+      normalize2 = CellSelection.rowSelection($cell, $cell);
+    } else if (!allowTableNodeSelection) {
+      const map4 = TableMap.get(sel.node);
+      const start2 = sel.from + 1;
+      const lastCell = start2 + map4.map[map4.width * map4.height - 1];
+      normalize2 = CellSelection.create(doc2, start2 + 1, lastCell);
+    }
+  } else if (sel instanceof TextSelection && isCellBoundarySelection(sel)) {
+    normalize2 = TextSelection.create(doc2, sel.from);
+  } else if (sel instanceof TextSelection && isTextSelectionAcrossCells(sel)) {
+    normalize2 = TextSelection.create(doc2, sel.$from.start(), sel.$from.end());
+  }
+  if (normalize2)
+    (tr2 || (tr2 = state2.tr)).setSelection(normalize2);
+  return tr2;
+}
+var fixTablesKey = new PluginKey("fix-tables");
+function changedDescendants(old, cur, offset2, f2) {
+  const oldSize = old.childCount, curSize = cur.childCount;
+  outer:
+    for (let i2 = 0, j = 0; i2 < curSize; i2++) {
+      const child = cur.child(i2);
+      for (let scan = j, e = Math.min(oldSize, i2 + 3); scan < e; scan++) {
+        if (old.child(scan) == child) {
+          j = scan + 1;
+          offset2 += child.nodeSize;
+          continue outer;
+        }
+      }
+      f2(child, offset2);
+      if (j < oldSize && old.child(j).sameMarkup(child))
+        changedDescendants(old.child(j), child, offset2 + 1, f2);
+      else
+        child.nodesBetween(0, child.content.size, f2, offset2 + 1);
+      offset2 += child.nodeSize;
+    }
+}
+function fixTables(state2, oldState) {
+  let tr2;
+  const check = (node, pos) => {
+    if (node.type.spec.tableRole == "table")
+      tr2 = fixTable(state2, node, pos, tr2);
+  };
+  if (!oldState)
+    state2.doc.descendants(check);
+  else if (oldState.doc != state2.doc)
+    changedDescendants(oldState.doc, state2.doc, 0, check);
+  return tr2;
+}
+function fixTable(state2, table, tablePos, tr2) {
+  const map4 = TableMap.get(table);
+  if (!map4.problems)
+    return tr2;
+  if (!tr2)
+    tr2 = state2.tr;
+  const mustAdd = [];
+  for (let i2 = 0; i2 < map4.height; i2++)
+    mustAdd.push(0);
+  for (let i2 = 0; i2 < map4.problems.length; i2++) {
+    const prob = map4.problems[i2];
+    if (prob.type == "collision") {
+      const cell = table.nodeAt(prob.pos);
+      if (!cell)
+        continue;
+      const attrs = cell.attrs;
+      for (let j = 0; j < attrs.rowspan; j++)
+        mustAdd[prob.row + j] += prob.n;
+      tr2.setNodeMarkup(
+        tr2.mapping.map(tablePos + 1 + prob.pos),
+        null,
+        removeColSpan(attrs, attrs.colspan - prob.n, prob.n)
+      );
+    } else if (prob.type == "missing") {
+      mustAdd[prob.row] += prob.n;
+    } else if (prob.type == "overlong_rowspan") {
+      const cell = table.nodeAt(prob.pos);
+      if (!cell)
+        continue;
+      tr2.setNodeMarkup(tr2.mapping.map(tablePos + 1 + prob.pos), null, {
+        ...cell.attrs,
+        rowspan: cell.attrs.rowspan - prob.n
+      });
+    } else if (prob.type == "colwidth mismatch") {
+      const cell = table.nodeAt(prob.pos);
+      if (!cell)
+        continue;
+      tr2.setNodeMarkup(tr2.mapping.map(tablePos + 1 + prob.pos), null, {
+        ...cell.attrs,
+        colwidth: prob.colwidth
+      });
+    }
+  }
+  let first2, last;
+  for (let i2 = 0; i2 < mustAdd.length; i2++)
+    if (mustAdd[i2]) {
+      if (first2 == null)
+        first2 = i2;
+      last = i2;
+    }
+  for (let i2 = 0, pos = tablePos + 1; i2 < map4.height; i2++) {
+    const row = table.child(i2);
+    const end2 = pos + row.nodeSize;
+    const add2 = mustAdd[i2];
+    if (add2 > 0) {
+      let role = "cell";
+      if (row.firstChild) {
+        role = row.firstChild.type.spec.tableRole;
+      }
+      const nodes = [];
+      for (let j = 0; j < add2; j++) {
+        const node = tableNodeTypes(state2.schema)[role].createAndFill();
+        if (node)
+          nodes.push(node);
+      }
+      const side = (i2 == 0 || first2 == i2 - 1) && last == i2 ? pos + 1 : end2 - 1;
+      tr2.insert(tr2.mapping.map(side), nodes);
+    }
+    pos = end2;
+  }
+  return tr2.setMeta(fixTablesKey, { fixTables: true });
+}
+function pastedCells(slice4) {
+  if (!slice4.size)
+    return null;
+  let { content, openStart, openEnd } = slice4;
+  while (content.childCount == 1 && (openStart > 0 && openEnd > 0 || content.child(0).type.spec.tableRole == "table")) {
+    openStart--;
+    openEnd--;
+    content = content.child(0).content;
+  }
+  const first2 = content.child(0);
+  const role = first2.type.spec.tableRole;
+  const schema = first2.type.schema, rows = [];
+  if (role == "row") {
+    for (let i2 = 0; i2 < content.childCount; i2++) {
+      let cells = content.child(i2).content;
+      const left2 = i2 ? 0 : Math.max(0, openStart - 1);
+      const right2 = i2 < content.childCount - 1 ? 0 : Math.max(0, openEnd - 1);
+      if (left2 || right2)
+        cells = fitSlice(
+          tableNodeTypes(schema).row,
+          new Slice(cells, left2, right2)
+        ).content;
+      rows.push(cells);
+    }
+  } else if (role == "cell" || role == "header_cell") {
+    rows.push(
+      openStart || openEnd ? fitSlice(
+        tableNodeTypes(schema).row,
+        new Slice(content, openStart, openEnd)
+      ).content : content
+    );
+  } else {
+    return null;
+  }
+  return ensureRectangular(schema, rows);
+}
+function ensureRectangular(schema, rows) {
+  const widths = [];
+  for (let i2 = 0; i2 < rows.length; i2++) {
+    const row = rows[i2];
+    for (let j = row.childCount - 1; j >= 0; j--) {
+      const { rowspan, colspan } = row.child(j).attrs;
+      for (let r2 = i2; r2 < i2 + rowspan; r2++)
+        widths[r2] = (widths[r2] || 0) + colspan;
+    }
+  }
+  let width = 0;
+  for (let r2 = 0; r2 < widths.length; r2++)
+    width = Math.max(width, widths[r2]);
+  for (let r2 = 0; r2 < widths.length; r2++) {
+    if (r2 >= rows.length)
+      rows.push(Fragment.empty);
+    if (widths[r2] < width) {
+      const empty2 = tableNodeTypes(schema).cell.createAndFill();
+      const cells = [];
+      for (let i2 = widths[r2]; i2 < width; i2++) {
+        cells.push(empty2);
+      }
+      rows[r2] = rows[r2].append(Fragment.from(cells));
+    }
+  }
+  return { height: rows.length, width, rows };
+}
+function fitSlice(nodeType, slice4) {
+  const node = nodeType.createAndFill();
+  const tr2 = new Transform(node).replace(0, node.content.size, slice4);
+  return tr2.doc;
+}
+function clipCells({ width, height, rows }, newWidth, newHeight) {
+  if (width != newWidth) {
+    const added = [];
+    const newRows = [];
+    for (let row = 0; row < rows.length; row++) {
+      const frag = rows[row], cells = [];
+      for (let col = added[row] || 0, i2 = 0; col < newWidth; i2++) {
+        let cell = frag.child(i2 % frag.childCount);
+        if (col + cell.attrs.colspan > newWidth)
+          cell = cell.type.createChecked(
+            removeColSpan(
+              cell.attrs,
+              cell.attrs.colspan,
+              col + cell.attrs.colspan - newWidth
+            ),
+            cell.content
+          );
+        cells.push(cell);
+        col += cell.attrs.colspan;
+        for (let j = 1; j < cell.attrs.rowspan; j++)
+          added[row + j] = (added[row + j] || 0) + cell.attrs.colspan;
+      }
+      newRows.push(Fragment.from(cells));
+    }
+    rows = newRows;
+    width = newWidth;
+  }
+  if (height != newHeight) {
+    const newRows = [];
+    for (let row = 0, i2 = 0; row < newHeight; row++, i2++) {
+      const cells = [], source = rows[i2 % height];
+      for (let j = 0; j < source.childCount; j++) {
+        let cell = source.child(j);
+        if (row + cell.attrs.rowspan > newHeight)
+          cell = cell.type.create(
+            {
+              ...cell.attrs,
+              rowspan: Math.max(1, newHeight - cell.attrs.rowspan)
+            },
+            cell.content
+          );
+        cells.push(cell);
+      }
+      newRows.push(Fragment.from(cells));
+    }
+    rows = newRows;
+    height = newHeight;
+  }
+  return { width, height, rows };
+}
+function growTable(tr2, map4, table, start2, width, height, mapFrom) {
+  const schema = tr2.doc.type.schema;
+  const types = tableNodeTypes(schema);
+  let empty2;
+  let emptyHead;
+  if (width > map4.width) {
+    for (let row = 0, rowEnd = 0; row < map4.height; row++) {
+      const rowNode = table.child(row);
+      rowEnd += rowNode.nodeSize;
+      const cells = [];
+      let add2;
+      if (rowNode.lastChild == null || rowNode.lastChild.type == types.cell)
+        add2 = empty2 || (empty2 = types.cell.createAndFill());
+      else
+        add2 = emptyHead || (emptyHead = types.header_cell.createAndFill());
+      for (let i2 = map4.width; i2 < width; i2++)
+        cells.push(add2);
+      tr2.insert(tr2.mapping.slice(mapFrom).map(rowEnd - 1 + start2), cells);
+    }
+  }
+  if (height > map4.height) {
+    const cells = [];
+    for (let i2 = 0, start22 = (map4.height - 1) * map4.width; i2 < Math.max(map4.width, width); i2++) {
+      const header = i2 >= map4.width ? false : table.nodeAt(map4.map[start22 + i2]).type == types.header_cell;
+      cells.push(
+        header ? emptyHead || (emptyHead = types.header_cell.createAndFill()) : empty2 || (empty2 = types.cell.createAndFill())
+      );
+    }
+    const emptyRow = types.row.create(null, Fragment.from(cells)), rows = [];
+    for (let i2 = map4.height; i2 < height; i2++)
+      rows.push(emptyRow);
+    tr2.insert(tr2.mapping.slice(mapFrom).map(start2 + table.nodeSize - 2), rows);
+  }
+  return !!(empty2 || emptyHead);
+}
+function isolateHorizontal(tr2, map4, table, start2, left2, right2, top2, mapFrom) {
+  if (top2 == 0 || top2 == map4.height)
+    return false;
+  let found2 = false;
+  for (let col = left2; col < right2; col++) {
+    const index2 = top2 * map4.width + col, pos = map4.map[index2];
+    if (map4.map[index2 - map4.width] == pos) {
+      found2 = true;
+      const cell = table.nodeAt(pos);
+      const { top: cellTop, left: cellLeft } = map4.findCell(pos);
+      tr2.setNodeMarkup(tr2.mapping.slice(mapFrom).map(pos + start2), null, {
+        ...cell.attrs,
+        rowspan: top2 - cellTop
+      });
+      tr2.insert(
+        tr2.mapping.slice(mapFrom).map(map4.positionAt(top2, cellLeft, table)),
+        cell.type.createAndFill({
+          ...cell.attrs,
+          rowspan: cellTop + cell.attrs.rowspan - top2
+        })
+      );
+      col += cell.attrs.colspan - 1;
+    }
+  }
+  return found2;
+}
+function isolateVertical(tr2, map4, table, start2, top2, bottom2, left2, mapFrom) {
+  if (left2 == 0 || left2 == map4.width)
+    return false;
+  let found2 = false;
+  for (let row = top2; row < bottom2; row++) {
+    const index2 = row * map4.width + left2, pos = map4.map[index2];
+    if (map4.map[index2 - 1] == pos) {
+      found2 = true;
+      const cell = table.nodeAt(pos);
+      const cellLeft = map4.colCount(pos);
+      const updatePos = tr2.mapping.slice(mapFrom).map(pos + start2);
+      tr2.setNodeMarkup(
+        updatePos,
+        null,
+        removeColSpan(
+          cell.attrs,
+          left2 - cellLeft,
+          cell.attrs.colspan - (left2 - cellLeft)
+        )
+      );
+      tr2.insert(
+        updatePos + cell.nodeSize,
+        cell.type.createAndFill(
+          removeColSpan(cell.attrs, 0, left2 - cellLeft)
+        )
+      );
+      row += cell.attrs.rowspan - 1;
+    }
+  }
+  return found2;
+}
+function insertCells(state2, dispatch, tableStart, rect, cells) {
+  let table = tableStart ? state2.doc.nodeAt(tableStart - 1) : state2.doc;
+  if (!table) {
+    throw new Error("No table found");
+  }
+  let map4 = TableMap.get(table);
+  const { top: top2, left: left2 } = rect;
+  const right2 = left2 + cells.width, bottom2 = top2 + cells.height;
+  const tr2 = state2.tr;
+  let mapFrom = 0;
+  function recomp() {
+    table = tableStart ? tr2.doc.nodeAt(tableStart - 1) : tr2.doc;
+    if (!table) {
+      throw new Error("No table found");
+    }
+    map4 = TableMap.get(table);
+    mapFrom = tr2.mapping.maps.length;
+  }
+  if (growTable(tr2, map4, table, tableStart, right2, bottom2, mapFrom))
+    recomp();
+  if (isolateHorizontal(tr2, map4, table, tableStart, left2, right2, top2, mapFrom))
+    recomp();
+  if (isolateHorizontal(tr2, map4, table, tableStart, left2, right2, bottom2, mapFrom))
+    recomp();
+  if (isolateVertical(tr2, map4, table, tableStart, top2, bottom2, left2, mapFrom))
+    recomp();
+  if (isolateVertical(tr2, map4, table, tableStart, top2, bottom2, right2, mapFrom))
+    recomp();
+  for (let row = top2; row < bottom2; row++) {
+    const from2 = map4.positionAt(row, left2, table), to2 = map4.positionAt(row, right2, table);
+    tr2.replace(
+      tr2.mapping.slice(mapFrom).map(from2 + tableStart),
+      tr2.mapping.slice(mapFrom).map(to2 + tableStart),
+      new Slice(cells.rows[row - top2], 0, 0)
+    );
+  }
+  recomp();
+  tr2.setSelection(
+    new CellSelection(
+      tr2.doc.resolve(tableStart + map4.positionAt(top2, left2, table)),
+      tr2.doc.resolve(tableStart + map4.positionAt(bottom2 - 1, right2 - 1, table))
+    )
+  );
+  dispatch(tr2);
+}
+var handleKeyDown = 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(state2, dispatch, selection) {
+  if (selection.eq(state2.selection))
+    return false;
+  if (dispatch)
+    dispatch(state2.tr.setSelection(selection).scrollIntoView());
+  return true;
+}
+function arrow(axis2, dir) {
+  return (state2, dispatch, view) => {
+    if (!view)
+      return false;
+    const sel = state2.selection;
+    if (sel instanceof CellSelection) {
+      return maybeSetSelection(
+        state2,
+        dispatch,
+        Selection$1.near(sel.$headCell, dir)
+      );
+    }
+    if (axis2 != "horiz" && !sel.empty)
+      return false;
+    const end2 = atEndOfCell(view, axis2, dir);
+    if (end2 == null)
+      return false;
+    if (axis2 == "horiz") {
+      return maybeSetSelection(
+        state2,
+        dispatch,
+        Selection$1.near(state2.doc.resolve(sel.head + dir), dir)
+      );
+    } else {
+      const $cell = state2.doc.resolve(end2);
+      const $next = nextCell($cell, axis2, dir);
+      let newSel;
+      if ($next)
+        newSel = Selection$1.near($next, 1);
+      else if (dir < 0)
+        newSel = Selection$1.near(state2.doc.resolve($cell.before(-1)), -1);
+      else
+        newSel = Selection$1.near(state2.doc.resolve($cell.after(-1)), 1);
+      return maybeSetSelection(state2, dispatch, newSel);
+    }
+  };
+}
+function shiftArrow(axis2, dir) {
+  return (state2, dispatch, view) => {
+    if (!view)
+      return false;
+    const sel = state2.selection;
+    let cellSel;
+    if (sel instanceof CellSelection) {
+      cellSel = sel;
+    } else {
+      const end2 = atEndOfCell(view, axis2, dir);
+      if (end2 == null)
+        return false;
+      cellSel = new CellSelection(state2.doc.resolve(end2));
+    }
+    const $head = nextCell(cellSel.$headCell, axis2, dir);
+    if (!$head)
+      return false;
+    return maybeSetSelection(
+      state2,
+      dispatch,
+      new CellSelection(cellSel.$anchorCell, $head)
+    );
+  };
+}
+function deleteCellSelection(state2, dispatch) {
+  const sel = state2.selection;
+  if (!(sel instanceof CellSelection))
+    return false;
+  if (dispatch) {
+    const tr2 = state2.tr;
+    const baseContent = tableNodeTypes(state2.schema).cell.createAndFill().content;
+    sel.forEachCell((cell, pos) => {
+      if (!cell.content.eq(baseContent))
+        tr2.replace(
+          tr2.mapping.map(pos + 1),
+          tr2.mapping.map(pos + cell.nodeSize - 1),
+          new Slice(baseContent, 0, 0)
+        );
+    });
+    if (tr2.docChanged)
+      dispatch(tr2);
+  }
+  return true;
+}
+function handleTripleClick(view, pos) {
+  const doc2 = view.state.doc, $cell = cellAround(doc2.resolve(pos));
+  if (!$cell)
+    return false;
+  view.dispatch(view.state.tr.setSelection(new CellSelection($cell)));
+  return true;
+}
+function handlePaste(view, _2, slice4) {
+  if (!isInTable(view.state))
+    return false;
+  let cells = pastedCells(slice4);
+  const sel = view.state.selection;
+  if (sel instanceof CellSelection) {
+    if (!cells)
+      cells = {
+        width: 1,
+        height: 1,
+        rows: [
+          Fragment.from(
+            fitSlice(tableNodeTypes(view.state.schema).cell, slice4)
+          )
+        ]
+      };
+    const table = sel.$anchorCell.node(-1);
+    const start2 = sel.$anchorCell.start(-1);
+    const rect = TableMap.get(table).rectBetween(
+      sel.$anchorCell.pos - start2,
+      sel.$headCell.pos - start2
+    );
+    cells = clipCells(cells, rect.right - rect.left, rect.bottom - rect.top);
+    insertCells(view.state, view.dispatch, start2, rect, cells);
+    return true;
+  } else if (cells) {
+    const $cell = selectionCell(view.state);
+    const start2 = $cell.start(-1);
+    insertCells(
+      view.state,
+      view.dispatch,
+      start2,
+      TableMap.get($cell.node(-1)).findCell($cell.pos - start2),
+      cells
+    );
+    return true;
+  } else {
+    return false;
+  }
+}
+function handleMouseDown(view, startEvent) {
+  var _a2;
+  if (startEvent.ctrlKey || startEvent.metaKey)
+    return;
+  const startDOMCell = domInCell(view, startEvent.target);
+  let $anchor;
+  if (startEvent.shiftKey && view.state.selection instanceof CellSelection) {
+    setCellSelection(view.state.selection.$anchorCell, startEvent);
+    startEvent.preventDefault();
+  } else if (startEvent.shiftKey && startDOMCell && ($anchor = cellAround(view.state.selection.$anchor)) != null && ((_a2 = cellUnderMouse(view, startEvent)) == null ? void 0 : _a2.pos) != $anchor.pos) {
+    setCellSelection($anchor, startEvent);
+    startEvent.preventDefault();
+  } else if (!startDOMCell) {
+    return;
+  }
+  function setCellSelection($anchor2, event) {
+    let $head = cellUnderMouse(view, event);
+    const starting = tableEditingKey.getState(view.state) == null;
+    if (!$head || !inSameTable($anchor2, $head)) {
+      if (starting)
+        $head = $anchor2;
+      else
+        return;
+    }
+    const selection = new CellSelection($anchor2, $head);
+    if (starting || !view.state.selection.eq(selection)) {
+      const tr2 = view.state.tr.setSelection(selection);
+      if (starting)
+        tr2.setMeta(tableEditingKey, $anchor2.pos);
+      view.dispatch(tr2);
+    }
+  }
+  function stop() {
+    view.root.removeEventListener("mouseup", stop);
+    view.root.removeEventListener("dragstart", stop);
+    view.root.removeEventListener("mousemove", move);
+    if (tableEditingKey.getState(view.state) != null)
+      view.dispatch(view.state.tr.setMeta(tableEditingKey, -1));
+  }
+  function move(_event) {
+    const event = _event;
+    const anchor = tableEditingKey.getState(view.state);
+    let $anchor2;
+    if (anchor != null) {
+      $anchor2 = view.state.doc.resolve(anchor);
+    } else if (domInCell(view, event.target) != startDOMCell) {
+      $anchor2 = cellUnderMouse(view, startEvent);
+      if (!$anchor2)
+        return stop();
+    }
+    if ($anchor2)
+      setCellSelection($anchor2, event);
+  }
+  view.root.addEventListener("mouseup", stop);
+  view.root.addEventListener("dragstart", stop);
+  view.root.addEventListener("mousemove", move);
+}
+function atEndOfCell(view, axis2, dir) {
+  if (!(view.state.selection instanceof TextSelection))
+    return null;
+  const { $head } = view.state.selection;
+  for (let d2 = $head.depth - 1; d2 >= 0; d2--) {
+    const parent = $head.node(d2), index2 = dir < 0 ? $head.index(d2) : $head.indexAfter(d2);
+    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(d2);
+      const dirStr = axis2 == "vert" ? dir > 0 ? "down" : "up" : dir > 0 ? "right" : "left";
+      return view.endOfTextblock(dirStr) ? cellPos : null;
+    }
+  }
+  return null;
+}
+function domInCell(view, dom) {
+  for (; dom && dom != view.dom; dom = dom.parentNode) {
+    if (dom.nodeName == "TD" || dom.nodeName == "TH") {
+      return dom;
+    }
+  }
+  return null;
+}
+function cellUnderMouse(view, event) {
+  const mousePos = view.posAtCoords({
+    left: event.clientX,
+    top: event.clientY
+  });
+  if (!mousePos)
+    return null;
+  return mousePos ? cellAround(view.state.doc.resolve(mousePos.pos)) : null;
+}
+var TableView$1 = class TableView2 {
+  constructor(node, cellMinWidth) {
+    this.node = node;
+    this.cellMinWidth = cellMinWidth;
+    this.dom = document.createElement("div");
+    this.dom.className = "tableWrapper";
+    this.table = this.dom.appendChild(document.createElement("table"));
+    this.colgroup = this.table.appendChild(document.createElement("colgroup"));
+    updateColumnsOnResize(node, this.colgroup, this.table, cellMinWidth);
+    this.contentDOM = this.table.appendChild(document.createElement("tbody"));
+  }
+  update(node) {
+    if (node.type != this.node.type)
+      return false;
+    this.node = node;
+    updateColumnsOnResize(node, this.colgroup, this.table, this.cellMinWidth);
+    return true;
+  }
+  ignoreMutation(record) {
+    return record.type == "attributes" && (record.target == this.table || this.colgroup.contains(record.target));
+  }
+};
+function updateColumnsOnResize(node, colgroup, table, cellMinWidth, overrideCol, overrideValue) {
+  var _a2;
+  let totalWidth = 0;
+  let fixedWidth = true;
+  let nextDOM = colgroup.firstChild;
+  const row = node.firstChild;
+  if (!row)
+    return;
+  for (let i2 = 0, col = 0; i2 < row.childCount; i2++) {
+    const { colspan, colwidth } = row.child(i2).attrs;
+    for (let j = 0; j < colspan; j++, col++) {
+      const hasWidth = overrideCol == col ? overrideValue : colwidth && colwidth[j];
+      const cssWidth = hasWidth ? hasWidth + "px" : "";
+      totalWidth += hasWidth || cellMinWidth;
+      if (!hasWidth)
+        fixedWidth = false;
+      if (!nextDOM) {
+        colgroup.appendChild(document.createElement("col")).style.width = cssWidth;
+      } else {
+        if (nextDOM.style.width != cssWidth)
+          nextDOM.style.width = cssWidth;
+        nextDOM = nextDOM.nextSibling;
+      }
+    }
+  }
+  while (nextDOM) {
+    const after = nextDOM.nextSibling;
+    (_a2 = nextDOM.parentNode) == null ? void 0 : _a2.removeChild(nextDOM);
+    nextDOM = after;
+  }
+  if (fixedWidth) {
+    table.style.width = totalWidth + "px";
+    table.style.minWidth = "";
+  } else {
+    table.style.width = "";
+    table.style.minWidth = totalWidth + "px";
+  }
+}
+var columnResizingPluginKey = new PluginKey(
+  "tableColumnResizing"
+);
+function columnResizing({
+  handleWidth = 5,
+  cellMinWidth = 25,
+  View = TableView$1,
+  lastColumnResizable = true
+} = {}) {
+  const plugin = new Plugin({
+    key: columnResizingPluginKey,
+    state: {
+      init(_2, state2) {
+        plugin.spec.props.nodeViews[tableNodeTypes(state2.schema).table.name] = (node, view) => new View(node, cellMinWidth, view);
+        return new ResizeState(-1, false);
+      },
+      apply(tr2, prev) {
+        return prev.apply(tr2);
+      }
+    },
+    props: {
+      attributes: (state2) => {
+        const pluginState = columnResizingPluginKey.getState(state2);
+        return pluginState && pluginState.activeHandle > -1 ? { class: "resize-cursor" } : {};
+      },
+      handleDOMEvents: {
+        mousemove: (view, event) => {
+          handleMouseMove(
+            view,
+            event,
+            handleWidth,
+            cellMinWidth,
+            lastColumnResizable
+          );
+        },
+        mouseleave: (view) => {
+          handleMouseLeave(view);
+        },
+        mousedown: (view, event) => {
+          handleMouseDown2(view, event, cellMinWidth);
+        }
+      },
+      decorations: (state2) => {
+        const pluginState = columnResizingPluginKey.getState(state2);
+        if (pluginState && pluginState.activeHandle > -1) {
+          return handleDecorations(state2, pluginState.activeHandle);
+        }
+      },
+      nodeViews: {}
+    }
+  });
+  return plugin;
+}
+var ResizeState = class _ResizeState {
+  constructor(activeHandle, dragging) {
+    this.activeHandle = activeHandle;
+    this.dragging = dragging;
+  }
+  apply(tr2) {
+    const state2 = this;
+    const action = tr2.getMeta(columnResizingPluginKey);
+    if (action && action.setHandle != null)
+      return new _ResizeState(action.setHandle, false);
+    if (action && action.setDragging !== void 0)
+      return new _ResizeState(state2.activeHandle, action.setDragging);
+    if (state2.activeHandle > -1 && tr2.docChanged) {
+      let handle = tr2.mapping.map(state2.activeHandle, -1);
+      if (!pointsAtCell(tr2.doc.resolve(handle))) {
+        handle = -1;
+      }
+      return new _ResizeState(handle, state2.dragging);
+    }
+    return state2;
+  }
+};
+function handleMouseMove(view, event, handleWidth, cellMinWidth, lastColumnResizable) {
+  const pluginState = columnResizingPluginKey.getState(view.state);
+  if (!pluginState)
+    return;
+  if (!pluginState.dragging) {
+    const target = domCellAround(event.target);
+    let cell = -1;
+    if (target) {
+      const { left: left2, right: right2 } = target.getBoundingClientRect();
+      if (event.clientX - left2 <= handleWidth)
+        cell = edgeCell(view, event, "left", handleWidth);
+      else if (right2 - event.clientX <= handleWidth)
+        cell = edgeCell(view, event, "right", handleWidth);
+    }
+    if (cell != pluginState.activeHandle) {
+      if (!lastColumnResizable && cell !== -1) {
+        const $cell = view.state.doc.resolve(cell);
+        const table = $cell.node(-1);
+        const map4 = TableMap.get(table);
+        const tableStart = $cell.start(-1);
+        const col = map4.colCount($cell.pos - tableStart) + $cell.nodeAfter.attrs.colspan - 1;
+        if (col == map4.width - 1) {
+          return;
+        }
+      }
+      updateHandle(view, cell);
+    }
+  }
+}
+function handleMouseLeave(view) {
+  const pluginState = columnResizingPluginKey.getState(view.state);
+  if (pluginState && pluginState.activeHandle > -1 && !pluginState.dragging)
+    updateHandle(view, -1);
+}
+function handleMouseDown2(view, event, cellMinWidth) {
+  var _a2;
+  const win = (_a2 = view.dom.ownerDocument.defaultView) != null ? _a2 : window;
+  const pluginState = columnResizingPluginKey.getState(view.state);
+  if (!pluginState || pluginState.activeHandle == -1 || pluginState.dragging)
+    return false;
+  const cell = view.state.doc.nodeAt(pluginState.activeHandle);
+  const width = currentColWidth(view, pluginState.activeHandle, cell.attrs);
+  view.dispatch(
+    view.state.tr.setMeta(columnResizingPluginKey, {
+      setDragging: { startX: event.clientX, startWidth: width }
+    })
+  );
+  function finish(event2) {
+    win.removeEventListener("mouseup", finish);
+    win.removeEventListener("mousemove", move);
+    const pluginState2 = columnResizingPluginKey.getState(view.state);
+    if (pluginState2 == null ? void 0 : pluginState2.dragging) {
+      updateColumnWidth(
+        view,
+        pluginState2.activeHandle,
+        draggedWidth(pluginState2.dragging, event2, cellMinWidth)
+      );
+      view.dispatch(
+        view.state.tr.setMeta(columnResizingPluginKey, { setDragging: null })
+      );
+    }
+  }
+  function move(event2) {
+    if (!event2.which)
+      return finish(event2);
+    const pluginState2 = columnResizingPluginKey.getState(view.state);
+    if (!pluginState2)
+      return;
+    if (pluginState2.dragging) {
+      const dragged = draggedWidth(pluginState2.dragging, event2, cellMinWidth);
+      displayColumnWidth(view, pluginState2.activeHandle, dragged, cellMinWidth);
+    }
+  }
+  win.addEventListener("mouseup", finish);
+  win.addEventListener("mousemove", move);
+  event.preventDefault();
+  return true;
+}
+function currentColWidth(view, cellPos, { colspan, colwidth }) {
+  const width = colwidth && colwidth[colwidth.length - 1];
+  if (width)
+    return width;
+  const dom = view.domAtPos(cellPos);
+  const node = dom.node.childNodes[dom.offset];
+  let domWidth = node.offsetWidth, parts = colspan;
+  if (colwidth) {
+    for (let i2 = 0; i2 < colspan; i2++)
+      if (colwidth[i2]) {
+        domWidth -= colwidth[i2];
+        parts--;
+      }
+  }
+  return domWidth / parts;
+}
+function domCellAround(target) {
+  while (target && target.nodeName != "TD" && target.nodeName != "TH")
+    target = target.classList && target.classList.contains("ProseMirror") ? null : target.parentNode;
+  return target;
+}
+function edgeCell(view, event, side, handleWidth) {
+  const offset2 = side == "right" ? -handleWidth : handleWidth;
+  const found2 = view.posAtCoords({
+    left: event.clientX + offset2,
+    top: event.clientY
+  });
+  if (!found2)
+    return -1;
+  const { pos } = found2;
+  const $cell = cellAround(view.state.doc.resolve(pos));
+  if (!$cell)
+    return -1;
+  if (side == "right")
+    return $cell.pos;
+  const map4 = TableMap.get($cell.node(-1)), start2 = $cell.start(-1);
+  const index2 = map4.map.indexOf($cell.pos - start2);
+  return index2 % map4.width == 0 ? -1 : start2 + map4.map[index2 - 1];
+}
+function draggedWidth(dragging, event, cellMinWidth) {
+  const offset2 = event.clientX - dragging.startX;
+  return Math.max(cellMinWidth, dragging.startWidth + offset2);
+}
+function updateHandle(view, value) {
+  view.dispatch(
+    view.state.tr.setMeta(columnResizingPluginKey, { setHandle: value })
+  );
+}
+function updateColumnWidth(view, cell, width) {
+  const $cell = view.state.doc.resolve(cell);
+  const table = $cell.node(-1), map4 = TableMap.get(table), start2 = $cell.start(-1);
+  const col = map4.colCount($cell.pos - start2) + $cell.nodeAfter.attrs.colspan - 1;
+  const tr2 = view.state.tr;
+  for (let row = 0; row < map4.height; row++) {
+    const mapIndex = row * map4.width + col;
+    if (row && map4.map[mapIndex] == map4.map[mapIndex - map4.width])
+      continue;
+    const pos = map4.map[mapIndex];
+    const attrs = table.nodeAt(pos).attrs;
+    const index2 = attrs.colspan == 1 ? 0 : col - map4.colCount(pos);
+    if (attrs.colwidth && attrs.colwidth[index2] == width)
+      continue;
+    const colwidth = attrs.colwidth ? attrs.colwidth.slice() : zeroes(attrs.colspan);
+    colwidth[index2] = width;
+    tr2.setNodeMarkup(start2 + pos, null, { ...attrs, colwidth });
+  }
+  if (tr2.docChanged)
+    view.dispatch(tr2);
+}
+function displayColumnWidth(view, cell, width, cellMinWidth) {
+  const $cell = view.state.doc.resolve(cell);
+  const table = $cell.node(-1), start2 = $cell.start(-1);
+  const col = TableMap.get(table).colCount($cell.pos - start2) + $cell.nodeAfter.attrs.colspan - 1;
+  let dom = view.domAtPos($cell.start(-1)).node;
+  while (dom && dom.nodeName != "TABLE") {
+    dom = dom.parentNode;
+  }
+  if (!dom)
+    return;
+  updateColumnsOnResize(
+    table,
+    dom.firstChild,
+    dom,
+    cellMinWidth,
+    col,
+    width
+  );
+}
+function zeroes(n2) {
+  return Array(n2).fill(0);
+}
+function handleDecorations(state2, cell) {
+  const decorations = [];
+  const $cell = state2.doc.resolve(cell);
+  const table = $cell.node(-1);
+  if (!table) {
+    return DecorationSet.empty;
+  }
+  const map4 = TableMap.get(table);
+  const start2 = $cell.start(-1);
+  const col = map4.colCount($cell.pos - start2) + $cell.nodeAfter.attrs.colspan;
+  for (let row = 0; row < map4.height; row++) {
+    const index2 = col + row * map4.width - 1;
+    if ((col == map4.width || map4.map[index2] != map4.map[index2 + 1]) && (row == 0 || map4.map[index2] != map4.map[index2 - map4.width])) {
+      const cellPos = map4.map[index2];
+      const pos = start2 + cellPos + table.nodeAt(cellPos).nodeSize - 1;
+      const dom = document.createElement("div");
+      dom.className = "column-resize-handle";
+      decorations.push(Decoration.widget(pos, dom));
+    }
+  }
+  return DecorationSet.create(state2.doc, decorations);
+}
+function selectedRect(state2) {
+  const sel = state2.selection;
+  const $pos = selectionCell(state2);
+  const table = $pos.node(-1);
+  const tableStart = $pos.start(-1);
+  const map4 = TableMap.get(table);
+  const rect = sel instanceof CellSelection ? map4.rectBetween(
+    sel.$anchorCell.pos - tableStart,
+    sel.$headCell.pos - tableStart
+  ) : map4.findCell($pos.pos - tableStart);
+  return { ...rect, tableStart, map: map4, table };
+}
+function addColumn(tr2, { map: map4, tableStart, table }, col) {
+  let refColumn = col > 0 ? -1 : 0;
+  if (columnIsHeader(map4, table, col + refColumn)) {
+    refColumn = col == 0 || col == map4.width ? null : 0;
+  }
+  for (let row = 0; row < map4.height; row++) {
+    const index2 = row * map4.width + col;
+    if (col > 0 && col < map4.width && map4.map[index2 - 1] == map4.map[index2]) {
+      const pos = map4.map[index2];
+      const cell = table.nodeAt(pos);
+      tr2.setNodeMarkup(
+        tr2.mapping.map(tableStart + pos),
+        null,
+        addColSpan(cell.attrs, col - map4.colCount(pos))
+      );
+      row += cell.attrs.rowspan - 1;
+    } else {
+      const type3 = refColumn == null ? tableNodeTypes(table.type.schema).cell : table.nodeAt(map4.map[index2 + refColumn]).type;
+      const pos = map4.positionAt(row, col, table);
+      tr2.insert(tr2.mapping.map(tableStart + pos), type3.createAndFill());
+    }
+  }
+  return tr2;
+}
+function addColumnBefore(state2, dispatch) {
+  if (!isInTable(state2))
+    return false;
+  if (dispatch) {
+    const rect = selectedRect(state2);
+    dispatch(addColumn(state2.tr, rect, rect.left));
+  }
+  return true;
+}
+function addColumnAfter(state2, dispatch) {
+  if (!isInTable(state2))
+    return false;
+  if (dispatch) {
+    const rect = selectedRect(state2);
+    dispatch(addColumn(state2.tr, rect, rect.right));
+  }
+  return true;
+}
+function removeColumn(tr2, { map: map4, table, tableStart }, col) {
+  const mapStart = tr2.mapping.maps.length;
+  for (let row = 0; row < map4.height; ) {
+    const index2 = row * map4.width + col;
+    const pos = map4.map[index2];
+    const cell = table.nodeAt(pos);
+    const attrs = cell.attrs;
+    if (col > 0 && map4.map[index2 - 1] == pos || col < map4.width - 1 && map4.map[index2 + 1] == pos) {
+      tr2.setNodeMarkup(
+        tr2.mapping.slice(mapStart).map(tableStart + pos),
+        null,
+        removeColSpan(attrs, col - map4.colCount(pos))
+      );
+    } else {
+      const start2 = tr2.mapping.slice(mapStart).map(tableStart + pos);
+      tr2.delete(start2, start2 + cell.nodeSize);
+    }
+    row += attrs.rowspan;
+  }
+}
+function deleteColumn(state2, dispatch) {
+  if (!isInTable(state2))
+    return false;
+  if (dispatch) {
+    const rect = selectedRect(state2);
+    const tr2 = state2.tr;
+    if (rect.left == 0 && rect.right == rect.map.width)
+      return false;
+    for (let i2 = rect.right - 1; ; i2--) {
+      removeColumn(tr2, rect, i2);
+      if (i2 == rect.left)
+        break;
+      const table = rect.tableStart ? tr2.doc.nodeAt(rect.tableStart - 1) : tr2.doc;
+      if (!table) {
+        throw RangeError("No table found");
+      }
+      rect.table = table;
+      rect.map = TableMap.get(table);
+    }
+    dispatch(tr2);
+  }
+  return true;
+}
+function rowIsHeader(map4, table, row) {
+  var _a2;
+  const headerCell = tableNodeTypes(table.type.schema).header_cell;
+  for (let col = 0; col < map4.width; col++)
+    if (((_a2 = table.nodeAt(map4.map[col + row * map4.width])) == null ? void 0 : _a2.type) != headerCell)
+      return false;
+  return true;
+}
+function addRow(tr2, { map: map4, tableStart, table }, row) {
+  var _a2;
+  let rowPos = tableStart;
+  for (let i2 = 0; i2 < row; i2++)
+    rowPos += table.child(i2).nodeSize;
+  const cells = [];
+  let refRow = row > 0 ? -1 : 0;
+  if (rowIsHeader(map4, table, row + refRow))
+    refRow = row == 0 || row == map4.height ? null : 0;
+  for (let col = 0, index2 = map4.width * row; col < map4.width; col++, index2++) {
+    if (row > 0 && row < map4.height && map4.map[index2] == map4.map[index2 - map4.width]) {
+      const pos = map4.map[index2];
+      const attrs = table.nodeAt(pos).attrs;
+      tr2.setNodeMarkup(tableStart + pos, null, {
+        ...attrs,
+        rowspan: attrs.rowspan + 1
+      });
+      col += attrs.colspan - 1;
+    } else {
+      const type3 = refRow == null ? tableNodeTypes(table.type.schema).cell : (_a2 = table.nodeAt(map4.map[index2 + refRow * map4.width])) == null ? void 0 : _a2.type;
+      const node = type3 == null ? void 0 : type3.createAndFill();
+      if (node)
+        cells.push(node);
+    }
+  }
+  tr2.insert(rowPos, tableNodeTypes(table.type.schema).row.create(null, cells));
+  return tr2;
+}
+function addRowBefore(state2, dispatch) {
+  if (!isInTable(state2))
+    return false;
+  if (dispatch) {
+    const rect = selectedRect(state2);
+    dispatch(addRow(state2.tr, rect, rect.top));
+  }
+  return true;
+}
+function addRowAfter(state2, dispatch) {
+  if (!isInTable(state2))
+    return false;
+  if (dispatch) {
+    const rect = selectedRect(state2);
+    dispatch(addRow(state2.tr, rect, rect.bottom));
+  }
+  return true;
+}
+function removeRow(tr2, { map: map4, table, tableStart }, row) {
+  let rowPos = 0;
+  for (let i2 = 0; i2 < row; i2++)
+    rowPos += table.child(i2).nodeSize;
+  const nextRow = rowPos + table.child(row).nodeSize;
+  const mapFrom = tr2.mapping.maps.length;
+  tr2.delete(rowPos + tableStart, nextRow + tableStart);
+  const seen = /* @__PURE__ */ new Set();
+  for (let col = 0, index2 = row * map4.width; col < map4.width; col++, index2++) {
+    const pos = map4.map[index2];
+    if (seen.has(pos))
+      continue;
+    seen.add(pos);
+    if (row > 0 && pos == map4.map[index2 - map4.width]) {
+      const attrs = table.nodeAt(pos).attrs;
+      tr2.setNodeMarkup(tr2.mapping.slice(mapFrom).map(pos + tableStart), null, {
+        ...attrs,
+        rowspan: attrs.rowspan - 1
+      });
+      col += attrs.colspan - 1;
+    } else if (row < map4.height && pos == map4.map[index2 + map4.width]) {
+      const cell = table.nodeAt(pos);
+      const attrs = cell.attrs;
+      const copy2 = cell.type.create(
+        { ...attrs, rowspan: cell.attrs.rowspan - 1 },
+        cell.content
+      );
+      const newPos = map4.positionAt(row + 1, col, table);
+      tr2.insert(tr2.mapping.slice(mapFrom).map(tableStart + newPos), copy2);
+      col += attrs.colspan - 1;
+    }
+  }
+}
+function deleteRow(state2, dispatch) {
+  if (!isInTable(state2))
+    return false;
+  if (dispatch) {
+    const rect = selectedRect(state2), tr2 = state2.tr;
+    if (rect.top == 0 && rect.bottom == rect.map.height)
+      return false;
+    for (let i2 = rect.bottom - 1; ; i2--) {
+      removeRow(tr2, rect, i2);
+      if (i2 == rect.top)
+        break;
+      const table = rect.tableStart ? tr2.doc.nodeAt(rect.tableStart - 1) : tr2.doc;
+      if (!table) {
+        throw RangeError("No table found");
+      }
+      rect.table = table;
+      rect.map = TableMap.get(rect.table);
+    }
+    dispatch(tr2);
+  }
+  return true;
+}
+function isEmpty(cell) {
+  const c2 = cell.content;
+  return c2.childCount == 1 && c2.child(0).isTextblock && c2.child(0).childCount == 0;
+}
+function cellsOverlapRectangle({ width, height, map: map4 }, rect) {
+  let indexTop = rect.top * width + rect.left, indexLeft = indexTop;
+  let indexBottom = (rect.bottom - 1) * width + rect.left, indexRight = indexTop + (rect.right - rect.left - 1);
+  for (let i2 = rect.top; i2 < rect.bottom; i2++) {
+    if (rect.left > 0 && map4[indexLeft] == map4[indexLeft - 1] || rect.right < width && map4[indexRight] == map4[indexRight + 1])
+      return true;
+    indexLeft += width;
+    indexRight += width;
+  }
+  for (let i2 = rect.left; i2 < rect.right; i2++) {
+    if (rect.top > 0 && map4[indexTop] == map4[indexTop - width] || rect.bottom < height && map4[indexBottom] == map4[indexBottom + width])
+      return true;
+    indexTop++;
+    indexBottom++;
+  }
+  return false;
+}
+function mergeCells(state2, dispatch) {
+  const sel = state2.selection;
+  if (!(sel instanceof CellSelection) || sel.$anchorCell.pos == sel.$headCell.pos)
+    return false;
+  const rect = selectedRect(state2), { map: map4 } = rect;
+  if (cellsOverlapRectangle(map4, rect))
+    return false;
+  if (dispatch) {
+    const tr2 = state2.tr;
+    const seen = {};
+    let content = Fragment.empty;
+    let mergedPos;
+    let mergedCell;
+    for (let row = rect.top; row < rect.bottom; row++) {
+      for (let col = rect.left; col < rect.right; col++) {
+        const cellPos = map4.map[row * map4.width + col];
+        const cell = rect.table.nodeAt(cellPos);
+        if (seen[cellPos] || !cell)
+          continue;
+        seen[cellPos] = true;
+        if (mergedPos == null) {
+          mergedPos = cellPos;
+          mergedCell = cell;
+        } else {
+          if (!isEmpty(cell))
+            content = content.append(cell.content);
+          const mapped = tr2.mapping.map(cellPos + rect.tableStart);
+          tr2.delete(mapped, mapped + cell.nodeSize);
+        }
+      }
+    }
+    if (mergedPos == null || mergedCell == null) {
+      return true;
+    }
+    tr2.setNodeMarkup(mergedPos + rect.tableStart, null, {
+      ...addColSpan(
+        mergedCell.attrs,
+        mergedCell.attrs.colspan,
+        rect.right - rect.left - mergedCell.attrs.colspan
+      ),
+      rowspan: rect.bottom - rect.top
+    });
+    if (content.size) {
+      const end2 = mergedPos + 1 + mergedCell.content.size;
+      const start2 = isEmpty(mergedCell) ? mergedPos + 1 : end2;
+      tr2.replaceWith(start2 + rect.tableStart, end2 + rect.tableStart, content);
+    }
+    tr2.setSelection(
+      new CellSelection(tr2.doc.resolve(mergedPos + rect.tableStart))
+    );
+    dispatch(tr2);
+  }
+  return true;
+}
+function splitCell(state2, dispatch) {
+  const nodeTypes = tableNodeTypes(state2.schema);
+  return splitCellWithType(({ node }) => {
+    return nodeTypes[node.type.spec.tableRole];
+  })(state2, dispatch);
+}
+function splitCellWithType(getCellType) {
+  return (state2, dispatch) => {
+    var _a2;
+    const sel = state2.selection;
+    let cellNode;
+    let cellPos;
+    if (!(sel instanceof CellSelection)) {
+      cellNode = cellWrapping(sel.$from);
+      if (!cellNode)
+        return false;
+      cellPos = (_a2 = cellAround(sel.$from)) == null ? void 0 : _a2.pos;
+    } else {
+      if (sel.$anchorCell.pos != sel.$headCell.pos)
+        return false;
+      cellNode = sel.$anchorCell.nodeAfter;
+      cellPos = sel.$anchorCell.pos;
+    }
+    if (cellNode == null || cellPos == null) {
+      return false;
+    }
+    if (cellNode.attrs.colspan == 1 && cellNode.attrs.rowspan == 1) {
+      return false;
+    }
+    if (dispatch) {
+      let baseAttrs = cellNode.attrs;
+      const attrs = [];
+      const colwidth = baseAttrs.colwidth;
+      if (baseAttrs.rowspan > 1)
+        baseAttrs = { ...baseAttrs, rowspan: 1 };
+      if (baseAttrs.colspan > 1)
+        baseAttrs = { ...baseAttrs, colspan: 1 };
+      const rect = selectedRect(state2), tr2 = state2.tr;
+      for (let i2 = 0; i2 < rect.right - rect.left; i2++)
+        attrs.push(
+          colwidth ? {
+            ...baseAttrs,
+            colwidth: colwidth && colwidth[i2] ? [colwidth[i2]] : null
+          } : baseAttrs
+        );
+      let lastCell;
+      for (let row = rect.top; row < rect.bottom; row++) {
+        let pos = rect.map.positionAt(row, rect.left, rect.table);
+        if (row == rect.top)
+          pos += cellNode.nodeSize;
+        for (let col = rect.left, i2 = 0; col < rect.right; col++, i2++) {
+          if (col == rect.left && row == rect.top)
+            continue;
+          tr2.insert(
+            lastCell = tr2.mapping.map(pos + rect.tableStart, 1),
+            getCellType({ node: cellNode, row, col }).createAndFill(attrs[i2])
+          );
+        }
+      }
+      tr2.setNodeMarkup(
+        cellPos,
+        getCellType({ node: cellNode, row: rect.top, col: rect.left }),
+        attrs[0]
+      );
+      if (sel instanceof CellSelection)
+        tr2.setSelection(
+          new CellSelection(
+            tr2.doc.resolve(sel.$anchorCell.pos),
+            lastCell ? tr2.doc.resolve(lastCell) : void 0
+          )
+        );
+      dispatch(tr2);
+    }
+    return true;
+  };
+}
+function setCellAttr(name, value) {
+  return function(state2, dispatch) {
+    if (!isInTable(state2))
+      return false;
+    const $cell = selectionCell(state2);
+    if ($cell.nodeAfter.attrs[name] === value)
+      return false;
+    if (dispatch) {
+      const tr2 = state2.tr;
+      if (state2.selection instanceof CellSelection)
+        state2.selection.forEachCell((node, pos) => {
+          if (node.attrs[name] !== value)
+            tr2.setNodeMarkup(pos, null, {
+              ...node.attrs,
+              [name]: value
+            });
+        });
+      else
+        tr2.setNodeMarkup($cell.pos, null, {
+          ...$cell.nodeAfter.attrs,
+          [name]: value
+        });
+      dispatch(tr2);
+    }
+    return true;
+  };
+}
+function deprecated_toggleHeader(type3) {
+  return function(state2, dispatch) {
+    if (!isInTable(state2))
+      return false;
+    if (dispatch) {
+      const types = tableNodeTypes(state2.schema);
+      const rect = selectedRect(state2), tr2 = state2.tr;
+      const cells = rect.map.cellsInRect(
+        type3 == "column" ? {
+          left: rect.left,
+          top: 0,
+          right: rect.right,
+          bottom: rect.map.height
+        } : type3 == "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 i2 = 0; i2 < cells.length; i2++)
+        if (nodes[i2].type == types.header_cell)
+          tr2.setNodeMarkup(
+            rect.tableStart + cells[i2],
+            types.cell,
+            nodes[i2].attrs
+          );
+      if (tr2.steps.length == 0)
+        for (let i2 = 0; i2 < cells.length; i2++)
+          tr2.setNodeMarkup(
+            rect.tableStart + cells[i2],
+            types.header_cell,
+            nodes[i2].attrs
+          );
+      dispatch(tr2);
+    }
+    return true;
+  };
+}
+function isHeaderEnabledByType(type3, rect, types) {
+  const cellPositions = rect.map.cellsInRect({
+    left: 0,
+    top: 0,
+    right: type3 == "row" ? rect.map.width : 1,
+    bottom: type3 == "column" ? rect.map.height : 1
+  });
+  for (let i2 = 0; i2 < cellPositions.length; i2++) {
+    const cell = rect.table.nodeAt(cellPositions[i2]);
+    if (cell && cell.type !== types.header_cell) {
+      return false;
+    }
+  }
+  return true;
+}
+function toggleHeader(type3, options) {
+  options = options || { useDeprecatedLogic: false };
+  if (options.useDeprecatedLogic)
+    return deprecated_toggleHeader(type3);
+  return function(state2, dispatch) {
+    if (!isInTable(state2))
+      return false;
+    if (dispatch) {
+      const types = tableNodeTypes(state2.schema);
+      const rect = selectedRect(state2), tr2 = state2.tr;
+      const isHeaderRowEnabled = isHeaderEnabledByType("row", rect, types);
+      const isHeaderColumnEnabled = isHeaderEnabledByType(
+        "column",
+        rect,
+        types
+      );
+      const isHeaderEnabled = type3 === "column" ? isHeaderRowEnabled : type3 === "row" ? isHeaderColumnEnabled : false;
+      const selectionStartsAt = isHeaderEnabled ? 1 : 0;
+      const cellsRect = type3 == "column" ? {
+        left: 0,
+        top: selectionStartsAt,
+        right: 1,
+        bottom: rect.map.height
+      } : type3 == "row" ? {
+        left: selectionStartsAt,
+        top: 0,
+        right: rect.map.width,
+        bottom: 1
+      } : rect;
+      const newType = type3 == "column" ? isHeaderColumnEnabled ? types.cell : types.header_cell : type3 == "row" ? isHeaderRowEnabled ? types.cell : types.header_cell : types.cell;
+      rect.map.cellsInRect(cellsRect).forEach((relativeCellPos) => {
+        const cellPos = relativeCellPos + rect.tableStart;
+        const cell = tr2.doc.nodeAt(cellPos);
+        if (cell) {
+          tr2.setNodeMarkup(cellPos, newType, cell.attrs);
+        }
+      });
+      dispatch(tr2);
+    }
+    return true;
+  };
+}
+toggleHeader("row", {
+  useDeprecatedLogic: true
+});
+toggleHeader("column", {
+  useDeprecatedLogic: true
+});
+var toggleHeaderCell = toggleHeader("cell", {
+  useDeprecatedLogic: true
+});
+function findNextCell($cell, dir) {
+  if (dir < 0) {
+    const before = $cell.nodeBefore;
+    if (before)
+      return $cell.pos - before.nodeSize;
+    for (let row = $cell.index(-1) - 1, rowEnd = $cell.before(); row >= 0; row--) {
+      const rowNode = $cell.node(-1).child(row);
+      const lastChild2 = rowNode.lastChild;
+      if (lastChild2) {
+        return rowEnd - 1 - lastChild2.nodeSize;
+      }
+      rowEnd -= rowNode.nodeSize;
+    }
+  } else {
+    if ($cell.index() < $cell.parent.childCount - 1) {
+      return $cell.pos + $cell.nodeAfter.nodeSize;
+    }
+    const table = $cell.node(-1);
+    for (let row = $cell.indexAfter(-1), rowStart = $cell.after(); row < table.childCount; row++) {
+      const rowNode = table.child(row);
+      if (rowNode.childCount)
+        return rowStart + 1;
+      rowStart += rowNode.nodeSize;
+    }
+  }
+  return null;
+}
+function goToNextCell(direction) {
+  return function(state2, dispatch) {
+    if (!isInTable(state2))
+      return false;
+    const cell = findNextCell(selectionCell(state2), direction);
+    if (cell == null)
+      return false;
+    if (dispatch) {
+      const $cell = state2.doc.resolve(cell);
+      dispatch(
+        state2.tr.setSelection(TextSelection.between($cell, moveCellForward($cell))).scrollIntoView()
+      );
+    }
+    return true;
+  };
+}
+function deleteTable(state2, dispatch) {
+  const $pos = state2.selection.$anchor;
+  for (let d2 = $pos.depth; d2 > 0; d2--) {
+    const node = $pos.node(d2);
+    if (node.type.spec.tableRole == "table") {
+      if (dispatch)
+        dispatch(
+          state2.tr.delete($pos.before(d2), $pos.after(d2)).scrollIntoView()
+        );
+      return true;
+    }
+  }
+  return false;
+}
+function tableEditing({
+  allowTableNodeSelection = false
+} = {}) {
+  return new Plugin({
+    key: tableEditingKey,
+    // This piece of state is used to remember when a mouse-drag
+    // cell-selection is happening, so that it can continue even as
+    // transactions (which might move its anchor cell) come in.
+    state: {
+      init() {
+        return null;
+      },
+      apply(tr2, cur) {
+        const set2 = tr2.getMeta(tableEditingKey);
+        if (set2 != null)
+          return set2 == -1 ? null : set2;
+        if (cur == null || !tr2.docChanged)
+          return cur;
+        const { deleted, pos } = tr2.mapping.mapResult(cur);
+        return deleted ? null : pos;
+      }
+    },
+    props: {
+      decorations: drawCellSelection,
+      handleDOMEvents: {
+        mousedown: handleMouseDown
+      },
+      createSelectionBetween(view) {
+        return tableEditingKey.getState(view.state) != null ? view.state.selection : null;
+      },
+      handleTripleClick,
+      handleKeyDown,
+      handlePaste
+    },
+    appendTransaction(_2, oldState, state2) {
+      return normalizeSelection(
+        state2,
+        fixTables(state2, oldState),
+        allowTableNodeSelection
+      );
+    }
+  });
+}
+function updateColumns(node, colgroup, table, cellMinWidth, overrideCol, overrideValue) {
+  let totalWidth = 0;
+  let fixedWidth = true;
+  let nextDOM = colgroup.firstChild;
+  const row = node.firstChild;
+  for (let i2 = 0, col = 0; i2 < row.childCount; i2 += 1) {
+    const { colspan, colwidth } = row.child(i2).attrs;
+    for (let j = 0; j < colspan; j += 1, col += 1) {
+      const hasWidth = overrideCol === col ? overrideValue : colwidth && colwidth[j];
+      const cssWidth = hasWidth ? `${hasWidth}px` : "";
+      totalWidth += hasWidth || cellMinWidth;
+      if (!hasWidth) {
+        fixedWidth = false;
+      }
+      if (!nextDOM) {
+        colgroup.appendChild(document.createElement("col")).style.width = cssWidth;
+      } else {
+        if (nextDOM.style.width !== cssWidth) {
+          nextDOM.style.width = cssWidth;
+        }
+        nextDOM = nextDOM.nextSibling;
+      }
+    }
+  }
+  while (nextDOM) {
+    const after = nextDOM.nextSibling;
+    nextDOM.parentNode.removeChild(nextDOM);
+    nextDOM = after;
+  }
+  if (fixedWidth) {
+    table.style.width = `${totalWidth}px`;
+    table.style.minWidth = "";
+  } else {
+    table.style.width = "";
+    table.style.minWidth = `${totalWidth}px`;
+  }
+}
+class TableView {
+  constructor(node, cellMinWidth) {
+    this.node = node;
+    this.cellMinWidth = cellMinWidth;
+    this.dom = document.createElement("div");
+    this.dom.className = "tableWrapper";
+    this.table = this.dom.appendChild(document.createElement("table"));
+    this.colgroup = this.table.appendChild(document.createElement("colgroup"));
+    updateColumns(node, this.colgroup, this.table, cellMinWidth);
+    this.contentDOM = this.table.appendChild(document.createElement("tbody"));
+  }
+  update(node) {
+    if (node.type !== this.node.type) {
+      return false;
+    }
+    this.node = node;
+    updateColumns(node, this.colgroup, this.table, this.cellMinWidth);
+    return true;
+  }
+  ignoreMutation(mutation) {
+    return mutation.type === "attributes" && (mutation.target === this.table || this.colgroup.contains(mutation.target));
+  }
+}
+function createColGroup(node, cellMinWidth, overrideCol, overrideValue) {
+  let totalWidth = 0;
+  let fixedWidth = true;
+  const cols = [];
+  const row = node.firstChild;
+  if (!row) {
+    return {};
+  }
+  for (let i2 = 0, col = 0; i2 < row.childCount; i2 += 1) {
+    const { colspan, colwidth } = row.child(i2).attrs;
+    for (let j = 0; j < colspan; j += 1, col += 1) {
+      const hasWidth = overrideCol === col ? overrideValue : colwidth && colwidth[j];
+      const cssWidth = hasWidth ? `${hasWidth}px` : "";
+      totalWidth += hasWidth || cellMinWidth;
+      if (!hasWidth) {
+        fixedWidth = false;
+      }
+      cols.push(["col", cssWidth ? { style: `width: ${cssWidth}` } : {}]);
+    }
+  }
+  const tableWidth = fixedWidth ? `${totalWidth}px` : "";
+  const tableMinWidth = fixedWidth ? "" : `${totalWidth}px`;
+  const colgroup = ["colgroup", {}, ...cols];
+  return { colgroup, tableWidth, tableMinWidth };
+}
+function createCell(cellType, cellContent) {
+  if (cellContent) {
+    return cellType.createChecked(null, cellContent);
+  }
+  return cellType.createAndFill();
+}
+function getTableNodeTypes(schema) {
+  if (schema.cached.tableNodeTypes) {
+    return schema.cached.tableNodeTypes;
+  }
+  const roles = {};
+  Object.keys(schema.nodes).forEach((type3) => {
+    const nodeType = schema.nodes[type3];
+    if (nodeType.spec.tableRole) {
+      roles[nodeType.spec.tableRole] = nodeType;
+    }
+  });
+  schema.cached.tableNodeTypes = roles;
+  return roles;
+}
+function createTable(schema, rowsCount, colsCount, withHeaderRow, cellContent) {
+  const types = getTableNodeTypes(schema);
+  const headerCells = [];
+  const cells = [];
+  for (let index2 = 0; index2 < colsCount; index2 += 1) {
+    const cell = createCell(types.cell, cellContent);
+    if (cell) {
+      cells.push(cell);
+    }
+    if (withHeaderRow) {
+      const headerCell = createCell(types.header_cell, cellContent);
+      if (headerCell) {
+        headerCells.push(headerCell);
+      }
+    }
+  }
+  const rows = [];
+  for (let index2 = 0; index2 < rowsCount; index2 += 1) {
+    rows.push(types.row.createChecked(null, withHeaderRow && index2 === 0 ? headerCells : cells));
+  }
+  return types.table.createChecked(null, rows);
+}
+function isCellSelection(value) {
+  return value instanceof CellSelection;
+}
+const deleteTableWhenAllCellsSelected = ({ editor }) => {
+  const { selection } = editor.state;
+  if (!isCellSelection(selection)) {
+    return false;
+  }
+  let cellCount = 0;
+  const table = findParentNodeClosestToPos(selection.ranges[0].$from, (node) => {
+    return node.type.name === "table";
+  });
+  table === null || table === void 0 ? void 0 : table.node.descendants((node) => {
+    if (node.type.name === "table") {
+      return false;
+    }
+    if (["tableCell", "tableHeader"].includes(node.type.name)) {
+      cellCount += 1;
+    }
+  });
+  const allCellsSelected = cellCount === selection.ranges.length;
+  if (!allCellsSelected) {
+    return false;
+  }
+  editor.commands.deleteTable();
+  return true;
+};
+const Table = Node$2.create({
+  name: "table",
+  // @ts-ignore
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      resizable: false,
+      handleWidth: 5,
+      cellMinWidth: 25,
+      // TODO: fix
+      View: TableView,
+      lastColumnResizable: true,
+      allowTableNodeSelection: false
+    };
+  },
+  content: "tableRow+",
+  tableRole: "table",
+  isolating: true,
+  group: "block",
+  parseHTML() {
+    return [{ tag: "table" }];
+  },
+  renderHTML({ node, HTMLAttributes }) {
+    const { colgroup, tableWidth, tableMinWidth } = createColGroup(node, this.options.cellMinWidth);
+    const table = [
+      "table",
+      mergeAttributes(this.options.HTMLAttributes, HTMLAttributes, {
+        style: tableWidth ? `width: ${tableWidth}` : `minWidth: ${tableMinWidth}`
+      }),
+      colgroup,
+      ["tbody", 0]
+    ];
+    return table;
+  },
+  addCommands() {
+    return {
+      insertTable: ({ rows = 3, cols = 3, withHeaderRow = true } = {}) => ({ tr: tr2, dispatch, editor }) => {
+        const node = createTable(editor.schema, rows, cols, withHeaderRow);
+        if (dispatch) {
+          const offset2 = tr2.selection.anchor + 1;
+          tr2.replaceSelectionWith(node).scrollIntoView().setSelection(TextSelection.near(tr2.doc.resolve(offset2)));
+        }
+        return true;
+      },
+      addColumnBefore: () => ({ state: state2, dispatch }) => {
+        return addColumnBefore(state2, dispatch);
+      },
+      addColumnAfter: () => ({ state: state2, dispatch }) => {
+        return addColumnAfter(state2, dispatch);
+      },
+      deleteColumn: () => ({ state: state2, dispatch }) => {
+        return deleteColumn(state2, dispatch);
+      },
+      addRowBefore: () => ({ state: state2, dispatch }) => {
+        return addRowBefore(state2, dispatch);
+      },
+      addRowAfter: () => ({ state: state2, dispatch }) => {
+        return addRowAfter(state2, dispatch);
+      },
+      deleteRow: () => ({ state: state2, dispatch }) => {
+        return deleteRow(state2, dispatch);
+      },
+      deleteTable: () => ({ state: state2, dispatch }) => {
+        return deleteTable(state2, dispatch);
+      },
+      mergeCells: () => ({ state: state2, dispatch }) => {
+        return mergeCells(state2, dispatch);
+      },
+      splitCell: () => ({ state: state2, dispatch }) => {
+        return splitCell(state2, dispatch);
+      },
+      toggleHeaderColumn: () => ({ state: state2, dispatch }) => {
+        return toggleHeader("column")(state2, dispatch);
+      },
+      toggleHeaderRow: () => ({ state: state2, dispatch }) => {
+        return toggleHeader("row")(state2, dispatch);
+      },
+      toggleHeaderCell: () => ({ state: state2, dispatch }) => {
+        return toggleHeaderCell(state2, dispatch);
+      },
+      mergeOrSplit: () => ({ state: state2, dispatch }) => {
+        if (mergeCells(state2, dispatch)) {
+          return true;
+        }
+        return splitCell(state2, dispatch);
+      },
+      setCellAttribute: (name, value) => ({ state: state2, dispatch }) => {
+        return setCellAttr(name, value)(state2, dispatch);
+      },
+      goToNextCell: () => ({ state: state2, dispatch }) => {
+        return goToNextCell(1)(state2, dispatch);
+      },
+      goToPreviousCell: () => ({ state: state2, dispatch }) => {
+        return goToNextCell(-1)(state2, dispatch);
+      },
+      fixTables: () => ({ state: state2, dispatch }) => {
+        if (dispatch) {
+          fixTables(state2);
+        }
+        return true;
+      },
+      setCellSelection: (position) => ({ tr: tr2, dispatch }) => {
+        if (dispatch) {
+          const selection = CellSelection.create(tr2.doc, position.anchorCell, position.headCell);
+          tr2.setSelection(selection);
+        }
+        return true;
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      Tab: () => {
+        if (this.editor.commands.goToNextCell()) {
+          return true;
+        }
+        if (!this.editor.can().addRowAfter()) {
+          return false;
+        }
+        return this.editor.chain().addRowAfter().goToNextCell().run();
+      },
+      "Shift-Tab": () => this.editor.commands.goToPreviousCell(),
+      Backspace: deleteTableWhenAllCellsSelected,
+      "Mod-Backspace": deleteTableWhenAllCellsSelected,
+      Delete: deleteTableWhenAllCellsSelected,
+      "Mod-Delete": deleteTableWhenAllCellsSelected
+    };
+  },
+  addProseMirrorPlugins() {
+    const isResizable = this.options.resizable && this.editor.isEditable;
+    return [
+      ...isResizable ? [
+        columnResizing({
+          handleWidth: this.options.handleWidth,
+          cellMinWidth: this.options.cellMinWidth,
+          // @ts-ignore (incorrect type)
+          View: this.options.View,
+          // TODO: PR for @types/prosemirror-tables
+          // @ts-ignore (incorrect type)
+          lastColumnResizable: this.options.lastColumnResizable
+        })
+      ] : [],
+      tableEditing({
+        allowTableNodeSelection: this.options.allowTableNodeSelection
+      })
+    ];
+  },
+  extendNodeSchema(extension) {
+    const context = {
+      name: extension.name,
+      options: extension.options,
+      storage: extension.storage
+    };
+    return {
+      tableRole: callOrReturn(getExtensionField(extension, "tableRole", context))
+    };
+  }
+});
+const TableRow = Node$2.create({
+  name: "tableRow",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  content: "(tableCell | tableHeader)*",
+  tableRole: "row",
+  parseHTML() {
+    return [
+      { tag: "tr" }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["tr", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+  }
+});
+const TableCell = Node$2.create({
+  name: "tableCell",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  content: "block+",
+  addAttributes() {
+    return {
+      colspan: {
+        default: 1
+      },
+      rowspan: {
+        default: 1
+      },
+      colwidth: {
+        default: null,
+        parseHTML: (element) => {
+          const colwidth = element.getAttribute("colwidth");
+          const value = colwidth ? [parseInt(colwidth, 10)] : null;
+          return value;
+        }
+      }
+    };
+  },
+  tableRole: "cell",
+  isolating: true,
+  parseHTML() {
+    return [
+      { tag: "td" }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["td", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+  }
+});
+const TableHeader = Node$2.create({
+  name: "tableHeader",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  content: "block+",
+  addAttributes() {
+    return {
+      colspan: {
+        default: 1
+      },
+      rowspan: {
+        default: 1
+      },
+      colwidth: {
+        default: null,
+        parseHTML: (element) => {
+          const colwidth = element.getAttribute("colwidth");
+          const value = colwidth ? [parseInt(colwidth, 10)] : null;
+          return value;
+        }
+      }
+    };
+  },
+  tableRole: "header_cell",
+  isolating: true,
+  parseHTML() {
+    return [
+      { tag: "th" }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["th", mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+  }
+});
 const _hoisted_1$d = { class: "RichText" };
 const _hoisted_2$a = {
   key: 0,
@@ -39632,12 +42259,25 @@ const _sfc_main$8 = /* @__PURE__ */ vue.defineComponent({
           var _a2;
           return !((_a2 = editor.value) == null ? void 0 : _a2.can().chain().focus().redo().run());
         }
+      },
+      {
+        name: "Table",
+        command: () => editor.value.chain().focus().insertTable({ rows: 3, cols: 3, withHeaderRow: true }).run(),
+        icon: "table"
       }
     ];
     const emit2 = __emit;
     function initEditor() {
       editor.value = new Editor({
-        extensions: [StarterKit, Image, Youtube],
+        extensions: [
+          StarterKit,
+          Image,
+          Youtube,
+          Table,
+          TableRow,
+          TableCell,
+          TableHeader
+        ],
         content: props2.modelValue,
         onUpdate: ({ editor: editor2 }) => emit2("update:modelValue", editor2.getHTML())
       });