@domternal/extension-table 0.2.0

package/dist/index.cjs

@@ -0,0 +1,1734 @@
+'use strict';
+
+var core = require('@domternal/core');
+var state = require('@domternal/pm/state');
+var tables = require('@domternal/pm/tables');
+var view = require('@domternal/pm/view');
+
+// src/Table.ts
+function getTableInfo(state) {
+  const $from = state.selection.$from;
+  for (let d = $from.depth; d > 0; d--) {
+    const node = $from.node(d);
+    if (node.type.name !== "table") continue;
+    const tableStart = $from.start(d);
+    const map = tables.TableMap.get(node);
+    const oldWidths = [];
+    let allFrozen = true;
+    for (let col = 0; col < map.width; col++) {
+      const cellOffset = map.map[col] ?? 0;
+      const cell = node.nodeAt(cellOffset);
+      if (!cell) {
+        allFrozen = false;
+        oldWidths.push(0);
+        continue;
+      }
+      const colInCell = col - map.colCount(cellOffset);
+      const colwidth = cell.attrs["colwidth"];
+      const w = colwidth?.[colInCell];
+      if (w) {
+        oldWidths.push(w);
+      } else {
+        allFrozen = false;
+        oldWidths.push(0);
+      }
+    }
+    return { tableStart, oldWidths, allFrozen };
+  }
+  return null;
+}
+function findTableDom(view, tableStart) {
+  try {
+    let node = view.domAtPos(tableStart).node;
+    while (node && node.nodeName !== "TABLE") {
+      node = node.parentNode;
+    }
+    return node;
+  } catch {
+    return null;
+  }
+}
+function getContainerWidth(view, tableStart) {
+  const tableDom = findTableDom(view, tableStart);
+  const wrapper = tableDom?.closest(".tableWrapper");
+  if (wrapper) return Math.floor(wrapper.getBoundingClientRect().width) - 1;
+  return 0;
+}
+function redistributeColumns(tr, tableStartPos, targetWidth, cellMinWidth) {
+  const $pos = tr.doc.resolve(tableStartPos);
+  let tableDepth = -1;
+  for (let d = $pos.depth; d > 0; d--) {
+    if ($pos.node(d).type.name === "table") {
+      tableDepth = d;
+      break;
+    }
+  }
+  if (tableDepth === -1) return;
+  const table = $pos.node(tableDepth);
+  const tableStart = $pos.start(tableDepth);
+  const map = tables.TableMap.get(table);
+  const colCount = map.width;
+  const baseWidth = Math.max(cellMinWidth, Math.floor(targetWidth / colCount));
+  const newWidths = new Array(colCount).fill(baseWidth);
+  const used = baseWidth * colCount;
+  const diff = targetWidth - used;
+  if (diff !== 0 && colCount > 0) {
+    const lastIdx = colCount - 1;
+    newWidths[lastIdx] = Math.max(cellMinWidth, (newWidths[lastIdx] ?? baseWidth) + diff);
+  }
+  for (let col = 0; col < map.width; col++) {
+    const targetW = newWidths[col];
+    for (let row = 0; row < map.height; row++) {
+      const mapIndex = row * map.width + col;
+      if (row > 0 && map.map[mapIndex] === map.map[mapIndex - map.width]) continue;
+      const pos = map.map[mapIndex] ?? 0;
+      const cellNode = table.nodeAt(pos);
+      if (!cellNode) continue;
+      const colspan = cellNode.attrs["colspan"] || 1;
+      const index = colspan === 1 ? 0 : col - map.colCount(pos);
+      const colwidth = cellNode.attrs["colwidth"];
+      if (colwidth?.[index] === targetW) continue;
+      const newColwidth = colwidth ? colwidth.slice() : new Array(colspan).fill(0);
+      newColwidth[index] = targetW;
+      tr.setNodeMarkup(tableStart + pos, null, { ...cellNode.attrs, colwidth: newColwidth });
+    }
+  }
+}
+function constrainedAddColumn(pmCommand, view, cellMinWidth, defaultCellMinWidth) {
+  const state = view.state;
+  const info = getTableInfo(state);
+  if (!info?.allFrozen) {
+    return pmCommand(state, view.dispatch.bind(view));
+  }
+  const containerWidth = getContainerWidth(view, info.tableStart);
+  if (containerWidth <= 0) {
+    return pmCommand(state, view.dispatch.bind(view));
+  }
+  const oldTotal = info.oldWidths.reduce((a, b) => a + b, 0);
+  if (oldTotal + defaultCellMinWidth <= containerWidth) {
+    return pmCommand(state, view.dispatch.bind(view));
+  }
+  let captured;
+  pmCommand(state, (tr) => {
+    captured = tr;
+  });
+  if (!captured) return false;
+  redistributeColumns(captured, info.tableStart, Math.min(oldTotal, containerWidth), cellMinWidth);
+  view.dispatch(captured);
+  return true;
+}
+
+// src/icons.ts
+var DOTS_H = '<svg width="10" height="4" viewBox="0 0 10 4"><circle cx="2" cy="2" r="1.2" fill="currentColor"/><circle cx="5" cy="2" r="1.2" fill="currentColor"/><circle cx="8" cy="2" r="1.2" fill="currentColor"/></svg>';
+var DOTS_V = '<svg width="4" height="10" viewBox="0 0 4 10"><circle cx="2" cy="2" r="1.2" fill="currentColor"/><circle cx="2" cy="5" r="1.2" fill="currentColor"/><circle cx="2" cy="8" r="1.2" fill="currentColor"/></svg>';
+var CHEVRON_DOWN = '<svg width="8" height="8" viewBox="0 0 8 8" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><path d="M1 2.5l3 3 3-3"/></svg>';
+var ICON_COLOR = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256" fill="currentColor"><path d="M200.77,53.89A103.27,103.27,0,0,0,128,24h-1.07A104,104,0,0,0,24,128c0,43,26.58,79.06,69.36,94.17A32,32,0,0,0,136,192a16,16,0,0,1,16-16h46.21a31.81,31.81,0,0,0,31.2-24.88,104.43,104.43,0,0,0,2.59-24A103.28,103.28,0,0,0,200.77,53.89Zm13,93.71A15.89,15.89,0,0,1,198.21,160H152a32,32,0,0,0-32,32,16,16,0,0,1-21.31,15.07C62.49,194.3,40,164,40,128a88,88,0,0,1,87.09-88h.9a88.35,88.35,0,0,1,88,87.25A88.86,88.86,0,0,1,213.81,147.6ZM140,76a12,12,0,1,1-12-12A12,12,0,0,1,140,76ZM96,100A12,12,0,1,1,84,88,12,12,0,0,1,96,100Zm0,56a12,12,0,1,1-12-12A12,12,0,0,1,96,156Zm88-56a12,12,0,1,1-12-12A12,12,0,0,1,184,100Z"/></svg>';
+var ICON_ALIGNMENT = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256" fill="currentColor"><path d="M32,64a8,8,0,0,1,8-8H216a8,8,0,0,1,0,16H40A8,8,0,0,1,32,64Zm8,48H168a8,8,0,0,0,0-16H40a8,8,0,0,0,0,16Zm176,24H40a8,8,0,0,0,0,16H216a8,8,0,0,0,0-16Zm-48,40H40a8,8,0,0,0,0,16H168a8,8,0,0,0,0-16Z"/></svg>';
+var ICON_HEADER = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256" fill="currentColor"><path d="M208,32H48A16,16,0,0,0,32,48V208a16,16,0,0,0,16,16H208a16,16,0,0,0,16-16V48A16,16,0,0,0,208,32Zm0,176H48V48H208V208ZM72,96V80a8,8,0,0,1,16,0V96a8,8,0,0,1-16,0Zm96,0V80a8,8,0,0,1,16,0V96a8,8,0,0,1-16,0Zm-48,0V80a8,8,0,0,1,16,0V96a8,8,0,0,1-16,0Z"/></svg>';
+var ICON_MERGE = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256" fill="currentColor"><path d="M200,40H56A16,16,0,0,0,40,56V200a16,16,0,0,0,16,16H200a16,16,0,0,0,16-16V56A16,16,0,0,0,200,40Zm0,16V96H136V56ZM56,56h64V96H56ZM56,200V112H200v88Z"/></svg>';
+var ICON_SPLIT = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256" fill="currentColor"><path d="M200,40H56A16,16,0,0,0,40,56V200a16,16,0,0,0,16,16H200a16,16,0,0,0,16-16V56A16,16,0,0,0,200,40Zm0,16V96H136V56ZM56,56h64V96H56ZM56,136V112h64v24Zm0,64V152h64v48Zm144,0H136V152h64Zm0-48H136V112h64Z"/></svg>';
+var ICON_ALIGN_LEFT = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256" fill="currentColor"><path d="M32,64a8,8,0,0,1,8-8H216a8,8,0,0,1,0,16H40A8,8,0,0,1,32,64Zm8,48H168a8,8,0,0,0,0-16H40a8,8,0,0,0,0,16Zm176,24H40a8,8,0,0,0,0,16H216a8,8,0,0,0,0-16Zm-48,40H40a8,8,0,0,0,0,16H168a8,8,0,0,0,0-16Z"/></svg>';
+var ICON_ALIGN_CENTER = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256" fill="currentColor"><path d="M32,64a8,8,0,0,1,8-8H216a8,8,0,0,1,0,16H40A8,8,0,0,1,32,64ZM64,96a8,8,0,0,0,0,16H192a8,8,0,0,0,0-16Zm152,40H40a8,8,0,0,0,0,16H216a8,8,0,0,0,0-16Zm-24,40H64a8,8,0,0,0,0,16H192a8,8,0,0,0,0-16Z"/></svg>';
+var ICON_ALIGN_RIGHT = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256" fill="currentColor"><path d="M32,64a8,8,0,0,1,8-8H216a8,8,0,0,1,0,16H40A8,8,0,0,1,32,64ZM216,96H88a8,8,0,0,0,0,16H216a8,8,0,0,0,0-16Zm0,40H40a8,8,0,0,0,0,16H216a8,8,0,0,0,0-16Zm0,40H88a8,8,0,0,0,0,16H216a8,8,0,0,0,0-16Z"/></svg>';
+var ICON_ALIGN_TOP = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256" fill="currentColor"><path d="M40,40H216a8,8,0,0,0,0-16H40a8,8,0,0,0,0,16Zm88,16a8,8,0,0,0-8,8v96a8,8,0,0,0,16,0V64A8,8,0,0,0,128,56Zm40,16a8,8,0,0,0-8,8v64a8,8,0,0,0,16,0V80A8,8,0,0,0,168,72ZM88,72a8,8,0,0,0-8,8v64a8,8,0,0,0,16,0V80A8,8,0,0,0,88,72Z"/></svg>';
+var ICON_ALIGN_MIDDLE = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256" fill="currentColor"><path d="M40,136H216a8,8,0,0,0,0-16H40a8,8,0,0,0,0,16Zm88-80a8,8,0,0,0-8,8v32a8,8,0,0,0,16,0V64A8,8,0,0,0,128,56Zm0,104a8,8,0,0,0-8,8v32a8,8,0,0,0,16,0V168A8,8,0,0,0,128,160Zm40-80a8,8,0,0,0-8,8v16a8,8,0,0,0,16,0V88A8,8,0,0,0,168,80Zm0,56a8,8,0,0,0-8,8v16a8,8,0,0,0,16,0V144A8,8,0,0,0,168,136ZM88,80a8,8,0,0,0-8,8v16a8,8,0,0,0,16,0V88A8,8,0,0,0,88,80Zm0,56a8,8,0,0,0-8,8v16a8,8,0,0,0,16,0V144A8,8,0,0,0,88,136Z"/></svg>';
+var ICON_ALIGN_BOTTOM = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256" fill="currentColor"><path d="M40,232H216a8,8,0,0,0,0-16H40a8,8,0,0,0,0,16Zm88-32a8,8,0,0,0,8-8V96a8,8,0,0,0-16,0v96A8,8,0,0,0,128,200Zm40-16a8,8,0,0,0,8-8V112a8,8,0,0,0-16,0v64A8,8,0,0,0,168,184ZM88,184a8,8,0,0,0,8-8V112a8,8,0,0,0-16,0v64A8,8,0,0,0,88,184Z"/></svg>';
+var CELL_ICON = '<svg width="8" height="8" viewBox="0 0 8 8"><circle cx="2" cy="2" r="1.2" fill="currentColor"/><circle cx="6" cy="2" r="1.2" fill="currentColor"/><circle cx="2" cy="6" r="1.2" fill="currentColor"/><circle cx="6" cy="6" r="1.2" fill="currentColor"/></svg>';
+var ICON_ROW_PLUS_TOP = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256" fill="currentColor"><path d="M208,160H48a16,16,0,0,0-16,16v24a16,16,0,0,0,16,16H208a16,16,0,0,0,16-16V176A16,16,0,0,0,208,160Zm0,40H48V176H208v24Zm0-112H48a16,16,0,0,0-16,16v24a16,16,0,0,0,16,16H208a16,16,0,0,0,16-16V104A16,16,0,0,0,208,88Zm0,40H48V104H208v24ZM96,40a8,8,0,0,1,8-8h16V16a8,8,0,0,1,16,0V32h16a8,8,0,0,1,0,16H136V64a8,8,0,0,1-16,0V48H104A8,8,0,0,1,96,40Z"/></svg>';
+var ICON_ROW_PLUS_BOTTOM = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256" fill="currentColor"><path d="M208,112H48a16,16,0,0,0-16,16v24a16,16,0,0,0,16,16H208a16,16,0,0,0,16-16V128A16,16,0,0,0,208,112Zm0,40H48V128H208v24Zm0-112H48A16,16,0,0,0,32,56V80A16,16,0,0,0,48,96H208a16,16,0,0,0,16-16V56A16,16,0,0,0,208,40Zm0,40H48V56H208V80ZM160,216a8,8,0,0,1-8,8H136v16a8,8,0,0,1-16,0V224H104a8,8,0,0,1,0-16h16V192a8,8,0,0,1,16,0v16h16A8,8,0,0,1,160,216Z"/></svg>';
+var ICON_DELETE_ROW = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256" fill="currentColor"><path d="M208,136H48a16,16,0,0,0-16,16v40a16,16,0,0,0,16,16H208a16,16,0,0,0,16-16V152A16,16,0,0,0,208,136Zm0,56H48V152H208v40Zm0-144H48A16,16,0,0,0,32,64v40a16,16,0,0,0,16,16H208a16,16,0,0,0,16-16V64A16,16,0,0,0,208,48Zm0,56H48V64H208v40Z"/></svg>';
+var ICON_COL_PLUS_LEFT = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256" fill="currentColor"><path d="M128,32H104A16,16,0,0,0,88,48V208a16,16,0,0,0,16,16h24a16,16,0,0,0,16-16V48A16,16,0,0,0,128,32Zm0,176H104V48h24ZM200,32H176a16,16,0,0,0-16,16V208a16,16,0,0,0,16,16h24a16,16,0,0,0,16-16V48A16,16,0,0,0,200,32Zm0,176H176V48h24ZM72,128a8,8,0,0,1-8,8H48v16a8,8,0,0,1-16,0V136H16a8,8,0,0,1,0-16H32V104a8,8,0,0,1,16,0v16H64A8,8,0,0,1,72,128Z"/></svg>';
+var ICON_COL_PLUS_RIGHT = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256" fill="currentColor"><path d="M80,32H56A16,16,0,0,0,40,48V208a16,16,0,0,0,16,16H80a16,16,0,0,0,16-16V48A16,16,0,0,0,80,32Zm0,176H56V48H80ZM152,32H128a16,16,0,0,0-16,16V208a16,16,0,0,0,16,16h24a16,16,0,0,0,16-16V48A16,16,0,0,0,152,32Zm0,176H128V48h24Zm96-80a8,8,0,0,1-8,8H224v16a8,8,0,0,1-16,0V136H192a8,8,0,0,1,0-16h16V104a8,8,0,0,1,16,0v16h16A8,8,0,0,1,248,128Z"/></svg>';
+var ICON_DELETE_COL = '<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 256 256" fill="currentColor"><path d="M104,32H64A16,16,0,0,0,48,48V208a16,16,0,0,0,16,16h40a16,16,0,0,0,16-16V48A16,16,0,0,0,104,32Zm0,176H64V48h40ZM192,32H152a16,16,0,0,0-16,16V208a16,16,0,0,0,16,16h40a16,16,0,0,0,16-16V48A16,16,0,0,0,192,32Zm0,176H152V48h40Z"/></svg>';
+var CELL_COLORS = [
+  // Row 1 — Warm highlights
+  "#fef08a",
+  "#fed7aa",
+  "#fecaca",
+  "#fbcfe8",
+  // Row 2 — Cool highlights
+  "#a7f3d0",
+  "#a5f3fc",
+  "#bfdbfe",
+  "#c4b5fd",
+  // Row 3 — Light pastels
+  "#fef9c3",
+  "#ffedd5",
+  "#dbeafe",
+  "#ede9fe",
+  // Row 4 — Neutrals
+  "#e5e7eb",
+  "#d1d5db",
+  "#f3f4f6",
+  "#ffffff"
+];
+
+// src/TableView.ts
+var tableViewMap = /* @__PURE__ */ new WeakMap();
+var TableView = class {
+  node;
+  cellMinWidth;
+  defaultCellMinWidth;
+  view;
+  constrainToContainer;
+  dom;
+  table;
+  colgroup;
+  contentDOM;
+  wrapper;
+  colHandle;
+  rowHandle;
+  cellToolbar;
+  colorBtn = null;
+  alignBtn = null;
+  mergeBtn = null;
+  splitBtn = null;
+  headerBtn = null;
+  cellHandle;
+  cellHandleCell = null;
+  dropdown = null;
+  /** When true, the plugin skips showing the cell toolbar (row/col dropdown is open). */
+  suppressCellToolbar = false;
+  /** When true, column resize drag is active — all handles/menus are hidden. */
+  _resizeDragging = false;
+  hoveredCell = null;
+  hoveredRow = -1;
+  hoveredCol = -1;
+  hideTimeout = null;
+  // Bound handlers for cleanup
+  boundMouseMove;
+  boundMouseLeave;
+  boundCancelHide;
+  boundDocMouseDown;
+  boundDocKeyDown;
+  boundScroll;
+  constructor(node, cellMinWidth, view, defaultCellMinWidth = 100, constrainToContainer = true) {
+    this.node = node;
+    this.cellMinWidth = cellMinWidth;
+    this.defaultCellMinWidth = defaultCellMinWidth;
+    this.view = view;
+    this.constrainToContainer = constrainToContainer;
+    this.boundMouseMove = this.onMouseMove.bind(this);
+    this.boundMouseLeave = this.onMouseLeave.bind(this);
+    this.boundCancelHide = this.cancelHide.bind(this);
+    this.boundDocMouseDown = this.onDocMouseDown.bind(this);
+    this.boundDocKeyDown = this.onDocKeyDown.bind(this);
+    this.boundScroll = () => {
+      this.closeDropdown();
+    };
+    this.dom = document.createElement("div");
+    this.dom.className = "dm-table-container";
+    tableViewMap.set(this.dom, this);
+    this.colHandle = this.createHandle("dm-table-col-handle", "Column options", DOTS_H);
+    this.colHandle.addEventListener("click", (e) => {
+      e.stopPropagation();
+      this.onColClick();
+    });
+    this.dom.appendChild(this.colHandle);
+    this.rowHandle = this.createHandle("dm-table-row-handle", "Row options", DOTS_V);
+    this.rowHandle.addEventListener("click", (e) => {
+      e.stopPropagation();
+      this.onRowClick();
+    });
+    this.dom.appendChild(this.rowHandle);
+    this.cellToolbar = this.buildCellToolbar();
+    this.dom.appendChild(this.cellToolbar);
+    this.cellHandle = document.createElement("button");
+    this.cellHandle.type = "button";
+    this.cellHandle.className = "dm-table-cell-handle";
+    this.cellHandle.setAttribute("aria-label", "Cell options");
+    this.cellHandle.innerHTML = CELL_ICON;
+    this.cellHandle.addEventListener("mousedown", (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+    });
+    this.cellHandle.addEventListener("click", (e) => {
+      e.stopPropagation();
+      this.onCellHandleClick();
+    });
+    this.dom.appendChild(this.cellHandle);
+    this.wrapper = document.createElement("div");
+    this.wrapper.className = "tableWrapper";
+    this.dom.appendChild(this.wrapper);
+    this.table = document.createElement("table");
+    this.wrapper.appendChild(this.table);
+    this.colgroup = document.createElement("colgroup");
+    this.updateColumns(node);
+    this.table.appendChild(this.colgroup);
+    this.contentDOM = document.createElement("tbody");
+    this.table.appendChild(this.contentDOM);
+    this.dom.addEventListener("mousemove", this.boundMouseMove);
+    this.dom.addEventListener("mouseleave", this.boundMouseLeave);
+    this.colHandle.addEventListener("mouseenter", this.boundCancelHide);
+    this.rowHandle.addEventListener("mouseenter", this.boundCancelHide);
+    this.cellHandle.addEventListener("mouseenter", this.boundCancelHide);
+  }
+  // ─── NodeView interface ───────────────────────────────────────────────
+  update(node) {
+    if (node.type !== this.node.type) {
+      return false;
+    }
+    this.node = node;
+    this.updateColumns(node);
+    this.hoveredCell = null;
+    this.hoveredRow = -1;
+    this.hoveredCol = -1;
+    if (this.cellHandleCell && !this.table.contains(this.cellHandleCell)) {
+      this.hideCellHandle();
+    }
+    return true;
+  }
+  destroy() {
+    this.dom.removeEventListener("mousemove", this.boundMouseMove);
+    this.dom.removeEventListener("mouseleave", this.boundMouseLeave);
+    this.colHandle.removeEventListener("mouseenter", this.boundCancelHide);
+    this.rowHandle.removeEventListener("mouseenter", this.boundCancelHide);
+    this.cellHandle.removeEventListener("mouseenter", this.boundCancelHide);
+    this.closeDropdown();
+    if (this.hideTimeout) clearTimeout(this.hideTimeout);
+    tableViewMap.delete(this.dom);
+  }
+  ignoreMutation(mutation) {
+    if (mutation.type === "selection") {
+      return false;
+    }
+    if (mutation.type === "attributes") {
+      return true;
+    }
+    if (mutation instanceof MutationRecord && !this.contentDOM.contains(mutation.target)) {
+      return true;
+    }
+    return false;
+  }
+  // ─── Handle creation ──────────────────────────────────────────────────
+  createHandle(className, label, icon) {
+    const btn = document.createElement("button");
+    btn.className = className;
+    btn.type = "button";
+    btn.setAttribute("aria-label", label);
+    btn.innerHTML = icon;
+    btn.addEventListener("mousedown", (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+    });
+    return btn;
+  }
+  // ─── Cell toolbar (floating strip for CellSelection) ──────────────────
+  buildCellToolbar() {
+    const toolbar = document.createElement("div");
+    toolbar.className = "dm-table-cell-toolbar";
+    toolbar.addEventListener("mousedown", (e) => {
+      e.preventDefault();
+      e.stopPropagation();
+    });
+    this.colorBtn = this.createToolbarButton(ICON_COLOR, "Cell color", CHEVRON_DOWN);
+    this.colorBtn.addEventListener("click", (e) => {
+      e.stopPropagation();
+      if (this.colorBtn) this.showColorDropdown(this.colorBtn);
+    });
+    toolbar.appendChild(this.colorBtn);
+    this.alignBtn = this.createToolbarButton(ICON_ALIGNMENT, "Alignment", CHEVRON_DOWN);
+    this.alignBtn.addEventListener("click", (e) => {
+      e.stopPropagation();
+      if (this.alignBtn) this.showAlignmentDropdown(this.alignBtn);
+    });
+    toolbar.appendChild(this.alignBtn);
+    const sep1 = document.createElement("span");
+    sep1.className = "dm-table-cell-toolbar-sep";
+    toolbar.appendChild(sep1);
+    this.mergeBtn = this.createToolbarButton(ICON_MERGE, "Merge cells");
+    this.mergeBtn.addEventListener("click", (e) => {
+      e.stopPropagation();
+      tables.mergeCells(this.view.state, this.view.dispatch);
+    });
+    toolbar.appendChild(this.mergeBtn);
+    this.splitBtn = this.createToolbarButton(ICON_SPLIT, "Split cell");
+    this.splitBtn.addEventListener("click", (e) => {
+      e.stopPropagation();
+      tables.splitCell(this.view.state, this.view.dispatch);
+    });
+    toolbar.appendChild(this.splitBtn);
+    const sep2 = document.createElement("span");
+    sep2.className = "dm-table-cell-toolbar-sep";
+    toolbar.appendChild(sep2);
+    this.headerBtn = this.createToolbarButton(ICON_HEADER, "Toggle header cell");
+    this.headerBtn.addEventListener("click", (e) => {
+      e.stopPropagation();
+      tables.toggleHeaderCell(this.view.state, this.view.dispatch);
+    });
+    toolbar.appendChild(this.headerBtn);
+    return toolbar;
+  }
+  createToolbarButton(icon, label, chevron) {
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "dm-table-cell-toolbar-btn";
+    btn.setAttribute("aria-label", label);
+    btn.innerHTML = icon + (chevron ? `<span class="dm-table-cell-toolbar-chevron">${chevron}</span>` : "");
+    return btn;
+  }
+  // ─── Hover tracking ──────────────────────────────────────────────────
+  onMouseMove(e) {
+    if (this._resizeDragging) return;
+    const target = e.target;
+    if (!(target instanceof HTMLElement)) return;
+    const cell = target.closest("td, th");
+    if (!cell || !this.table.contains(cell)) return;
+    if (cell === this.hoveredCell) return;
+    this.hoveredCell = cell;
+    const { row, col } = this.getCellIndices(cell);
+    this.hoveredRow = row;
+    this.hoveredCol = col;
+    this.positionHandles(cell);
+    this.showHandles();
+    this.cancelHide();
+  }
+  onMouseLeave() {
+    if (this.hideTimeout) clearTimeout(this.hideTimeout);
+    this.hideTimeout = setTimeout(() => {
+      this.hideHandles();
+      this.hoveredCell = null;
+    }, 200);
+  }
+  cancelHide() {
+    if (this.hideTimeout) {
+      clearTimeout(this.hideTimeout);
+      this.hideTimeout = null;
+    }
+  }
+  showHandles() {
+    this.colHandle.style.display = "flex";
+    this.rowHandle.style.display = "flex";
+  }
+  hideHandles() {
+    if (this.dropdown) return;
+    this.colHandle.style.display = "";
+    this.rowHandle.style.display = "";
+  }
+  positionHandles(cell) {
+    const containerRect = this.dom.getBoundingClientRect();
+    const tableRect = this.table.getBoundingClientRect();
+    const cellRect = cell.getBoundingClientRect();
+    this.colHandle.style.left = String(cellRect.left - containerRect.left + cellRect.width / 2 - 12) + "px";
+    this.colHandle.style.top = String(tableRect.top - containerRect.top - 16) + "px";
+    this.rowHandle.style.left = String(tableRect.left - containerRect.left - 16) + "px";
+    if (cell.rowSpan > 1) {
+      this.rowHandle.style.top = String(cellRect.top - containerRect.top + cellRect.height / 2 - 12) + "px";
+    } else {
+      const tr = cell.closest("tr");
+      if (tr) {
+        const trRect = tr.getBoundingClientRect();
+        this.rowHandle.style.top = String(trRect.top - containerRect.top + trRect.height / 2 - 12) + "px";
+      }
+    }
+  }
+  getCellIndices(cell) {
+    const tr = cell.closest("tr");
+    if (!tr) return { row: 0, col: 0 };
+    const row = Array.from(this.contentDOM.querySelectorAll("tr")).indexOf(tr);
+    let col = 0;
+    let sibling = cell.previousElementSibling;
+    while (sibling) {
+      col += sibling.colSpan || 1;
+      sibling = sibling.previousElementSibling;
+    }
+    return { row, col };
+  }
+  // ─── Cell toolbar positioning (driven by CellSelection plugin) ────────
+  /** Called by the cellHandlePlugin when CellSelection changes. */
+  updateCellHandle(active) {
+    if (!active || this._resizeDragging) {
+      this.cellToolbar.style.display = "";
+      this.closeDropdown();
+      return;
+    }
+    const selectedCells = this.table.querySelectorAll(".selectedCell");
+    if (selectedCells.length === 0) {
+      this.cellToolbar.style.display = "";
+      return;
+    }
+    let top = Infinity;
+    let left = Infinity;
+    let right = -Infinity;
+    selectedCells.forEach((c) => {
+      const r = c.getBoundingClientRect();
+      if (r.top < top) top = r.top;
+      if (r.left < left) left = r.left;
+      if (r.right > right) right = r.right;
+    });
+    const containerRect = this.dom.getBoundingClientRect();
+    this.cellToolbar.style.display = "flex";
+    const toolbarWidth = this.cellToolbar.offsetWidth;
+    const selectionCenter = (left + right) / 2;
+    let toolbarLeft = selectionCenter - containerRect.left - toolbarWidth / 2;
+    toolbarLeft = Math.max(0, Math.min(toolbarLeft, containerRect.width - toolbarWidth));
+    this.cellToolbar.style.left = String(toolbarLeft) + "px";
+    this.cellToolbar.style.top = String(top - containerRect.top - 36) + "px";
+    const canMerge = tables.mergeCells(this.view.state);
+    const canSplit = tables.splitCell(this.view.state);
+    if (this.mergeBtn) this.mergeBtn.disabled = !canMerge;
+    if (this.splitBtn) this.splitBtn.disabled = !canSplit;
+    const sel = this.view.state.selection;
+    if (sel instanceof tables.CellSelection) {
+      let hasCustomAlign = false;
+      let hasCustomColor = false;
+      let allHeaders = true;
+      sel.forEachCell((node) => {
+        if (node.attrs["textAlign"] || node.attrs["verticalAlign"]) hasCustomAlign = true;
+        if (node.attrs["background"]) hasCustomColor = true;
+        if (node.type.name !== "tableHeader") allHeaders = false;
+      });
+      this.alignBtn?.classList.toggle("dm-table-cell-toolbar-btn--active", hasCustomAlign);
+      this.colorBtn?.classList.toggle("dm-table-cell-toolbar-btn--active", hasCustomColor);
+      this.headerBtn?.classList.toggle("dm-table-cell-toolbar-btn--active", allHeaders);
+    }
+  }
+  // ─── Cell handle (small circle for single-cell operations) ──────────
+  /** Hide all controls during column resize drag. Called by the plugin. */
+  hideForResize() {
+    this._resizeDragging = true;
+    this.cellHandle.style.display = "";
+    this.colHandle.style.display = "";
+    this.rowHandle.style.display = "";
+    this.cellToolbar.style.display = "";
+    this.closeDropdown();
+  }
+  /** Re-enable controls after column resize drag ends. Called by the plugin. */
+  showAfterResize() {
+    this._resizeDragging = false;
+  }
+  /** Show cell handle at the top-center of the given cell. Always repositions (no early return). */
+  showCellHandle(cell) {
+    if (this._resizeDragging) return;
+    this.cellHandleCell = cell;
+    const containerRect = this.dom.getBoundingClientRect();
+    const cellRect = cell.getBoundingClientRect();
+    this.cellHandle.style.left = String(cellRect.left - containerRect.left - 7) + "px";
+    this.cellHandle.style.top = String(cellRect.top - containerRect.top - 7) + "px";
+    this.cellHandle.style.display = "flex";
+  }
+  /** Hide cell handle. */
+  hideCellHandle() {
+    this.cellHandle.style.display = "";
+    this.cellHandleCell = null;
+  }
+  /** Click on cell handle → create CellSelection for that cell. */
+  onCellHandleClick() {
+    if (!this.cellHandleCell) return;
+    this.dismissOverlays();
+    const pos = this.view.posAtDOM(this.cellHandleCell, 0);
+    const $pos = this.view.state.doc.resolve(pos);
+    for (let d = $pos.depth; d > 0; d--) {
+      const node = $pos.node(d);
+      if (node.type.name === "tableCell" || node.type.name === "tableHeader") {
+        const cellPos = $pos.before(d);
+        const sel = tables.CellSelection.create(this.view.state.doc, cellPos, cellPos);
+        this.dispatchCellSelection(sel);
+        break;
+      }
+    }
+  }
+  // ─── Handle clicks ───────────────────────────────────────────────────
+  /** Dismiss other floating overlays (bubble menu, etc.) */
+  dismissOverlays() {
+    this.dom.closest(".dm-editor")?.dispatchEvent(
+      new Event("dm:dismiss-overlays", { bubbles: false })
+    );
+  }
+  onColClick() {
+    this.suppressCellToolbar = true;
+    this.cellToolbar.style.display = "";
+    this.dismissOverlays();
+    this.selectColumn(this.hoveredCol);
+    this.showDropdown("column");
+  }
+  onRowClick() {
+    this.suppressCellToolbar = true;
+    this.cellToolbar.style.display = "";
+    this.dismissOverlays();
+    this.selectRow(this.hoveredRow);
+    this.showDropdown("row");
+  }
+  getTablePos() {
+    const pos = this.view.posAtDOM(this.table, 0);
+    const $pos = this.view.state.doc.resolve(pos);
+    for (let d = $pos.depth; d > 0; d--) {
+      if ($pos.node(d).type.name === "table") {
+        return $pos.before(d);
+      }
+    }
+    return pos;
+  }
+  /** Dispatch a CellSelection and focus the editor. */
+  dispatchCellSelection(sel) {
+    this.view.dispatch(
+      this.view.state.tr.setSelection(sel)
+    );
+    this.view.focus();
+  }
+  selectRow(row) {
+    const tablePos = this.getTablePos();
+    const tableStart = tablePos + 1;
+    const map = tables.TableMap.get(this.node);
+    if (row < 0 || row >= map.height) return;
+    const anchorOffset = map.map[row * map.width];
+    const headOffset = map.map[row * map.width + map.width - 1];
+    if (anchorOffset === void 0 || headOffset === void 0) return;
+    const sel = tables.CellSelection.create(this.view.state.doc, tableStart + anchorOffset, tableStart + headOffset);
+    this.dispatchCellSelection(sel);
+  }
+  selectColumn(col) {
+    const tablePos = this.getTablePos();
+    const tableStart = tablePos + 1;
+    const map = tables.TableMap.get(this.node);
+    if (col < 0 || col >= map.width) return;
+    const anchorOffset = map.map[col];
+    const headOffset = map.map[(map.height - 1) * map.width + col];
+    if (anchorOffset === void 0 || headOffset === void 0) return;
+    const sel = tables.CellSelection.create(this.view.state.doc, tableStart + anchorOffset, tableStart + headOffset);
+    this.dispatchCellSelection(sel);
+  }
+  setCursorInCell(row, col) {
+    const tablePos = this.getTablePos();
+    const tableStart = tablePos + 1;
+    const map = tables.TableMap.get(this.node);
+    if (row < 0 || row >= map.height || col < 0 || col >= map.width) return;
+    const cellOffset = map.map[row * map.width + col];
+    if (cellOffset === void 0) return;
+    const $pos = this.view.state.doc.resolve(tableStart + cellOffset + 1);
+    const sel = state.TextSelection.near($pos);
+    this.view.dispatch(this.view.state.tr.setSelection(sel));
+  }
+  // ─── Dropdown ────────────────────────────────────────────────────────
+  showDropdown(type) {
+    this.closeDropdown();
+    const dropdown = document.createElement("div");
+    dropdown.className = "dm-table-controls-dropdown";
+    dropdown.addEventListener("mouseenter", this.boundCancelHide);
+    dropdown.addEventListener("mousedown", (e) => {
+      e.preventDefault();
+    });
+    const items = type === "row" ? [
+      { icon: ICON_ROW_PLUS_TOP, label: "Insert Row Above", action: () => {
+        this.execRowCmd(tables.addRowBefore);
+      } },
+      { icon: ICON_ROW_PLUS_BOTTOM, label: "Insert Row Below", action: () => {
+        this.execRowCmd(tables.addRowAfter);
+      } },
+      { icon: ICON_DELETE_ROW, label: "Delete Row", action: () => {
+        this.execRowCmd(tables.deleteRow);
+      } }
+    ] : [
+      { icon: ICON_COL_PLUS_LEFT, label: "Insert Column Left", action: () => {
+        this.execColCmd(tables.addColumnBefore);
+      } },
+      { icon: ICON_COL_PLUS_RIGHT, label: "Insert Column Right", action: () => {
+        this.execColCmd(tables.addColumnAfter);
+      } },
+      { icon: ICON_DELETE_COL, label: "Delete Column", action: () => {
+        this.execColCmd(tables.deleteColumn);
+      } }
+    ];
+    for (const item of items) {
+      const btn = document.createElement("button");
+      btn.type = "button";
+      btn.innerHTML = `<span class="dm-table-controls-dropdown-icon">${item.icon}</span>${item.label}`;
+      btn.addEventListener("click", (e) => {
+        e.stopPropagation();
+        item.action();
+        this.closeDropdown();
+        this.hideHandles();
+      });
+      dropdown.appendChild(btn);
+    }
+    const handle = type === "row" ? this.rowHandle : this.colHandle;
+    const handleRect = handle.getBoundingClientRect();
+    dropdown.style.position = "fixed";
+    dropdown.style.left = String(handleRect.left) + "px";
+    dropdown.style.top = String(handleRect.bottom + 4) + "px";
+    document.body.appendChild(dropdown);
+    this.dropdown = dropdown;
+    this.addDropdownListeners();
+  }
+  // ─── Cell toolbar dropdowns ──────────────────────────────────────────
+  /** Shared open/toggle for toolbar dropdown buttons. */
+  openToolbarDropdown(triggerBtn, className, buildContent) {
+    if (this.dropdown && triggerBtn.classList.contains("dm-table-cell-toolbar-btn--open")) {
+      this.closeDropdown();
+      return;
+    }
+    this.closeDropdown();
+    triggerBtn.classList.add("dm-table-cell-toolbar-btn--open");
+    const dropdown = document.createElement("div");
+    dropdown.className = className;
+    dropdown.addEventListener("mousedown", (e) => {
+      e.preventDefault();
+    });
+    buildContent(dropdown);
+    this.positionToolbarDropdown(dropdown, triggerBtn);
+  }
+  showColorDropdown(triggerBtn) {
+    this.openToolbarDropdown(triggerBtn, "dm-table-controls-dropdown dm-table-cell-dropdown", (dropdown) => {
+      const palette = document.createElement("div");
+      palette.className = "dm-color-palette";
+      palette.style.setProperty("--dm-palette-columns", "4");
+      const resetBtn = document.createElement("button");
+      resetBtn.type = "button";
+      resetBtn.className = "dm-color-palette-reset";
+      resetBtn.innerHTML = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" fill="currentColor" width="14" height="14"><path d="M128,24A104,104,0,1,0,232,128,104.11,104.11,0,0,0,128,24Zm88,104a87.56,87.56,0,0,1-20.41,56.28L71.72,60.41A88,88,0,0,1,216,128ZM40,128A87.56,87.56,0,0,1,60.41,71.72L184.28,195.59A88,88,0,0,1,40,128Z"/></svg> Default';
+      resetBtn.addEventListener("click", (e) => {
+        e.stopPropagation();
+        tables.setCellAttr("background", null)(this.view.state, this.view.dispatch);
+        this.closeDropdown();
+      });
+      palette.appendChild(resetBtn);
+      for (const color of CELL_COLORS) {
+        const swatch = document.createElement("button");
+        swatch.type = "button";
+        swatch.className = "dm-color-swatch";
+        swatch.style.backgroundColor = color;
+        swatch.setAttribute("aria-label", color);
+        swatch.addEventListener("click", (e) => {
+          e.stopPropagation();
+          tables.setCellAttr("background", color)(this.view.state, this.view.dispatch);
+          this.closeDropdown();
+        });
+        palette.appendChild(swatch);
+      }
+      dropdown.appendChild(palette);
+    });
+  }
+  showAlignmentDropdown(triggerBtn) {
+    this.openToolbarDropdown(triggerBtn, "dm-table-controls-dropdown dm-table-cell-align-dropdown", (dropdown) => {
+      const sel = this.view.state.selection;
+      const cellNode = this.view.state.doc.nodeAt(sel.$anchorCell.pos);
+      const curTextAlign = cellNode?.attrs["textAlign"] ?? null;
+      const curVerticalAlign = cellNode?.attrs["verticalAlign"] ?? null;
+      const hAligns = [
+        { value: "left", label: "Align left", icon: ICON_ALIGN_LEFT },
+        { value: "center", label: "Align center", icon: ICON_ALIGN_CENTER },
+        { value: "right", label: "Align right", icon: ICON_ALIGN_RIGHT }
+      ];
+      const vAligns = [
+        { value: "top", label: "Align top", icon: ICON_ALIGN_TOP },
+        { value: "middle", label: "Align middle", icon: ICON_ALIGN_MIDDLE },
+        { value: "bottom", label: "Align bottom", icon: ICON_ALIGN_BOTTOM }
+      ];
+      for (const a of hAligns) {
+        const isActive = curTextAlign === a.value || !curTextAlign && a.value === "left";
+        dropdown.appendChild(this.createAlignItem(a.icon, a.label, isActive, () => {
+          tables.setCellAttr("textAlign", a.value === "left" ? null : a.value)(this.view.state, this.view.dispatch);
+          this.closeDropdown();
+        }));
+      }
+      const sep = document.createElement("div");
+      sep.className = "dm-table-cell-dropdown-separator";
+      dropdown.appendChild(sep);
+      for (const a of vAligns) {
+        const isActive = curVerticalAlign === a.value || !curVerticalAlign && a.value === "top";
+        dropdown.appendChild(this.createAlignItem(a.icon, a.label, isActive, () => {
+          tables.setCellAttr("verticalAlign", a.value === "top" ? null : a.value)(this.view.state, this.view.dispatch);
+          this.closeDropdown();
+        }));
+      }
+    });
+  }
+  createAlignItem(icon, label, active, onClick) {
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "dm-table-align-item" + (active ? " dm-table-align-item--active" : "");
+    btn.innerHTML = `<span class="dm-table-align-item-icon">${icon}</span><span>${label}</span>`;
+    btn.addEventListener("click", (e) => {
+      e.stopPropagation();
+      onClick();
+    });
+    return btn;
+  }
+  positionToolbarDropdown(dropdown, triggerBtn) {
+    const btnRect = triggerBtn.getBoundingClientRect();
+    dropdown.style.position = "fixed";
+    dropdown.style.top = String(btnRect.bottom + 4) + "px";
+    document.body.appendChild(dropdown);
+    this.dropdown = dropdown;
+    const dropdownWidth = dropdown.offsetWidth;
+    let leftPos = btnRect.left;
+    if (leftPos + dropdownWidth > window.innerWidth) {
+      leftPos = window.innerWidth - dropdownWidth - 4;
+    }
+    dropdown.style.left = String(Math.max(0, leftPos)) + "px";
+    this.addDropdownListeners();
+  }
+  addDropdownListeners() {
+    document.addEventListener("mousedown", this.boundDocMouseDown, true);
+    document.addEventListener("keydown", this.boundDocKeyDown);
+    window.addEventListener("scroll", this.boundScroll, true);
+  }
+  removeDropdownListeners() {
+    document.removeEventListener("mousedown", this.boundDocMouseDown, true);
+    document.removeEventListener("keydown", this.boundDocKeyDown);
+    window.removeEventListener("scroll", this.boundScroll, true);
+  }
+  closeDropdown() {
+    if (!this.dropdown) return;
+    this.dropdown.remove();
+    this.dropdown = null;
+    this.suppressCellToolbar = false;
+    this.cellToolbar.querySelectorAll(".dm-table-cell-toolbar-btn--open").forEach(
+      (el) => {
+        el.classList.remove("dm-table-cell-toolbar-btn--open");
+      }
+    );
+    this.removeDropdownListeners();
+  }
+  onDocMouseDown(e) {
+    const target = e.target;
+    if (this.dropdown?.contains(target) || this.cellToolbar.contains(target) || this.colHandle.contains(target) || this.rowHandle.contains(target)) {
+      return;
+    }
+    this.closeDropdown();
+  }
+  onDocKeyDown(e) {
+    if (e.key === "Escape") {
+      this.closeDropdown();
+    }
+  }
+  execRowCmd(cmd) {
+    this.setCursorInCell(this.hoveredRow, 0);
+    const state = this.view.state;
+    if (cmd === tables.deleteRow && tables.isInTable(state)) {
+      const rect = tables.selectedRect(state);
+      if (rect.top === 0 && rect.bottom === rect.map.height) {
+        tables.deleteTable(state, this.view.dispatch);
+        return;
+      }
+    }
+    cmd(state, this.view.dispatch);
+  }
+  execColCmd(cmd) {
+    this.setCursorInCell(0, this.hoveredCol);
+    if (this.constrainToContainer && (cmd === tables.addColumnBefore || cmd === tables.addColumnAfter)) {
+      constrainedAddColumn(cmd, this.view, this.cellMinWidth, this.defaultCellMinWidth);
+      return;
+    }
+    const state = this.view.state;
+    if (cmd === tables.deleteColumn && tables.isInTable(state)) {
+      const rect = tables.selectedRect(state);
+      if (rect.left === 0 && rect.right === rect.map.width) {
+        tables.deleteTable(state, this.view.dispatch);
+        return;
+      }
+    }
+    cmd(state, this.view.dispatch);
+  }
+  // ─── Column management ───────────────────────────────────────────────
+  /**
+   * Update colgroup col elements based on cell widths.
+   * Matches prosemirror-tables' updateColumnsOnResize behavior:
+   * - Reuses existing col elements (avoids DOM churn during resize)
+   * - Uses defaultCellMinWidth for totalWidth calc (matches columnResizing plugin)
+   * - Columns without explicit widths get empty style.width (table-layout: fixed distributes)
+   */
+  updateColumns(node) {
+    let totalWidth = 0;
+    let fixedWidth = true;
+    let nextDOM = this.colgroup.firstChild;
+    const firstRow = node.firstChild;
+    if (!firstRow) return;
+    for (let i = 0; i < firstRow.childCount; i++) {
+      const cell = firstRow.child(i);
+      const colspan = cell.attrs["colspan"] || 1;
+      const colwidth = cell.attrs["colwidth"];
+      for (let j = 0; j < colspan; j++) {
+        const hasWidth = colwidth?.[j];
+        const cssWidth = hasWidth ? String(hasWidth) + "px" : "";
+        totalWidth += hasWidth ?? this.defaultCellMinWidth;
+        if (!hasWidth) fixedWidth = false;
+        if (!nextDOM) {
+          const colEl = document.createElement("col");
+          colEl.style.width = cssWidth;
+          this.colgroup.appendChild(colEl);
+        } else {
+          if (nextDOM.style.width !== cssWidth) {
+            nextDOM.style.width = cssWidth;
+          }
+          nextDOM = nextDOM.nextElementSibling;
+        }
+      }
+    }
+    while (nextDOM) {
+      const after = nextDOM.nextElementSibling;
+      nextDOM.remove();
+      nextDOM = after;
+    }
+    if (fixedWidth && totalWidth > 0) {
+      this.table.style.width = String(totalWidth) + "px";
+      this.table.style.minWidth = "";
+    } else {
+      this.table.style.width = "";
+      this.table.style.minWidth = this.constrainToContainer ? "" : String(totalWidth) + "px";
+    }
+  }
+};
+function createTable(schema, rows, cols, withHeaderRow, cellContent) {
+  const types = tables.tableNodeTypes(schema);
+  const headerCells = [];
+  const cells = [];
+  for (let col = 0; col < cols; col++) {
+    const cell = cellContent ? types.cell.createChecked(null, cellContent) : types.cell.createAndFill();
+    if (cell) {
+      cells.push(cell);
+    }
+    if (withHeaderRow) {
+      const headerCell = cellContent ? types.header_cell.createChecked(null, cellContent) : types.header_cell.createAndFill();
+      if (headerCell) {
+        headerCells.push(headerCell);
+      }
+    }
+  }
+  const tableRows = [];
+  for (let row = 0; row < rows; row++) {
+    const rowCells = withHeaderRow && row === 0 ? headerCells : cells;
+    tableRows.push(types.row.createChecked(null, rowCells));
+  }
+  return types.table.createChecked(null, tableRows);
+}
+function deleteTableWhenAllCellsSelected({
+  state: state$1,
+  dispatch
+}) {
+  const { selection } = state$1;
+  if (!(selection instanceof tables.CellSelection)) {
+    return false;
+  }
+  let cellCount = 0;
+  const table = tables.findTable(selection.$anchorCell);
+  if (!table) {
+    return false;
+  }
+  table.node.descendants((node) => {
+    const role = node.type.spec["tableRole"];
+    if (role === "cell" || role === "header_cell") {
+      cellCount++;
+    }
+  });
+  const selectionCellCount = selection.ranges.length;
+  if (cellCount !== selectionCellCount) {
+    return false;
+  }
+  if (dispatch) {
+    const tr = state$1.tr;
+    tr.delete(table.pos, table.pos + table.node.nodeSize);
+    const $pos = tr.doc.resolve(Math.min(table.pos, tr.doc.content.size));
+    const newSelection = state.TextSelection.near($pos);
+    tr.setSelection(newSelection);
+    dispatch(tr);
+  }
+  return true;
+}
+function createResizeSuppressionPlugin(options) {
+  const { resizeBehavior, cellMinWidth, defaultCellMinWidth, constrainToContainer } = options;
+  return new state.Plugin({
+    props: {
+      handleDOMEvents: {
+        mousedown: (view, event) => {
+          if (event.button !== 0) return false;
+          const resizeState = tables.columnResizingPluginKey.getState(view.state);
+          if (!resizeState || resizeState.activeHandle === -1) {
+            view.dom.classList.add("dm-mouse-drag");
+            document.addEventListener("mouseup", () => {
+              view.dom.classList.remove("dm-mouse-drag");
+            }, { once: true });
+            return false;
+          }
+          if (resizeBehavior === "redistribute" || resizeBehavior === "independent") {
+            if (resizeBehavior === "independent") {
+              freezeColumnWidths(view, resizeState.activeHandle, cellMinWidth, defaultCellMinWidth);
+            }
+            const win = view.dom.ownerDocument.defaultView ?? window;
+            win.addEventListener("mouseup", () => {
+              const st = tables.columnResizingPluginKey.getState(view.state);
+              if (st && st.activeHandle > -1 && !st.dragging) {
+                view.dispatch(view.state.tr.setMeta(tables.columnResizingPluginKey, { setHandle: -1 }));
+              }
+            }, { once: true });
+            return false;
+          }
+          return handleNeighborResize(view, event, resizeState.activeHandle, cellMinWidth, defaultCellMinWidth, constrainToContainer);
+        },
+        mousemove: (view, event) => {
+          if (event.buttons !== 1) return false;
+          const resizeState = tables.columnResizingPluginKey.getState(view.state);
+          if (resizeState?.dragging) return false;
+          return true;
+        }
+      }
+    }
+  });
+}
+function handleNeighborResize(view, event, activeHandle, cellMinWidth, defaultCellMinWidth, constrainToContainer) {
+  freezeColumnWidths(view, activeHandle, cellMinWidth, defaultCellMinWidth);
+  const state = view.state;
+  const resizeState = tables.columnResizingPluginKey.getState(state);
+  const handle = resizeState?.activeHandle ?? -1;
+  if (handle === -1) return false;
+  const $cell = state.doc.resolve(handle);
+  const table = $cell.node(-1);
+  const map = tables.TableMap.get(table);
+  const tableStart = $cell.start(-1);
+  const nodeAfter = $cell.nodeAfter;
+  if (!nodeAfter) return false;
+  const draggedCol = map.colCount($cell.pos - tableStart) + (nodeAfter.attrs["colspan"] || 1) - 1;
+  const neighborCol = draggedCol + 1;
+  if (neighborCol >= map.width) {
+    if (!constrainToContainer) return false;
+    return handleLastColumnResize(view, event, table, map, tableStart, draggedCol, cellMinWidth, defaultCellMinWidth);
+  }
+  const startWidth = readColWidth(table, map, draggedCol, defaultCellMinWidth);
+  const neighborStartWidth = readColWidth(table, map, neighborCol, defaultCellMinWidth);
+  const startX = event.clientX;
+  view.dispatch(state.tr.setMeta(tables.columnResizingPluginKey, {
+    setDragging: { startX, startWidth }
+  }));
+  const tableDom = findTableDom(view, tableStart);
+  const colgroup = tableDom?.querySelector("colgroup")?.children;
+  if (!colgroup) return false;
+  const cols = colgroup;
+  const win = view.dom.ownerDocument.defaultView ?? window;
+  function move(e) {
+    if (!e.buttons) {
+      finish(e);
+      return;
+    }
+    const offset = e.clientX - startX;
+    const clamped = Math.max(
+      -(startWidth - cellMinWidth),
+      Math.min(offset, neighborStartWidth - cellMinWidth)
+    );
+    const newDraggedW = startWidth + clamped;
+    const newNeighborW = neighborStartWidth - clamped;
+    cols[draggedCol].style.width = String(newDraggedW) + "px";
+    cols[neighborCol].style.width = String(newNeighborW) + "px";
+  }
+  function finish(e) {
+    win.removeEventListener("mouseup", finish);
+    win.removeEventListener("mousemove", move);
+    const pluginState = tables.columnResizingPluginKey.getState(view.state);
+    if (!pluginState?.dragging) return;
+    const offset = e.clientX - startX;
+    const clamped = Math.max(
+      -(startWidth - cellMinWidth),
+      Math.min(offset, neighborStartWidth - cellMinWidth)
+    );
+    const finalDraggedW = Math.round(startWidth + clamped);
+    const finalNeighborW = Math.round(neighborStartWidth - clamped);
+    const curState = view.state;
+    const curHandle = pluginState.activeHandle;
+    const $curCell = curState.doc.resolve(curHandle);
+    const curTable = $curCell.node(-1);
+    const curMap = tables.TableMap.get(curTable);
+    const curStart = $curCell.start(-1);
+    const tr = curState.tr;
+    storeColWidth(tr, curTable, curMap, curStart, draggedCol, finalDraggedW);
+    storeColWidth(tr, curTable, curMap, curStart, neighborCol, finalNeighborW);
+    tr.setMeta(tables.columnResizingPluginKey, { setDragging: null });
+    view.dispatch(tr);
+    view.dispatch(view.state.tr.setMeta(tables.columnResizingPluginKey, { setHandle: -1 }));
+  }
+  win.addEventListener("mouseup", finish);
+  win.addEventListener("mousemove", move);
+  event.preventDefault();
+  return true;
+}
+function handleLastColumnResize(view, event, table, map, tableStart, draggedCol, cellMinWidth, defaultCellMinWidth) {
+  const startWidth = readColWidth(table, map, draggedCol, defaultCellMinWidth);
+  const startX = event.clientX;
+  const tableDom = findTableDom(view, tableStart);
+  const colgroupChildren = tableDom?.querySelector("colgroup")?.children;
+  if (!colgroupChildren) return false;
+  const cols = colgroupChildren;
+  let totalWidth = 0;
+  for (let c = 0; c < map.width; c++) {
+    totalWidth += readColWidth(table, map, c, defaultCellMinWidth);
+  }
+  const containerWidth = getContainerWidth(view, tableStart);
+  const maxGrow = containerWidth > 0 ? containerWidth - totalWidth : 0;
+  view.dispatch(view.state.tr.setMeta(tables.columnResizingPluginKey, {
+    setDragging: { startX, startWidth }
+  }));
+  const win = view.dom.ownerDocument.defaultView ?? window;
+  function move(e) {
+    if (!e.buttons) {
+      finish(e);
+      return;
+    }
+    const offset = e.clientX - startX;
+    const clamped = Math.max(-(startWidth - cellMinWidth), Math.min(offset, maxGrow));
+    cols[draggedCol].style.width = String(startWidth + clamped) + "px";
+    if (tableDom) tableDom.style.width = String(totalWidth + clamped) + "px";
+  }
+  function finish(e) {
+    win.removeEventListener("mouseup", finish);
+    win.removeEventListener("mousemove", move);
+    const pluginState = tables.columnResizingPluginKey.getState(view.state);
+    if (!pluginState?.dragging) return;
+    const offset = e.clientX - startX;
+    const clamped = Math.max(-(startWidth - cellMinWidth), Math.min(offset, maxGrow));
+    const finalWidth = Math.round(startWidth + clamped);
+    const curState = view.state;
+    const $curCell = curState.doc.resolve(pluginState.activeHandle);
+    const curTable = $curCell.node(-1);
+    const curMap = tables.TableMap.get(curTable);
+    const curStart = $curCell.start(-1);
+    const tr = curState.tr;
+    storeColWidth(tr, curTable, curMap, curStart, draggedCol, finalWidth);
+    tr.setMeta(tables.columnResizingPluginKey, { setDragging: null });
+    view.dispatch(tr);
+    view.dispatch(view.state.tr.setMeta(tables.columnResizingPluginKey, { setHandle: -1 }));
+  }
+  win.addEventListener("mouseup", finish);
+  win.addEventListener("mousemove", move);
+  event.preventDefault();
+  return true;
+}
+function readColWidth(table, map, col, fallback) {
+  const offset = map.map[col] ?? 0;
+  const cell = table.nodeAt(offset);
+  if (!cell) return fallback;
+  const idx = col - map.colCount(offset);
+  const colwidth = cell.attrs["colwidth"];
+  return colwidth?.[idx] ?? fallback;
+}
+function storeColWidth(tr, table, map, tableStart, col, width) {
+  for (let row = 0; row < map.height; row++) {
+    const mapIndex = row * map.width + col;
+    if (row > 0 && map.map[mapIndex] === map.map[mapIndex - map.width]) continue;
+    const pos = map.map[mapIndex] ?? 0;
+    const cellNode = table.nodeAt(pos);
+    if (!cellNode) continue;
+    const attrs = cellNode.attrs;
+    const colspan = attrs["colspan"] || 1;
+    const index = colspan === 1 ? 0 : col - map.colCount(pos);
+    const colwidth = attrs["colwidth"];
+    if (colwidth?.[index] === width) continue;
+    const newColwidth = colwidth ? colwidth.slice() : new Array(colspan).fill(0);
+    newColwidth[index] = width;
+    tr.setNodeMarkup(tableStart + pos, null, { ...attrs, colwidth: newColwidth });
+  }
+}
+function freezeColumnWidths(view, handlePos, cellMinWidth, defaultCellMinWidth) {
+  const state = view.state;
+  const $cell = state.doc.resolve(handlePos);
+  let tableDepth = -1;
+  for (let d = $cell.depth; d > 0; d--) {
+    if ($cell.node(d).type.name === "table") {
+      tableDepth = d;
+      break;
+    }
+  }
+  if (tableDepth === -1) return;
+  const table = $cell.node(tableDepth);
+  const tableStart = $cell.start(tableDepth);
+  const map = tables.TableMap.get(table);
+  const firstRow = table.firstChild;
+  if (!firstRow) return;
+  const colNeedsWidth = [];
+  let anyNeedsWidth = false;
+  for (let col = 0; col < map.width; col++) {
+    const cellOffset = map.map[col] ?? 0;
+    const cellNode = table.nodeAt(cellOffset);
+    if (!cellNode) {
+      colNeedsWidth.push(true);
+      anyNeedsWidth = true;
+      continue;
+    }
+    const colWithinCell = col - map.colCount(cellOffset);
+    const colwidth = cellNode.attrs["colwidth"];
+    if (colwidth?.[colWithinCell]) {
+      colNeedsWidth.push(false);
+    } else {
+      colNeedsWidth.push(true);
+      anyNeedsWidth = true;
+    }
+  }
+  if (!anyNeedsWidth) return;
+  const measuredWidths = new Array(map.width);
+  for (let col = 0; col < map.width; col++) {
+    const cellOffset = map.map[col] ?? 0;
+    const cellNode = table.nodeAt(cellOffset);
+    if (!cellNode) {
+      measuredWidths[col] = defaultCellMinWidth;
+      continue;
+    }
+    const colspan = cellNode.attrs["colspan"] || 1;
+    const colwidth = cellNode.attrs["colwidth"];
+    const colWithinCell = col - map.colCount(cellOffset);
+    if (!colNeedsWidth[col]) {
+      measuredWidths[col] = colwidth?.[colWithinCell] ?? defaultCellMinWidth;
+      continue;
+    }
+    try {
+      const dom = view.domAtPos(tableStart + cellOffset);
+      const cellDom = dom.node.childNodes[dom.offset];
+      if (cellDom) {
+        let domWidth = cellDom.offsetWidth;
+        let parts = colspan;
+        if (colwidth) {
+          for (let j = 0; j < colspan; j++) {
+            const cw = colwidth[j];
+            if (cw) {
+              domWidth -= cw;
+              parts--;
+            }
+          }
+        }
+        measuredWidths[col] = Math.max(cellMinWidth, Math.round(domWidth / parts));
+      } else {
+        measuredWidths[col] = defaultCellMinWidth;
+      }
+    } catch {
+      measuredWidths[col] = defaultCellMinWidth;
+    }
+  }
+  try {
+    const tableDom = findTableDom(view, tableStart);
+    if (tableDom) {
+      const actualWidth = Math.floor(tableDom.getBoundingClientRect().width) - 1;
+      if (actualWidth > 0) {
+        let measuredTotal = 0;
+        for (let col = 0; col < map.width; col++) measuredTotal += measuredWidths[col] ?? 0;
+        const diff = measuredTotal - actualWidth;
+        if (diff > 0) {
+          for (let col = map.width - 1; col >= 0; col--) {
+            if (colNeedsWidth[col]) {
+              measuredWidths[col] = Math.max(cellMinWidth, (measuredWidths[col] ?? 0) - diff);
+              break;
+            }
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  const cellColwidths = /* @__PURE__ */ new Map();
+  for (let col = 0; col < map.width; col++) {
+    if (!colNeedsWidth[col]) continue;
+    const width = measuredWidths[col] ?? 0;
+    for (let row = 0; row < map.height; row++) {
+      const mapIndex = row * map.width + col;
+      if (row > 0 && map.map[mapIndex] === map.map[mapIndex - map.width]) continue;
+      const pos = map.map[mapIndex] ?? 0;
+      const cellNode = table.nodeAt(pos);
+      if (!cellNode) continue;
+      const attrs = cellNode.attrs;
+      const colspan = attrs["colspan"] || 1;
+      const index = colspan === 1 ? 0 : col - map.colCount(pos);
+      if (!cellColwidths.has(pos)) {
+        const existing = attrs["colwidth"];
+        cellColwidths.set(pos, existing ? existing.slice() : new Array(colspan).fill(0));
+      }
+      const arr = cellColwidths.get(pos);
+      if (arr) arr[index] = width;
+    }
+  }
+  const tr = state.tr;
+  for (const [pos, colwidth] of cellColwidths) {
+    const cellNode = table.nodeAt(pos);
+    if (!cellNode) continue;
+    tr.setNodeMarkup(tableStart + pos, null, {
+      ...cellNode.attrs,
+      colwidth
+    });
+  }
+  if (tr.docChanged) {
+    view.dispatch(tr);
+  }
+}
+var pluginKey = new state.PluginKey("cellSelection");
+function domElementAt(view, pos) {
+  const { node } = view.domAtPos(pos);
+  return node instanceof HTMLElement ? node : node.parentElement;
+}
+function createCellSelectionPlugin() {
+  return new state.Plugin({
+    key: pluginKey,
+    state: {
+      init() {
+        return view.DecorationSet.empty;
+      },
+      apply(_tr, _set, _oldState, newState) {
+        const sel = newState.selection;
+        if (sel instanceof tables.CellSelection) return view.DecorationSet.empty;
+        const $from = sel.$from;
+        for (let d = $from.depth; d > 0; d--) {
+          const name = $from.node(d).type.name;
+          if (name === "tableCell" || name === "tableHeader") {
+            const pos = $from.before(d);
+            const deco = view.Decoration.node(pos, pos + $from.node(d).nodeSize, { class: "dm-cell-focused" });
+            return view.DecorationSet.create(newState.doc, [deco]);
+          }
+        }
+        return view.DecorationSet.empty;
+      }
+    },
+    props: {
+      decorations(state) {
+        return pluginKey.getState(state);
+      }
+    },
+    view: () => {
+      let lastToolbarView = null;
+      let lastHandleView = null;
+      let resizingView = null;
+      return {
+        update: (view) => {
+          const draggingCell = view.dom.querySelector(".column-resize-dragging");
+          if (draggingCell) {
+            const container = draggingCell.closest(".dm-table-container");
+            const tv = container ? tableViewMap.get(container) : void 0;
+            if (tv && tv !== resizingView) {
+              tv.hideForResize();
+              resizingView = tv;
+            }
+            return;
+          } else if (resizingView) {
+            resizingView.showAfterResize();
+            resizingView = null;
+          }
+          const sel = view.state.selection;
+          if (sel instanceof tables.CellSelection) {
+            const anchorPos = sel.$anchorCell.pos;
+            const el = domElementAt(view, anchorPos + 1);
+            const container = el?.closest(".dm-table-container");
+            const tv = container ? tableViewMap.get(container) : void 0;
+            if (tv) {
+              if (!tv.suppressCellToolbar) {
+                tv.updateCellHandle(true);
+              }
+              tv.hideCellHandle();
+              lastToolbarView = tv;
+            }
+            if (lastHandleView && lastHandleView !== tv) {
+              lastHandleView.hideCellHandle();
+            }
+            lastHandleView = null;
+          } else {
+            if (lastToolbarView) {
+              lastToolbarView.updateCellHandle(false);
+              lastToolbarView = null;
+            }
+            const $from = sel.$from;
+            let inCell = false;
+            for (let d = $from.depth; d > 0; d--) {
+              const name = $from.node(d).type.name;
+              if (name === "tableCell" || name === "tableHeader") {
+                inCell = true;
+                break;
+              }
+            }
+            if (inCell && sel.empty) {
+              const domEl = domElementAt(view, $from.pos);
+              const cellEl = domEl?.closest("td, th");
+              const container = cellEl?.closest(".dm-table-container");
+              const tv = container ? tableViewMap.get(container) : void 0;
+              if (tv && cellEl) {
+                tv.showCellHandle(cellEl);
+                if (lastHandleView && lastHandleView !== tv) {
+                  lastHandleView.hideCellHandle();
+                }
+                lastHandleView = tv;
+              }
+            } else {
+              if (lastHandleView) {
+                lastHandleView.hideCellHandle();
+                lastHandleView = null;
+              }
+            }
+          }
+        }
+      };
+    }
+  });
+}
+var TableRow = core.Node.create({
+  name: "tableRow",
+  content: "(tableCell | tableHeader)*",
+  tableRole: "row",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [{ tag: "tr" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["tr", { ...this.options.HTMLAttributes, ...HTMLAttributes }, 0];
+  }
+});
+
+// src/helpers/cellAttributes.ts
+function cellAttributes() {
+  return {
+    colspan: {
+      default: 1,
+      parseHTML: (element) => {
+        const colspan = element.getAttribute("colspan");
+        return colspan ? Number(colspan) : 1;
+      },
+      renderHTML: (attrs) => {
+        const colspan = attrs["colspan"];
+        if (colspan === 1) return null;
+        return { colspan };
+      }
+    },
+    rowspan: {
+      default: 1,
+      parseHTML: (element) => {
+        const rowspan = element.getAttribute("rowspan");
+        return rowspan ? Number(rowspan) : 1;
+      },
+      renderHTML: (attrs) => {
+        const rowspan = attrs["rowspan"];
+        if (rowspan === 1) return null;
+        return { rowspan };
+      }
+    },
+    colwidth: {
+      default: null,
+      parseHTML: (element) => {
+        const colwidth = element.getAttribute("data-colwidth");
+        return colwidth ? colwidth.split(",").map(Number) : null;
+      },
+      renderHTML: (attrs) => {
+        const colwidth = attrs["colwidth"];
+        if (!colwidth) return null;
+        return { "data-colwidth": colwidth.join(",") };
+      }
+    },
+    background: {
+      default: null,
+      parseHTML: (element) => {
+        return element.getAttribute("data-background") ?? (element.style.backgroundColor || null);
+      },
+      renderHTML: (attrs) => {
+        const bg = attrs["background"];
+        if (!bg) return null;
+        return { "data-background": bg, style: `background-color: ${bg}` };
+      }
+    },
+    textAlign: {
+      default: null,
+      parseHTML: (element) => {
+        return element.getAttribute("data-text-align") ?? null;
+      },
+      renderHTML: (attrs) => {
+        const align = attrs["textAlign"];
+        if (!align) return null;
+        return { "data-text-align": align };
+      }
+    },
+    verticalAlign: {
+      default: null,
+      parseHTML: (element) => {
+        return element.getAttribute("data-vertical-align") ?? null;
+      },
+      renderHTML: (attrs) => {
+        const align = attrs["verticalAlign"];
+        if (!align) return null;
+        return { "data-vertical-align": align };
+      }
+    }
+  };
+}
+
+// src/TableCell.ts
+var TableCell = core.Node.create({
+  name: "tableCell",
+  content: "block+",
+  tableRole: "cell",
+  isolating: true,
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  addAttributes() {
+    return cellAttributes();
+  },
+  parseHTML() {
+    return [{ tag: "td" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["td", { ...this.options.HTMLAttributes, ...HTMLAttributes }, 0];
+  }
+});
+var TableHeader = core.Node.create({
+  name: "tableHeader",
+  content: "block+",
+  tableRole: "header_cell",
+  isolating: true,
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  addAttributes() {
+    return cellAttributes();
+  },
+  parseHTML() {
+    return [{ tag: "th" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["th", { ...this.options.HTMLAttributes, ...HTMLAttributes }, 0];
+  }
+});
+
+// src/Table.ts
+var Table = core.Node.create({
+  name: "table",
+  group: "block",
+  content: "tableRow+",
+  tableRole: "table",
+  isolating: true,
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      cellMinWidth: 25,
+      defaultCellMinWidth: 100,
+      resizeBehavior: "neighbor",
+      constrainToContainer: true,
+      allowTableNodeSelection: false,
+      View: TableView
+    };
+  },
+  parseHTML() {
+    return [{ tag: "table" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["table", { ...this.options.HTMLAttributes, ...HTMLAttributes }, ["tbody", 0]];
+  },
+  addExtensions() {
+    return [TableRow, TableCell, TableHeader];
+  },
+  addNodeView() {
+    const ViewClass = this.options.View;
+    const cellMinWidth = this.options.cellMinWidth;
+    const defaultCellMinWidth = this.options.defaultCellMinWidth;
+    const constrainToContainer = this.options.constrainToContainer;
+    if (!ViewClass) {
+      return void 0;
+    }
+    return ((node, view) => new ViewClass(node, cellMinWidth, view, defaultCellMinWidth, constrainToContainer));
+  },
+  addCommands() {
+    return {
+      insertTable: (options) => ({ state: state$1, tr, dispatch }) => {
+        const $from = state$1.selection.$from;
+        for (let d = $from.depth; d > 0; d--) {
+          const node = $from.node(d);
+          if (node.type.name === "table") return false;
+          if (node.type.spec.code) return false;
+        }
+        const rows = options?.rows ?? 3;
+        const cols = options?.cols ?? 3;
+        const withHeaderRow = options?.withHeaderRow ?? true;
+        const table = createTable(state$1.schema, rows, cols, withHeaderRow);
+        if (!dispatch) {
+          return true;
+        }
+        const offset = tr.selection.from + 1;
+        tr.replaceSelectionWith(table).scrollIntoView().setSelection(state.TextSelection.near(tr.doc.resolve(offset)));
+        dispatch(tr);
+        return true;
+      },
+      deleteTable: () => ({ state, dispatch }) => {
+        return tables.deleteTable(state, dispatch);
+      },
+      addRowBefore: () => ({ state, dispatch }) => {
+        return tables.addRowBefore(state, dispatch);
+      },
+      addRowAfter: () => ({ state, dispatch }) => {
+        return tables.addRowAfter(state, dispatch);
+      },
+      deleteRow: () => ({ state, dispatch }) => {
+        if (!tables.isInTable(state)) return false;
+        const rect = tables.selectedRect(state);
+        if (rect.top === 0 && rect.bottom === rect.map.height) {
+          return tables.deleteTable(state, dispatch);
+        }
+        return tables.deleteRow(state, dispatch);
+      },
+      addColumnBefore: () => ({ state, dispatch, editor }) => {
+        if (!this.options.constrainToContainer || !dispatch) {
+          return tables.addColumnBefore(state, dispatch);
+        }
+        const view = editor.view;
+        return constrainedAddColumn(tables.addColumnBefore, view, this.options.cellMinWidth, this.options.defaultCellMinWidth);
+      },
+      addColumnAfter: () => ({ state, dispatch, editor }) => {
+        if (!this.options.constrainToContainer || !dispatch) {
+          return tables.addColumnAfter(state, dispatch);
+        }
+        const view = editor.view;
+        return constrainedAddColumn(tables.addColumnAfter, view, this.options.cellMinWidth, this.options.defaultCellMinWidth);
+      },
+      deleteColumn: () => ({ state: state$1, dispatch }) => {
+        if (!tables.isInTable(state$1)) return false;
+        const rect = tables.selectedRect(state$1);
+        if (rect.left === 0 && rect.right === rect.map.width) {
+          return tables.deleteTable(state$1, dispatch);
+        }
+        if (!dispatch) return true;
+        let captured;
+        tables.deleteColumn(state$1, (tr) => {
+          captured = tr;
+        });
+        if (!captured) return false;
+        const table = captured.doc.nodeAt(rect.tableStart - 1);
+        if (table) {
+          const map = tables.TableMap.get(table);
+          const targetCol = Math.min(rect.left, map.width - 1);
+          const cellOffset = map.map[targetCol];
+          if (cellOffset !== void 0) {
+            const $pos = captured.doc.resolve(rect.tableStart + cellOffset + 1);
+            captured.setSelection(state.TextSelection.near($pos));
+          }
+        }
+        dispatch(captured);
+        return true;
+      },
+      toggleHeaderRow: () => ({ state, dispatch }) => {
+        return tables.toggleHeader("row")(state, dispatch);
+      },
+      toggleHeaderColumn: () => ({ state, dispatch }) => {
+        return tables.toggleHeader("column")(state, dispatch);
+      },
+      toggleHeaderCell: () => ({ state, dispatch }) => {
+        return tables.toggleHeaderCell(state, dispatch);
+      },
+      mergeCells: () => ({ state, dispatch }) => {
+        return tables.mergeCells(state, dispatch);
+      },
+      splitCell: () => ({ state, dispatch }) => {
+        return tables.splitCell(state, dispatch);
+      },
+      setCellAttribute: (name, value) => ({ state, dispatch }) => {
+        return tables.setCellAttr(name, value)(state, dispatch);
+      },
+      goToNextCell: () => ({ state, dispatch }) => {
+        return tables.goToNextCell(1)(state, dispatch);
+      },
+      goToPreviousCell: () => ({ state, dispatch }) => {
+        return tables.goToNextCell(-1)(state, dispatch);
+      },
+      fixTables: () => ({ state, dispatch }) => {
+        if (dispatch) {
+          const tr = tables.fixTables(state);
+          if (tr) dispatch(tr);
+        }
+        return true;
+      },
+      setCellSelection: (position) => ({ tr, dispatch }) => {
+        const selection = tables.CellSelection.create(
+          tr.doc,
+          position.anchorCell,
+          position.headCell
+        );
+        tr.setSelection(selection);
+        if (dispatch) {
+          dispatch(tr);
+        }
+        return true;
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    const editor = this.editor;
+    const isInListItem = () => {
+      if (!editor) return false;
+      const { $from } = editor.state.selection;
+      for (let d = $from.depth; d >= 0; d--) {
+        const name = $from.node(d).type.name;
+        if (name === "listItem" || name === "taskItem") return true;
+      }
+      return false;
+    };
+    const deleteTableHandler = () => {
+      if (!editor) return false;
+      return deleteTableWhenAllCellsSelected({
+        state: editor.state,
+        dispatch: editor.view.dispatch
+      });
+    };
+    return {
+      Tab: () => {
+        if (!editor || isInListItem()) return false;
+        if (editor.commands["goToNextCell"]?.()) {
+          return true;
+        }
+        if (editor.commands["addRowAfter"]?.()) {
+          editor.commands["goToNextCell"]?.();
+          return true;
+        }
+        return false;
+      },
+      "Shift-Tab": () => {
+        if (!editor || isInListItem()) return false;
+        return editor.commands["goToPreviousCell"]?.() ?? false;
+      },
+      Backspace: deleteTableHandler,
+      "Mod-Backspace": deleteTableHandler,
+      Delete: deleteTableHandler,
+      "Mod-Delete": deleteTableHandler
+    };
+  },
+  addToolbarItems() {
+    return [
+      {
+        type: "button",
+        name: "insertTable",
+        command: "insertTable",
+        icon: "table",
+        label: "Insert Table",
+        group: "insert",
+        priority: 140
+      }
+    ];
+  },
+  addProseMirrorPlugins() {
+    return [
+      createResizeSuppressionPlugin({
+        resizeBehavior: this.options.resizeBehavior,
+        cellMinWidth: this.options.cellMinWidth,
+        defaultCellMinWidth: this.options.defaultCellMinWidth,
+        constrainToContainer: this.options.constrainToContainer
+      }),
+      tables.columnResizing({
+        cellMinWidth: this.options.cellMinWidth,
+        defaultCellMinWidth: this.options.defaultCellMinWidth
+      }),
+      tables.tableEditing({
+        allowTableNodeSelection: this.options.allowTableNodeSelection
+      }),
+      createCellSelectionPlugin()
+    ];
+  }
+});
+
+Object.defineProperty(exports, "CellSelection", {
+  enumerable: true,
+  get: function () { return tables.CellSelection; }
+});
+Object.defineProperty(exports, "TableMap", {
+  enumerable: true,
+  get: function () { return tables.TableMap; }
+});
+exports.Table = Table;
+exports.TableCell = TableCell;
+exports.TableHeader = TableHeader;
+exports.TableRow = TableRow;
+exports.TableView = TableView;
+exports.createTable = createTable;
+exports.deleteTableWhenAllCellsSelected = deleteTableWhenAllCellsSelected;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map