@milkdown/preset-gfm 6.1.5 → 6.2.0

package/lib/index.es.js

@@ -24,27 +24,33 @@ import remarkGFM from "remark-gfm";
 import { inputRules, InputRule, wrappingInputRule } from "@milkdown/prose/inputrules";
 import { createCmdKey, editorViewCtx, createCmd, commandsCtx, themeManagerCtx, ThemeIcon, ThemeBorder, ThemeShadow, getPalette, ThemeSize, schemaCtx } from "@milkdown/core";
 import { findSelectedNodeOfType, findParentNode, cloneTr, calculateNodePosition, markRule } from "@milkdown/prose";
-import { PluginKey, NodeSelection, Plugin, Selection, TextSelection } from "@milkdown/prose/state";
+import { PluginKey, NodeSelection, Plugin, Selection, SelectionRange, TextSelection } from "@milkdown/prose/state";
 import { toggleMark, wrapIn } from "@milkdown/prose/commands";
-import { isInTable, TableMap, CellSelection, tableNodeTypes, addColumnBefore, addColumnAfter, selectedRect, setCellAttr, deleteTable, deleteColumn, deleteRow, tableNodes, goToNextCell, columnResizing, tableEditing } from "@milkdown/prose/tables";
+import { Fragment, Slice } from "@milkdown/prose/model";
 import { Decoration, DecorationSet } from "@milkdown/prose/view";
+import { keydownHandler } from "@milkdown/prose/keymap";
+import { Transform } from "@milkdown/prose/transform";
 import { splitListItem, sinkListItem, liftListItem } from "@milkdown/prose/schema-list";
 const urlRegex = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&//=]*)$/;
 const proseUrlPlugin = () => inputRules({
   rules: [
     new InputRule(urlRegex, (state, match, start, end) => {
+      var _a;
       const { schema: schema2 } = state;
       const [text2] = match;
       if (!text2)
         return null;
-      return state.tr.replaceWith(start, end, schema2.text(text2)).addMark(start, text2.length + start, schema2.marks.link.create({ href: text2 }));
+      const link2 = (_a = schema2.marks["link"]) == null ? void 0 : _a.create({ href: text2 });
+      if (!link2)
+        return null;
+      return state.tr.replaceWith(start, end, schema2.text(text2)).addMark(start, text2.length + start, link2);
     })
   ]
 });
 const urlPlugin = $prose(() => proseUrlPlugin());
 const getFootnoteRefId = (label) => `footnote-ref-${label}`;
 const getFootnoteDefId = (label) => `footnote-def-${label}`;
-const key$1 = new PluginKey("MILKDOWN_FOOTNOTE_DEF_INPUT");
+const key$2 = new PluginKey("MILKDOWN_FOOTNOTE_DEF_INPUT");
 const ModifyFootnoteDef = createCmdKey("ModifyFootnoteDef");
 const footnoteDefinition = createNode((utils) => {
   const id2 = "footnote_definition";
@@ -143,7 +149,7 @@ const footnoteDefinition = createNode((utils) => {
     prosePlugins: (type, ctx) => {
       return [
         new Plugin({
-          key: key$1,
+          key: key$2,
           view: (editorView) => {
             const inputChipRenderer = utils.themeManager.get("input-chip", {
               width: "12em",
@@ -195,7 +201,7 @@ const footnoteDefinition = createNode((utils) => {
   };
 });
 const ModifyFootnoteRef = createCmdKey("ModifyFootnoteRef");
-const key = new PluginKey("MILKDOWN_FOOTNOTE_REF_INPUT");
+const key$1 = new PluginKey("MILKDOWN_FOOTNOTE_REF_INPUT");
 const footnoteReference = createNode((utils) => {
   const id2 = "footnote_reference";
   return {
@@ -326,7 +332,7 @@ const footnoteReference = createNode((utils) => {
       };
       return [
         new Plugin({
-          key,
+          key: key$1,
           view: (editorView) => {
             inputChipRenderer.init(editorView);
             renderByView(editorView);
@@ -347,6 +353,684 @@ const footnoteReference = createNode((utils) => {
     }
   };
 });
+const cache = /* @__PURE__ */ new WeakMap();
+const readFromCache = (key2) => cache.get(key2);
+const addToCache = (key2, value) => {
+  cache.set(key2, value);
+  return value;
+};
+class Rect {
+  constructor(left, top, right, bottom) {
+    this.left = left;
+    this.top = top;
+    this.right = right;
+    this.bottom = bottom;
+  }
+}
+class TableMap {
+  constructor(width, height, map, problems) {
+    this.width = width;
+    this.height = height;
+    this.map = map;
+    this.problems = problems;
+    this.width = width;
+    this.height = height;
+    this.map = map;
+    this.problems = problems;
+  }
+  findCell(pos) {
+    for (let i = 0; i < this.map.length; i++) {
+      const curPos = this.map[i];
+      if (curPos != pos)
+        continue;
+      const left = i % this.width, top = i / this.width | 0;
+      let right = left + 1, bottom = top + 1;
+      for (let j = 1; right < this.width && this.map[i + j] == curPos; j++)
+        right++;
+      for (let j = 1; bottom < this.height && this.map[i + this.width * j] == curPos; j++)
+        bottom++;
+      return new Rect(left, top, right, bottom);
+    }
+    throw new RangeError("No cell with offset " + pos + " found");
+  }
+  colCount(pos) {
+    for (let i = 0; i < this.map.length; i++)
+      if (this.map[i] == pos)
+        return i % this.width;
+    throw new RangeError("No cell with offset " + pos + " found");
+  }
+  nextCell(pos, axis, dir) {
+    const { left, right, top, bottom } = this.findCell(pos);
+    if (axis == "horiz") {
+      if (dir < 0 ? left == 0 : right == this.width)
+        return void 0;
+      return this.map[top * this.width + (dir < 0 ? left - 1 : right)];
+    } else {
+      if (dir < 0 ? top == 0 : bottom == this.height)
+        return void 0;
+      return this.map[left + this.width * (dir < 0 ? top - 1 : bottom)];
+    }
+  }
+  rectBetween(a, b) {
+    const { left: leftA, right: rightA, top: topA, bottom: bottomA } = this.findCell(a);
+    const { left: leftB, right: rightB, top: topB, bottom: bottomB } = this.findCell(b);
+    return new Rect(Math.min(leftA, leftB), Math.min(topA, topB), Math.max(rightA, rightB), Math.max(bottomA, bottomB));
+  }
+  cellsInRect(rect) {
+    const result = [], seen = {};
+    for (let row = rect.top; row < rect.bottom; row++) {
+      for (let col = rect.left; col < rect.right; col++) {
+        const index = row * this.width + col, pos = this.map[index];
+        if (seen[pos])
+          continue;
+        seen[pos] = true;
+        if ((col != rect.left || !col || this.map[index - 1] != pos) && (row != rect.top || !row || this.map[index - this.width] != pos))
+          result.push(pos);
+      }
+    }
+    return result;
+  }
+  positionAt(row, col, table2) {
+    for (let i = 0, rowStart = 0; ; i++) {
+      const rowEnd = rowStart + table2.child(i).nodeSize;
+      if (i == row) {
+        let index = col + row * this.width;
+        const rowEndIndex = (row + 1) * this.width;
+        while (index < rowEndIndex && this.map[index] < rowStart)
+          index++;
+        return index == rowEndIndex ? rowEnd - 1 : this.map[index];
+      }
+      rowStart = rowEnd;
+    }
+  }
+  static get(table2) {
+    return readFromCache(table2) || addToCache(table2, computeMap(table2));
+  }
+}
+function computeMap(table2) {
+  if (table2.type.spec["tableRole"] != "table")
+    throw new RangeError("Not a table node: " + table2.type.name);
+  const width = findWidth(table2), height = table2.childCount;
+  const map = [];
+  const colWidths = [];
+  let mapPos = 0, problems = void 0;
+  for (let i = 0, e = width * height; i < e; i++)
+    map[i] = 0;
+  for (let row = 0, pos = 0; row < height; row++) {
+    const rowNode = table2.child(row);
+    pos++;
+    for (let i = 0; ; i++) {
+      while (mapPos < map.length && map[mapPos] != 0)
+        mapPos++;
+      if (i == rowNode.childCount)
+        break;
+      const cellNode = rowNode.child(i), { colspan, rowspan, colwidth } = cellNode.attrs;
+      for (let h = 0; h < rowspan; h++) {
+        if (h + row >= height) {
+          (problems || (problems = [])).push({
+            type: "overlong_rowspan",
+            pos,
+            n: rowspan - h
+          });
+          break;
+        }
+        const start = mapPos + h * width;
+        for (let w = 0; w < colspan; w++) {
+          if (map[start + w] == 0)
+            map[start + w] = pos;
+          else
+            (problems || (problems = [])).push({
+              type: "collision",
+              row,
+              pos,
+              n: colspan - w
+            });
+          const colW = colwidth && colwidth[w];
+          if (colW) {
+            const widthIndex = (start + w) % width * 2, prev = colWidths[widthIndex];
+            if (prev == null || prev != colW && colWidths[widthIndex + 1] == 1) {
+              colWidths[widthIndex] = colW;
+              colWidths[widthIndex + 1] = 1;
+            } else if (prev == colW) {
+              colWidths[widthIndex + 1]++;
+            }
+          }
+        }
+      }
+      mapPos += colspan;
+      pos += cellNode.nodeSize;
+    }
+    const expectedPos = (row + 1) * width;
+    let missing = 0;
+    while (mapPos < expectedPos)
+      if (map[mapPos++] == 0)
+        missing++;
+    if (missing)
+      (problems || (problems = [])).push({ type: "missing", row, n: missing });
+    pos++;
+  }
+  const tableMap = new TableMap(width, height, map, problems);
+  let badWidths = false;
+  for (let i = 0; !badWidths && i < colWidths.length; i += 2)
+    if (colWidths[i] != null && colWidths[i + 1] < height)
+      badWidths = true;
+  if (badWidths)
+    findBadColWidths(tableMap, colWidths, table2);
+  return tableMap;
+}
+function findWidth(table2) {
+  let width = -1, hasRowSpan = false;
+  for (let row = 0; row < table2.childCount; row++) {
+    const rowNode = table2.child(row);
+    let rowWidth = 0;
+    if (hasRowSpan)
+      for (let j = 0; j < row; j++) {
+        const prevRow = table2.child(j);
+        for (let i = 0; i < prevRow.childCount; i++) {
+          const cell = prevRow.child(i);
+          if (j + cell.attrs["rowspan"] > row)
+            rowWidth += cell.attrs["colspan"];
+        }
+      }
+    for (let i = 0; i < rowNode.childCount; i++) {
+      const cell = rowNode.child(i);
+      rowWidth += cell.attrs["colspan"];
+      if (cell.attrs["rowspan"] > 1)
+        hasRowSpan = true;
+    }
+    if (width == -1)
+      width = rowWidth;
+    else if (width != rowWidth)
+      width = Math.max(width, rowWidth);
+  }
+  return width;
+}
+function findBadColWidths(map, colWidths, table2) {
+  if (!map.problems)
+    map.problems = [];
+  for (let i = 0, seen = {}; i < map.map.length; i++) {
+    const pos = map.map[i];
+    if (seen[pos])
+      continue;
+    seen[pos] = true;
+    const node = table2.nodeAt(pos);
+    let updated = null;
+    for (let j = 0; j < node.attrs["colspan"]; j++) {
+      const col = (i + j) % map.width, colWidth = colWidths[col * 2];
+      if (colWidth != null && (!node.attrs["colwidth"] || node.attrs["colwidth"][j] != colWidth))
+        (updated || (updated = freshColWidth(node.attrs)))[j] = colWidth;
+    }
+    if (updated)
+      map.problems.unshift({
+        type: "colwidth mismatch",
+        pos,
+        colwidth: updated
+      });
+  }
+}
+function freshColWidth(attrs) {
+  if (attrs["colwidth"])
+    return attrs["colwidth"].slice();
+  const result = [];
+  for (let i = 0; i < attrs["colspan"]; i++)
+    result.push(0);
+  return result;
+}
+class CellSelection extends Selection {
+  constructor($anchorCell, $headCell = $anchorCell) {
+    const table2 = $anchorCell.node(-1), map = TableMap.get(table2), start = $anchorCell.start(-1);
+    const rect = map.rectBetween($anchorCell.pos - start, $headCell.pos - start);
+    const doc2 = $anchorCell.node(0);
+    const cells = map.cellsInRect(rect).filter((p) => p != $headCell.pos - start);
+    cells.unshift($headCell.pos - start);
+    const ranges = cells.map((pos) => {
+      const cell = table2.nodeAt(pos), from = pos + start + 1;
+      return new SelectionRange(doc2.resolve(from), doc2.resolve(from + cell.content.size));
+    });
+    super(ranges[0].$from, ranges[0].$to, ranges);
+    this.$anchorCell = $anchorCell;
+    this.$headCell = $headCell;
+    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);
+  }
+  content() {
+    const table2 = this.$anchorCell.node(-1), map = TableMap.get(table2), start = this.$anchorCell.start(-1);
+    const rect = map.rectBetween(this.$anchorCell.pos - start, this.$headCell.pos - start);
+    const seen = {}, rows = [];
+    for (let row = rect.top; row < rect.bottom; row++) {
+      const rowContent = [];
+      for (let index = row * map.width + rect.left, col = rect.left; col < rect.right; col++, index++) {
+        const pos = map.map[index];
+        if (!seen[pos]) {
+          seen[pos] = true;
+          const cellRect = map.findCell(pos);
+          let cell = table2.nodeAt(pos);
+          const extraLeft = rect.left - cellRect.left, 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);
+            else
+              cell = cell.type.create(attrs, cell.content);
+          }
+          if (cellRect.top < rect.top || cellRect.bottom > rect.bottom) {
+            const attrs = setAttr(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(table2.child(row).copy(Fragment.from(rowContent)));
+    }
+    const fragment = this.isColSelection() && this.isRowSelection() ? table2 : rows;
+    return new Slice(Fragment.from(fragment), 1, 1);
+  }
+  replace(tr, content = Slice.empty) {
+    const mapFrom = tr.steps.length, ranges = this.ranges;
+    for (let i = 0; i < ranges.length; i++) {
+      const { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);
+      tr.replace(mapping.map($from.pos), mapping.map($to.pos), i ? Slice.empty : content);
+    }
+    const sel = Selection.findFrom(tr.doc.resolve(tr.mapping.slice(mapFrom).map(this.to)), -1);
+    if (sel)
+      tr.setSelection(sel);
+  }
+  replaceWith(tr, node) {
+    this.replace(tr, new Slice(Fragment.from(node), 0, 0));
+  }
+  forEachCell(f) {
+    const table2 = this.$anchorCell.node(-1), map = TableMap.get(table2), start = this.$anchorCell.start(-1);
+    const cells = map.cellsInRect(map.rectBetween(this.$anchorCell.pos - start, this.$headCell.pos - start));
+    for (let i = 0; i < cells.length; i++)
+      f(table2.nodeAt(cells[i]), start + cells[i]);
+  }
+  isColSelection() {
+    const anchorTop = this.$anchorCell.index(-1), headTop = this.$headCell.index(-1);
+    if (Math.min(anchorTop, headTop) > 0)
+      return false;
+    const anchorBot = anchorTop + this.$anchorCell.nodeAfter.attrs["rowspan"], headBot = headTop + this.$headCell.nodeAfter.attrs["rowspan"];
+    return Math.max(anchorBot, headBot) == this.$headCell.node(-1).childCount;
+  }
+  static colSelection($anchorCell, $headCell = $anchorCell) {
+    const map = TableMap.get($anchorCell.node(-1)), start = $anchorCell.start(-1);
+    const anchorRect = map.findCell($anchorCell.pos - start), headRect = map.findCell($headCell.pos - start);
+    const doc2 = $anchorCell.node(0);
+    if (anchorRect.top <= headRect.top) {
+      if (anchorRect.top > 0) {
+        const left = map.map[anchorRect.left];
+        $anchorCell = doc2.resolve(start + left);
+      }
+      if (headRect.bottom < map.height) {
+        const pos = map.map[map.width * (map.height - 1) + headRect.right - 1];
+        $headCell = doc2.resolve(start + pos);
+      }
+    } else {
+      if (headRect.top > 0) {
+        const left = map.map[anchorRect.left];
+        $headCell = doc2.resolve(start + left);
+      }
+      if (anchorRect.bottom < map.height) {
+        const pos = map.map[map.width * (map.height - 1) + anchorRect.right - 1];
+        $anchorCell = doc2.resolve(start + pos);
+      }
+    }
+    return new CellSelection($anchorCell, $headCell);
+  }
+  isRowSelection() {
+    const map = TableMap.get(this.$anchorCell.node(-1)), start = this.$anchorCell.start(-1);
+    const anchorLeft = map.colCount(this.$anchorCell.pos - start), headLeft = map.colCount(this.$headCell.pos - start);
+    if (Math.min(anchorLeft, headLeft) > 0)
+      return false;
+    const anchorRight = anchorLeft + this.$anchorCell.nodeAfter.attrs["colspan"], headRight = headLeft + this.$headCell.nodeAfter.attrs["colspan"];
+    return Math.max(anchorRight, headRight) == map.width;
+  }
+  eq(other) {
+    return other instanceof CellSelection && other.$anchorCell.pos == this.$anchorCell.pos && other.$headCell.pos == this.$headCell.pos;
+  }
+  static rowSelection($anchorCell, $headCell = $anchorCell) {
+    const map = TableMap.get($anchorCell.node(-1)), start = $anchorCell.start(-1);
+    const anchorRect = map.findCell($anchorCell.pos - start), headRect = map.findCell($headCell.pos - start);
+    const doc2 = $anchorCell.node(0);
+    if (anchorRect.left <= headRect.left) {
+      if (anchorRect.left > 0) {
+        const pos = map.map[anchorRect.top * map.width];
+        $anchorCell = doc2.resolve(start + pos);
+      }
+      if (headRect.right < map.width) {
+        const pos = map.map[map.width * (headRect.top + 1) - 1];
+        $headCell = doc2.resolve(start + pos);
+      }
+    } else {
+      if (headRect.left > 0) {
+        const pos = map.map[headRect.top * map.width];
+        $headCell = doc2.resolve(start + pos);
+      }
+      if (anchorRect.right < map.width) {
+        const pos = map.map[map.width * (anchorRect.top + 1) - 1];
+        $anchorCell = doc2.resolve(start + pos);
+      }
+    }
+    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.jsonID("cell", CellSelection);
+class CellBookmark {
+  constructor(anchor, head) {
+    this.anchor = anchor;
+    this.head = 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.near($headCell, 1);
+  }
+}
+function drawCellSelection(state) {
+  if (!(state.selection instanceof CellSelection))
+    return null;
+  const cells = [];
+  state.selection.forEachCell((node, pos) => {
+    cells.push(Decoration.node(pos, pos + node.nodeSize, { class: "selectedCell" }));
+  });
+  return DecorationSet.create(state.doc, cells);
+}
+function isCellBoundarySelection({ $from, $to }) {
+  if ($from.pos == $to.pos || $from.pos < $from.pos - 6)
+    return false;
+  let afterFrom = $from.pos, beforeTo = $to.pos, depth = $from.depth;
+  for (; depth >= 0; depth--, afterFrom++)
+    if ($from.after(depth + 1) < $from.end(depth))
+      break;
+  for (let d = $to.depth; d >= 0; d--, beforeTo--)
+    if ($to.before(d + 1) > $to.start(d))
+      break;
+  return afterFrom == beforeTo && /row|table/.test($from.node(depth).type.spec["tableRole"]);
+}
+function isTextSelectionAcrossCells({ $from, $to }) {
+  let fromCellBoundaryNode;
+  let toCellBoundaryNode;
+  for (let i = $from.depth; i > 0; i--) {
+    const node = $from.node(i);
+    if (node.type.spec["tableRole"] === "cell" || node.type.spec["tableRole"] === "header_cell") {
+      fromCellBoundaryNode = node;
+      break;
+    }
+  }
+  for (let i = $to.depth; i > 0; i--) {
+    const node = $to.node(i);
+    if (node.type.spec["tableRole"] === "cell" || node.type.spec["tableRole"] === "header_cell") {
+      toCellBoundaryNode = node;
+      break;
+    }
+  }
+  return fromCellBoundaryNode !== toCellBoundaryNode && $to.parentOffset === 0;
+}
+function normalizeSelection(state, tr, allowTableNodeSelection) {
+  const sel = (tr || state).selection, doc2 = (tr || state).doc;
+  let normalize, role;
+  if (sel instanceof NodeSelection && (role = sel.node.type.spec["tableRole"])) {
+    if (role == "cell" || role == "header_cell") {
+      normalize = CellSelection.create(doc2, sel.from);
+    } else if (role == "row") {
+      const $cell = doc2.resolve(sel.from + 1);
+      normalize = CellSelection.rowSelection($cell, $cell);
+    } else if (!allowTableNodeSelection) {
+      const map = TableMap.get(sel.node), start = sel.from + 1;
+      const pos = map.map[map.width * map.height - 1];
+      const lastCell = start + pos;
+      normalize = CellSelection.create(doc2, start + 1, lastCell);
+    }
+  } else if (sel instanceof TextSelection && isCellBoundarySelection(sel)) {
+    normalize = TextSelection.create(doc2, sel.from);
+  } else if (sel instanceof TextSelection && isTextSelectionAcrossCells(sel)) {
+    normalize = TextSelection.create(doc2, sel.$from.start(), sel.$from.end());
+  }
+  if (normalize)
+    (tr || (tr = state.tr)).setSelection(normalize);
+  return tr;
+}
+function getCellAttrs(dom, extraAttrs) {
+  const widthAttr = dom.getAttribute("data-colwidth");
+  const widths = widthAttr && /^\d+(,\d+)*$/.test(widthAttr) ? widthAttr.split(",").map((s) => Number(s)) : null;
+  const colspan = Number(dom.getAttribute("colspan") || 1);
+  const result = {
+    colspan,
+    rowspan: Number(dom.getAttribute("rowspan") || 1),
+    colwidth: widths && widths.length == colspan ? widths : null
+  };
+  for (const prop in extraAttrs) {
+    const getter = extraAttrs[prop].getFromDOM;
+    const value = getter && getter(dom);
+    if (value != null)
+      result[prop] = value;
+  }
+  return result;
+}
+function setCellAttrs(node, extraAttrs) {
+  const attrs = {};
+  if (node.attrs["colspan"] != 1)
+    attrs["colspan"] = node.attrs["colspan"];
+  if (node.attrs["rowspan"] != 1)
+    attrs["rowspan"] = node.attrs["rowspan"];
+  if (node.attrs["colwidth"])
+    attrs["data-colwidth"] = node.attrs["colwidth"].join(",");
+  for (const prop in extraAttrs) {
+    const setter = extraAttrs[prop].setDOMAttr;
+    if (setter)
+      setter(node.attrs[prop], attrs);
+  }
+  return attrs;
+}
+function tableNodesSpecCreator(options) {
+  const extraAttrs = options.cellAttributes || {};
+  const cellAttrs = {
+    colspan: { default: 1 },
+    rowspan: { default: 1 },
+    colwidth: { default: null }
+  };
+  for (const prop in extraAttrs)
+    cellAttrs[prop] = { default: extraAttrs[prop].default };
+  const finalAttrs = cellAttrs;
+  const schema2 = {
+    table: {
+      content: "table_row+",
+      tableRole: "table",
+      isolating: true,
+      group: options.tableGroup,
+      parseDOM: [{ tag: "table" }],
+      toDOM() {
+        return ["table", ["tbody", 0]];
+      }
+    },
+    table_row: {
+      content: "(table_cell | table_header)*",
+      tableRole: "row",
+      parseDOM: [{ tag: "tr" }],
+      toDOM() {
+        return ["tr", 0];
+      }
+    },
+    table_cell: {
+      content: options.cellContent,
+      attrs: finalAttrs,
+      tableRole: "cell",
+      isolating: true,
+      parseDOM: [{ tag: "td", getAttrs: (dom) => getCellAttrs(dom, extraAttrs) }],
+      toDOM(node) {
+        return ["td", setCellAttrs(node, extraAttrs), 0];
+      }
+    },
+    table_header: {
+      content: options.cellContent,
+      attrs: finalAttrs,
+      tableRole: "header_cell",
+      isolating: true,
+      parseDOM: [{ tag: "th", getAttrs: (dom) => getCellAttrs(dom, extraAttrs) }],
+      toDOM(node) {
+        return ["th", setCellAttrs(node, extraAttrs), 0];
+      }
+    }
+  };
+  return schema2;
+}
+function tableNodeTypes(schema2) {
+  let result = schema2.cached["tableNodeTypes"];
+  if (!result) {
+    result = schema2.cached["tableNodeTypes"] = {};
+    for (const name in schema2.nodes) {
+      const type = schema2.nodes[name], role = type == null ? void 0 : type.spec["tableRole"];
+      if (role)
+        result[role] = type;
+    }
+  }
+  return result;
+}
+const schema = tableNodesSpecCreator({
+  tableGroup: "block",
+  cellContent: "paragraph",
+  cellAttributes: {
+    alignment: {
+      default: "left",
+      getFromDOM: (dom) => dom.style.textAlign || "left",
+      setDOMAttr: (value, attrs) => {
+        attrs["style"] = `text-align: ${value || "left"}`;
+      }
+    }
+  }
+});
+function cellAround($pos) {
+  for (let d = $pos.depth - 1; d > 0; d--)
+    if ($pos.node(d).type.spec["tableRole"] == "row")
+      return $pos.node(0).resolve($pos.before(d + 1));
+  return void 0;
+}
+function pointsAtCell($pos) {
+  if ($pos.parent.type.spec["tableRole"] == "row")
+    return $pos.nodeAfter;
+  return null;
+}
+function moveCellForward($pos) {
+  return $pos.node(0).resolve($pos.pos + $pos.nodeAfter.nodeSize);
+}
+function inSameTable($a, $b) {
+  return $a.depth == $b.depth && $a.pos >= $b.start(-1) && $a.pos <= $b.end(-1);
+}
+function nextCell($pos, axis, dir) {
+  const start = $pos.start(-1), map = TableMap.get($pos.node(-1));
+  const moved = map.nextCell($pos.pos - start, axis, dir);
+  return moved == null ? null : $pos.node(0).resolve(start + moved);
+}
+function setAttr(attrs, name, value) {
+  const result = {};
+  for (const prop in attrs)
+    result[prop] = attrs[prop];
+  result[name] = value;
+  return result;
+}
+function removeColSpan(attrs, pos, n = 1) {
+  const result = setAttr(attrs, "colspan", attrs["colspan"] - n);
+  if (result["colwidth"]) {
+    const widths = result["colwidth"];
+    result["colwidth"] = widths.slice();
+    widths.splice(pos, n);
+    if (!widths.some((w) => w > 0))
+      result["colwidth"] = null;
+  }
+  return result;
+}
+function isInTable(state) {
+  const $head = state.selection.$head;
+  for (let d = $head.depth; d > 0; d--)
+    if ($head.node(d).type.spec["tableRole"] == "row")
+      return true;
+  return false;
+}
+function selectionCell(state) {
+  const sel = state.selection;
+  if (sel instanceof CellSelection) {
+    return sel.$anchorCell.pos > sel.$headCell.pos ? sel.$anchorCell : sel.$headCell;
+  } else if (sel.node && sel.node.type.spec["tableRole"] == "cell") {
+    return sel.$anchor;
+  }
+  return cellAround(sel.$head) || cellNear(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);
+  }
+  return;
+}
+function addColSpan(attrs, pos, n = 1) {
+  const result = setAttr(attrs, "colspan", attrs["colspan"] + n);
+  if (result["colwidth"]) {
+    const widths = result["colwidth"];
+    result["colwidth"] = widths.slice();
+    for (let i = 0; i < n; i++)
+      widths.splice(pos, 0, 0);
+  }
+  return result;
+}
+function columnIsHeader(map, table2, col) {
+  const headerCell = tableNodeTypes(table2.type.schema).header_cell;
+  for (let row = 0; row < map.height; row++) {
+    const pos = map.map[col + row * map.width];
+    if (table2.nodeAt(pos).type != headerCell)
+      return false;
+  }
+  return true;
+}
 const exitTable = (node) => (state, dispatch) => {
   if (!isInTable(state)) {
     return false;
@@ -835,19 +1519,990 @@ const operatorPlugin = (ctx, utils) => {
     }
   });
 };
-const schema = tableNodes({
-  tableGroup: "block",
-  cellContent: "paragraph",
-  cellAttributes: {
-    alignment: {
-      default: "left",
-      getFromDOM: (dom) => dom.style.textAlign || "left",
-      setDOMAttr: (value, attrs) => {
-        attrs.style = `text-align: ${value || "left"}`;
+class TableView {
+  constructor(node, cellMinWidth) {
+    this.node = node;
+    this.cellMinWidth = 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(record) {
+    return record.type == "attributes" && (record.target == this.table || this.colgroup.contains(record.target));
+  }
+}
+function updateColumns(node, colgroup, table2, cellMinWidth, overrideCol, overrideValue) {
+  var _a;
+  let totalWidth = 0, fixedWidth = true;
+  let nextDOM = colgroup.firstChild;
+  const row = node.firstChild;
+  for (let i = 0, col = 0; i < row.childCount; i++) {
+    const { colspan, colwidth } = row.child(i).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;
+    (_a = nextDOM.parentNode) == null ? void 0 : _a.removeChild(nextDOM);
+    nextDOM = after;
+  }
+  if (fixedWidth) {
+    table2.style.width = totalWidth + "px";
+    table2.style.minWidth = "";
+  } else {
+    table2.style.width = "";
+    table2.style.minWidth = totalWidth + "px";
+  }
+}
+const key = new PluginKey("tableColumnResizing");
+function columnResizing({
+  handleWidth = 5,
+  cellMinWidth = 25,
+  View = TableView,
+  lastColumnResizable = true
+} = {}) {
+  const plugin = new Plugin({
+    key,
+    state: {
+      init(_, state) {
+        this.spec.props.nodeViews[tableNodeTypes(state.schema).table.name] = (node) => new View(node, cellMinWidth);
+        return new ResizeState(-1, false);
+      },
+      apply(tr, prev) {
+        return prev.apply(tr);
+      }
+    },
+    props: {
+      attributes(state) {
+        const pluginState = key.getState(state);
+        return pluginState.activeHandle > -1 ? { class: "resize-cursor" } : void 0;
+      },
+      handleDOMEvents: {
+        mousemove(view, event) {
+          handleMouseMove(view, event, handleWidth, lastColumnResizable);
+        },
+        mouseleave(view) {
+          handleMouseLeave(view);
+        },
+        mousedown(view, event) {
+          handleMouseDown$1(view, event, cellMinWidth);
+        }
+      },
+      decorations(state) {
+        const pluginState = key.getState(state);
+        if (pluginState.activeHandle > -1)
+          return handleDecorations(state, pluginState.activeHandle);
+        return null;
+      },
+      nodeViews: {}
+    }
+  });
+  return plugin;
+}
+class ResizeState {
+  constructor(activeHandle, dragging) {
+    this.activeHandle = activeHandle;
+    this.dragging = dragging;
+    this.activeHandle = activeHandle;
+    this.dragging = dragging;
+  }
+  apply(tr) {
+    let state = this;
+    const action = tr.getMeta(key);
+    if (action && action.setHandle != null)
+      return new ResizeState(action.setHandle, null);
+    if (action && action.setDragging !== void 0)
+      return new ResizeState(state.activeHandle, action.setDragging);
+    if (state.activeHandle > -1 && tr.docChanged) {
+      let handle = tr.mapping.map(state.activeHandle, -1);
+      if (!pointsAtCell(tr.doc.resolve(handle)))
+        handle = 0;
+      state = new ResizeState(handle, state.dragging);
+    }
+    return state;
+  }
+}
+function handleMouseMove(view, event, handleWidth, lastColumnResizable) {
+  const pluginState = key.getState(view.state);
+  if (!pluginState.dragging) {
+    const target = domCellAround(event.target);
+    let cell = -1;
+    if (target) {
+      const { left, right } = target.getBoundingClientRect();
+      if (event.clientX - left <= handleWidth)
+        cell = edgeCell(view, event, "left");
+      else if (right - event.clientX <= handleWidth)
+        cell = edgeCell(view, event, "right");
+    }
+    if (cell != pluginState.activeHandle) {
+      if (!lastColumnResizable && cell !== -1) {
+        const $cell = view.state.doc.resolve(cell);
+        const table2 = $cell.node(-1), map = TableMap.get(table2), start = $cell.start(-1);
+        const col = map.colCount($cell.pos - start) + $cell.nodeAfter.attrs["colspan"] - 1;
+        if (col == map.width - 1) {
+          return;
+        }
+      }
+      updateHandle(view, cell);
+    }
+  }
+}
+function handleMouseLeave(view) {
+  const pluginState = key.getState(view.state);
+  if (pluginState.activeHandle > -1 && !pluginState.dragging)
+    updateHandle(view, -1);
+}
+function handleMouseDown$1(view, event, cellMinWidth) {
+  const pluginState = key.getState(view.state);
+  if (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(key, {
+    setDragging: { startX: event.clientX, startWidth: width }
+  }));
+  function finish(event2) {
+    window.removeEventListener("mouseup", finish);
+    window.removeEventListener("mousemove", move);
+    const pluginState2 = key.getState(view.state);
+    if (pluginState2.dragging) {
+      updateColumnWidth(view, pluginState2.activeHandle, draggedWidth(pluginState2.dragging, event2, cellMinWidth));
+      view.dispatch(view.state.tr.setMeta(key, { setDragging: null }));
+    }
+  }
+  function move(event2) {
+    if (!event2.which)
+      return finish(event2);
+    const pluginState2 = key.getState(view.state);
+    const dragged = draggedWidth(pluginState2.dragging, event2, cellMinWidth);
+    displayColumnWidth(view, pluginState2.activeHandle, dragged, cellMinWidth);
+  }
+  window.addEventListener("mouseup", finish);
+  window.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 i = 0; i < colspan; i++)
+      if (colwidth[i]) {
+        domWidth -= colwidth[i];
+        parts--;
+      }
+  }
+  return domWidth / parts;
+}
+function domCellAround(target) {
+  while (target && target.nodeName != "TD" && target.nodeName != "TH")
+    target = target.classList.contains("ProseMirror") ? null : target.parentNode;
+  return target;
+}
+function edgeCell(view, event, side) {
+  const found = view.posAtCoords({ left: event.clientX, top: event.clientY });
+  if (!found)
+    return -1;
+  const { pos } = found;
+  const $cell = cellAround(view.state.doc.resolve(pos));
+  if (!$cell)
+    return -1;
+  if (side == "right")
+    return $cell.pos;
+  const map = TableMap.get($cell.node(-1)), start = $cell.start(-1);
+  const index = map.map.indexOf($cell.pos - start);
+  return index % map.width == 0 ? -1 : start + map.map[index - 1];
+}
+function draggedWidth(dragging, event, cellMinWidth) {
+  const offset = event.clientX - dragging.startX;
+  return Math.max(cellMinWidth, dragging.startWidth + offset);
+}
+function updateHandle(view, value) {
+  view.dispatch(view.state.tr.setMeta(key, { setHandle: value }));
+}
+function updateColumnWidth(view, cell, width) {
+  const $cell = view.state.doc.resolve(cell);
+  const table2 = $cell.node(-1), map = TableMap.get(table2), start = $cell.start(-1);
+  const col = map.colCount($cell.pos - start) + $cell.nodeAfter.attrs["colspan"] - 1;
+  const tr = view.state.tr;
+  for (let row = 0; row < map.height; row++) {
+    const mapIndex = row * map.width + col;
+    if (row && map.map[mapIndex] == map.map[mapIndex - map.width])
+      continue;
+    const pos = map.map[mapIndex], { attrs } = table2.nodeAt(pos);
+    const index = attrs["colspan"] == 1 ? 0 : col - map.colCount(pos);
+    if (attrs["colwidth"] && attrs["colwidth"][index] == width)
+      continue;
+    const colwidth = attrs["colwidth"] ? attrs["colwidth"].slice() : zeroes(attrs["colspan"]);
+    colwidth[index] = width;
+    tr.setNodeMarkup(start + pos, null, setAttr(attrs, "colwidth", colwidth));
+  }
+  if (tr.docChanged)
+    view.dispatch(tr);
+}
+function displayColumnWidth(view, cell, width, cellMinWidth) {
+  const $cell = view.state.doc.resolve(cell);
+  const table2 = $cell.node(-1), start = $cell.start(-1);
+  const col = TableMap.get(table2).colCount($cell.pos - start) + $cell.nodeAfter.attrs["colspan"] - 1;
+  let dom = view.domAtPos($cell.start(-1)).node;
+  while (dom.nodeName != "TABLE")
+    dom = dom.parentNode;
+  updateColumns(table2, dom.firstChild, dom, cellMinWidth, col, width);
+}
+function zeroes(n) {
+  const result = [];
+  for (let i = 0; i < n; i++)
+    result.push(0);
+  return result;
+}
+function handleDecorations(state, cell) {
+  const decorations = [];
+  const $cell = state.doc.resolve(cell);
+  const table2 = $cell.node(-1), map = TableMap.get(table2), start = $cell.start(-1);
+  const col = map.colCount($cell.pos - start) + $cell.nodeAfter.attrs["colspan"];
+  for (let row = 0; row < map.height; row++) {
+    const index = col + row * map.width - 1;
+    if ((col == map.width || map.map[index] != map.map[index + 1]) && (row == 0 || map.map[index - 1] != map.map[index - 1 - map.width])) {
+      const cellPos = map.map[index];
+      const pos = start + cellPos + table2.nodeAt(cellPos).nodeSize - 1;
+      const dom = document.createElement("div");
+      dom.className = "column-resize-handle";
+      decorations.push(Decoration.widget(pos, dom));
+    }
+  }
+  return DecorationSet.create(state.doc, decorations);
+}
+function selectedRect(state) {
+  const sel = state.selection, $pos = selectionCell(state);
+  const table2 = $pos.node(-1), tableStart = $pos.start(-1), map = TableMap.get(table2);
+  let rect;
+  if (sel instanceof CellSelection)
+    rect = map.rectBetween(sel.$anchorCell.pos - tableStart, sel.$headCell.pos - tableStart);
+  else
+    rect = map.findCell($pos.pos - tableStart);
+  rect.tableStart = tableStart;
+  rect.map = map;
+  rect.table = table2;
+  return rect;
+}
+function addColumn(tr, { map, tableStart, table: table2 }, col) {
+  map = map;
+  table2 = table2;
+  tableStart = tableStart;
+  let refColumn = col > 0 ? -1 : 0;
+  if (columnIsHeader(map, table2, col + refColumn))
+    refColumn = col == 0 || col == map.width ? null : 0;
+  for (let row = 0; row < map.height; row++) {
+    const index = row * map.width + col;
+    if (col > 0 && col < map.width && map.map[index - 1] == map.map[index]) {
+      const pos = map.map[index], cell = table2.nodeAt(pos);
+      tr.setNodeMarkup(tr.mapping.map(tableStart + pos), null, addColSpan(cell.attrs, col - map.colCount(pos)));
+      row += cell.attrs["rowspan"] - 1;
+    } else {
+      const offset = map.map[index + refColumn];
+      const type = refColumn == null ? tableNodeTypes(table2.type.schema).cell : table2.nodeAt(offset).type;
+      const pos = map.positionAt(row, col, table2);
+      tr.insert(tr.mapping.map(tableStart + pos), type.createAndFill());
+    }
+  }
+  return tr;
+}
+const addColumnBefore = (state, dispatch) => {
+  if (!isInTable(state))
+    return false;
+  if (dispatch) {
+    const rect = selectedRect(state);
+    dispatch(addColumn(state.tr, rect, rect.left));
+  }
+  return true;
+};
+const addColumnAfter = (state, dispatch) => {
+  if (!isInTable(state))
+    return false;
+  if (dispatch) {
+    const rect = selectedRect(state);
+    dispatch(addColumn(state.tr, rect, rect.right));
+  }
+  return true;
+};
+function removeColumn(tr, { map, table: table2, tableStart }, col) {
+  map = map;
+  table2 = table2;
+  tableStart = tableStart;
+  const mapStart = tr.mapping.maps.length;
+  for (let row = 0; row < map.height; ) {
+    const index = row * map.width + col, pos = map.map[index], cell = table2.nodeAt(pos);
+    if (col > 0 && map.map[index - 1] == pos || col < map.width - 1 && map.map[index + 1] == pos) {
+      tr.setNodeMarkup(tr.mapping.slice(mapStart).map(tableStart + pos), null, removeColSpan(cell.attrs, col - map.colCount(pos)));
+    } else {
+      const start = tr.mapping.slice(mapStart).map(tableStart + pos);
+      tr.delete(start, start + cell.nodeSize);
+    }
+    row += cell.attrs["rowspan"];
+  }
+}
+const deleteColumn = (state, dispatch) => {
+  if (!isInTable(state))
+    return false;
+  if (dispatch) {
+    const rect = selectedRect(state), tr = state.tr;
+    if (rect.left == 0 && rect.right == rect.map.width)
+      return false;
+    for (let i = rect.right - 1; ; i--) {
+      removeColumn(tr, rect, i);
+      if (i == rect.left)
+        break;
+      rect.table = rect.tableStart ? tr.doc.nodeAt(rect.tableStart - 1) : tr.doc;
+      rect.map = TableMap.get(rect.table);
+    }
+    dispatch(tr);
+  }
+  return true;
+};
+function removeRow(tr, { map, tableStart, table: table2 }, row) {
+  map = map;
+  table2 = table2;
+  tableStart = tableStart;
+  let rowPos = 0;
+  for (let i = 0; i < row; i++)
+    rowPos += table2.child(i).nodeSize;
+  const nextRow = rowPos + table2.child(row).nodeSize;
+  const mapFrom = tr.mapping.maps.length;
+  tr.delete(rowPos + tableStart, nextRow + tableStart);
+  for (let col = 0, index = row * map.width; col < map.width; col++, index++) {
+    const pos = map.map[index];
+    if (row > 0 && pos == map.map[index - map.width]) {
+      const attrs = table2.nodeAt(pos).attrs;
+      tr.setNodeMarkup(tr.mapping.slice(mapFrom).map(pos + tableStart), null, setAttr(attrs, "rowspan", attrs["rowspan"] - 1));
+      col += attrs["colspan"] - 1;
+    } else if (row < map.width && pos == map.map[index + map.width]) {
+      const cell = table2.nodeAt(pos);
+      const copy = cell.type.create(setAttr(cell.attrs, "rowspan", cell.attrs["rowspan"] - 1), cell.content);
+      const newPos = map.positionAt(row + 1, col, table2);
+      tr.insert(tr.mapping.slice(mapFrom).map(tableStart + newPos), copy);
+      col += cell.attrs["colspan"] - 1;
+    }
+  }
+}
+const deleteRow = (state, dispatch) => {
+  if (!isInTable(state))
+    return false;
+  if (dispatch) {
+    const rect = selectedRect(state), tr = state.tr;
+    if (rect.top == 0 && rect.bottom == rect.map.height)
+      return false;
+    for (let i = rect.bottom - 1; ; i--) {
+      removeRow(tr, rect, i);
+      if (i == rect.top)
+        break;
+      rect.table = rect.tableStart ? tr.doc.nodeAt(rect.tableStart - 1) : tr.doc;
+      rect.map = TableMap.get(rect.table);
+    }
+    dispatch(tr);
+  }
+  return true;
+};
+function setCellAttr(name, value) {
+  return (state, dispatch) => {
+    if (!isInTable(state))
+      return false;
+    const $cell = selectionCell(state);
+    if ($cell.nodeAfter.attrs[name] === value)
+      return false;
+    if (dispatch) {
+      const tr = state.tr;
+      if (state.selection instanceof CellSelection)
+        state.selection.forEachCell((node, pos) => {
+          if (node.attrs[name] !== value)
+            tr.setNodeMarkup(pos, null, setAttr(node.attrs, name, value));
+        });
+      else
+        tr.setNodeMarkup($cell.pos, null, setAttr($cell.nodeAfter.attrs, name, value));
+      dispatch(tr);
+    }
+    return 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);
+      if (rowNode.childCount)
+        return rowEnd - 1 - rowNode.lastChild.nodeSize;
+      rowEnd -= rowNode.nodeSize;
+    }
+  } else {
+    if ($cell.index() < $cell.parent.childCount - 1)
+      return $cell.pos + $cell.nodeAfter.nodeSize;
+    const table2 = $cell.node(-1);
+    for (let row = $cell.indexAfter(-1), rowStart = $cell.after(); row < table2.childCount; row++) {
+      const rowNode = table2.child(row);
+      if (rowNode.childCount)
+        return rowStart + 1;
+      rowStart += rowNode.nodeSize;
+    }
+  }
+  return;
+}
+function goToNextCell(direction) {
+  return (state, dispatch) => {
+    if (!isInTable(state))
+      return false;
+    const cell = findNextCell(selectionCell(state), direction);
+    if (cell == null)
+      return false;
+    if (dispatch) {
+      const $cell = state.doc.resolve(cell);
+      dispatch(state.tr.setSelection(TextSelection.between($cell, moveCellForward($cell))).scrollIntoView());
+    }
+    return true;
+  };
+}
+const deleteTable = (state, dispatch) => {
+  const $pos = state.selection.$anchor;
+  for (let d = $pos.depth; d > 0; d--) {
+    const node = $pos.node(d);
+    if (node.type.spec["tableRole"] == "table") {
+      if (dispatch)
+        dispatch(state.tr.delete($pos.before(d), $pos.after(d)).scrollIntoView());
+      return true;
+    }
+  }
+  return false;
+};
+function pastedCells(slice) {
+  if (!slice.size)
+    return null;
+  let { content, openStart, openEnd } = slice;
+  while (content.childCount == 1 && (openStart > 0 && openEnd > 0 || content.firstChild.type.spec["tableRole"] == "table")) {
+    openStart--;
+    openEnd--;
+    content = content.firstChild.content;
+  }
+  const first = content.firstChild, role = first.type.spec["tableRole"];
+  const schema2 = first.type.schema, rows = [];
+  if (role == "row") {
+    for (let i = 0; i < content.childCount; i++) {
+      let cells = content.child(i).content;
+      const left = i ? 0 : Math.max(0, openStart - 1);
+      const right = i < content.childCount - 1 ? 0 : Math.max(0, openEnd - 1);
+      if (left || right)
+        cells = fitSlice(tableNodeTypes(schema2).row, new Slice(cells, left, right)).content;
+      rows.push(cells);
+    }
+  } else if (role == "cell" || role == "header_cell") {
+    rows.push(openStart || openEnd ? fitSlice(tableNodeTypes(schema2).row, new Slice(content, openStart, openEnd)).content : content);
+  } else {
+    return null;
+  }
+  return ensureRectangular(schema2, rows);
+}
+function ensureRectangular(schema2, rows) {
+  const widths = [];
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    for (let j = row.childCount - 1; j >= 0; j--) {
+      const { rowspan, colspan } = row.child(j).attrs;
+      for (let r = i; r < i + rowspan; r++)
+        widths[r] = (widths[r] || 0) + colspan;
+    }
+  }
+  let width = 0;
+  for (let r = 0; r < widths.length; r++)
+    width = Math.max(width, widths[r]);
+  for (let r = 0; r < widths.length; r++) {
+    if (r >= rows.length)
+      rows.push(Fragment.empty);
+    if (widths[r] < width) {
+      const empty = tableNodeTypes(schema2).cell.createAndFill(), cells = [];
+      for (let i = widths[r]; i < width; i++)
+        cells.push(empty);
+      rows[r] = rows[r].append(Fragment.from(cells));
+    }
+  }
+  return { height: rows.length, width, rows };
+}
+function fitSlice(nodeType, slice) {
+  const node = nodeType.createAndFill();
+  const tr = new Transform(node).replace(0, node.content.size, slice);
+  return tr.doc;
+}
+function clipCells({ width, height, rows }, newWidth, newHeight) {
+  if (width != newWidth) {
+    const added = [], newRows = [];
+    for (let row = 0; row < rows.length; row++) {
+      const frag = rows[row], cells = [];
+      for (let col = added[row] || 0, i = 0; col < newWidth; i++) {
+        let cell = frag.child(i % frag.childCount);
+        if (col + cell.attrs["colspan"] > newWidth)
+          cell = cell.type.create(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, i = 0; row < newHeight; row++, i++) {
+      const cells = [], source = rows[i % height];
+      for (let j = 0; j < source.childCount; j++) {
+        let cell = source.child(j);
+        if (row + cell.attrs["rowspan"] > newHeight)
+          cell = cell.type.create(setAttr(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(tr, map, table2, start, width, height, mapFrom) {
+  const schema2 = tr.doc.type.schema, types = tableNodeTypes(schema2);
+  let empty, emptyHead;
+  if (width > map.width) {
+    for (let row = 0, rowEnd = 0; row < map.height; row++) {
+      const rowNode = table2.child(row);
+      rowEnd += rowNode.nodeSize;
+      const cells = [];
+      let add;
+      if (rowNode.lastChild == null || rowNode.lastChild.type == types.cell)
+        add = empty || (empty = types.cell.createAndFill());
+      else
+        add = emptyHead || (emptyHead = types.header_cell.createAndFill());
+      for (let i = map.width; i < width; i++)
+        cells.push(add);
+      tr.insert(tr.mapping.slice(mapFrom).map(rowEnd - 1 + start), cells);
+    }
+  }
+  if (height > map.height) {
+    const cells = [];
+    for (let i = 0, start2 = (map.height - 1) * map.width; i < Math.max(map.width, width); i++) {
+      const header = i >= map.width ? false : table2.nodeAt(map.map[start2 + i]).type == types.header_cell;
+      cells.push(header ? emptyHead || (emptyHead = types.header_cell.createAndFill()) : empty || (empty = types.cell.createAndFill()));
+    }
+    const emptyRow = types.row.create(null, Fragment.from(cells)), rows = [];
+    for (let i = map.height; i < height; i++)
+      rows.push(emptyRow);
+    tr.insert(tr.mapping.slice(mapFrom).map(start + table2.nodeSize - 2), rows);
+  }
+  return !!(empty || emptyHead);
+}
+function isolateHorizontal(tr, map, table2, start, left, right, top, mapFrom) {
+  if (top == 0 || top == map.height)
+    return false;
+  let found = false;
+  for (let col = left; col < right; col++) {
+    const index = top * map.width + col, pos = map.map[index];
+    if (map.map[index - map.width] == pos) {
+      found = true;
+      const cell = table2.nodeAt(pos);
+      const { top: cellTop, left: cellLeft } = map.findCell(pos);
+      tr.setNodeMarkup(tr.mapping.slice(mapFrom).map(pos + start), null, setAttr(cell.attrs, "rowspan", top - cellTop));
+      tr.insert(tr.mapping.slice(mapFrom).map(map.positionAt(top, cellLeft, table2)), cell.type.createAndFill(setAttr(cell.attrs, "rowspan", cellTop + cell.attrs["rowspan"] - top)));
+      col += cell.attrs["colspan"] - 1;
+    }
+  }
+  return found;
+}
+function isolateVertical(tr, map, table2, start, top, bottom, left, mapFrom) {
+  if (left == 0 || left == map.width)
+    return false;
+  let found = false;
+  for (let row = top; row < bottom; row++) {
+    const index = row * map.width + left, pos = map.map[index];
+    if (map.map[index - 1] == pos) {
+      found = true;
+      const cell = table2.nodeAt(pos), cellLeft = map.colCount(pos);
+      const updatePos = tr.mapping.slice(mapFrom).map(pos + start);
+      tr.setNodeMarkup(updatePos, null, removeColSpan(cell.attrs, left - cellLeft, cell.attrs["colspan"] - (left - cellLeft)));
+      tr.insert(updatePos + cell.nodeSize, cell.type.createAndFill(removeColSpan(cell.attrs, 0, left - cellLeft)));
+      row += cell.attrs["rowspan"] - 1;
+    }
+  }
+  return found;
+}
+function insertCells(state, dispatch, tableStart, rect, cells) {
+  let table2 = tableStart ? state.doc.nodeAt(tableStart - 1) : state.doc, map = TableMap.get(table2);
+  const { top, left } = rect;
+  const right = left + cells.width, bottom = top + cells.height;
+  const tr = state.tr;
+  let mapFrom = 0;
+  function recomp() {
+    table2 = tableStart ? tr.doc.nodeAt(tableStart - 1) : tr.doc;
+    map = TableMap.get(table2);
+    mapFrom = tr.mapping.maps.length;
+  }
+  if (growTable(tr, map, table2, tableStart, right, bottom, mapFrom))
+    recomp();
+  if (isolateHorizontal(tr, map, table2, tableStart, left, right, top, mapFrom))
+    recomp();
+  if (isolateHorizontal(tr, map, table2, tableStart, left, right, bottom, mapFrom))
+    recomp();
+  if (isolateVertical(tr, map, table2, tableStart, top, bottom, left, mapFrom))
+    recomp();
+  if (isolateVertical(tr, map, table2, tableStart, top, bottom, right, mapFrom))
+    recomp();
+  for (let row = top; row < bottom; row++) {
+    const from = map.positionAt(row, left, table2), to = map.positionAt(row, right, table2);
+    tr.replace(tr.mapping.slice(mapFrom).map(from + tableStart), tr.mapping.slice(mapFrom).map(to + tableStart), new Slice(cells.rows[row - top], 0, 0));
+  }
+  recomp();
+  tr.setSelection(new CellSelection(tr.doc.resolve(tableStart + map.positionAt(top, left, table2)), tr.doc.resolve(tableStart + map.positionAt(bottom - 1, right - 1, table2))));
+  dispatch(tr);
+}
+const fixTablesKey = new PluginKey("fix-tables");
+function changedDescendants(old, cur, offset, f) {
+  const oldSize = old.childCount, curSize = cur.childCount;
+  outer:
+    for (let i = 0, j = 0; i < curSize; i++) {
+      const child = cur.child(i);
+      for (let scan = j, e = Math.min(oldSize, i + 3); scan < e; scan++) {
+        if (old.child(scan) == child) {
+          j = scan + 1;
+          offset += child.nodeSize;
+          continue outer;
+        }
+      }
+      f(child, offset);
+      if (j < oldSize && old.child(j).sameMarkup(child))
+        changedDescendants(old.child(j), child, offset + 1, f);
+      else
+        child.nodesBetween(0, child.content.size, f, offset + 1);
+      offset += child.nodeSize;
+    }
+}
+function fixTables(state, oldState) {
+  let tr;
+  const check = (node, pos) => {
+    if (node.type.spec["tableRole"] == "table")
+      tr = fixTable(state, node, pos, tr);
+  };
+  if (!oldState)
+    state.doc.descendants(check);
+  else if (oldState.doc != state.doc)
+    changedDescendants(oldState.doc, state.doc, 0, check);
+  return tr;
+}
+function fixTable(state, table2, tablePos, tr) {
+  const map = TableMap.get(table2);
+  if (!map.problems)
+    return tr;
+  if (!tr)
+    tr = state.tr;
+  const mustAdd = [];
+  for (let i = 0; i < map.height; i++)
+    mustAdd.push(0);
+  for (let i = 0; i < map.problems.length; i++) {
+    const prob = map.problems[i];
+    if (prob.type == "collision") {
+      const cell = table2.nodeAt(prob.pos);
+      for (let j = 0; j < cell.attrs["rowspan"]; j++)
+        mustAdd[prob.row + j] += prob.n;
+      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), null, removeColSpan(cell.attrs, cell.attrs["colspan"] - prob.n, prob.n));
+    } else if (prob.type == "missing") {
+      mustAdd[prob.row] += prob.n;
+    } else if (prob.type == "overlong_rowspan") {
+      const cell = table2.nodeAt(prob.pos);
+      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), null, setAttr(cell.attrs, "rowspan", cell.attrs["rowspan"] - prob.n));
+    } else if (prob.type == "colwidth mismatch") {
+      const cell = table2.nodeAt(prob.pos);
+      tr.setNodeMarkup(tr.mapping.map(tablePos + 1 + prob.pos), null, setAttr(cell.attrs, "colwidth", prob.colwidth));
+    }
+  }
+  let first, last;
+  for (let i = 0; i < mustAdd.length; i++)
+    if (mustAdd[i]) {
+      if (first == null)
+        first = i;
+      last = i;
+    }
+  for (let i = 0, pos = tablePos + 1; i < map.height; i++) {
+    const row = table2.child(i);
+    const end = pos + row.nodeSize;
+    const add = mustAdd[i];
+    if (add > 0) {
+      let tableNodeType = "cell";
+      if (row.firstChild) {
+        tableNodeType = row.firstChild.type.spec["tableRole"];
+      }
+      const nodes = [];
+      for (let j = 0; j < add; j++)
+        nodes.push(tableNodeTypes(state.schema)[tableNodeType].createAndFill());
+      const side = (i == 0 || first == i - 1) && last == i ? pos + 1 : end - 1;
+      tr.insert(tr.mapping.map(side), nodes);
+    }
+    pos = end;
+  }
+  return tr.setMeta(fixTablesKey, { fixTables: true });
+}
+const tableEditingKey = new PluginKey("selectingCells");
+function domInCell(view, dom) {
+  for (; dom && dom != view.dom; dom = dom.parentNode)
+    if (dom.nodeName == "TD" || dom.nodeName == "TH")
+      return dom;
+  return;
+}
+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;
+}
+function handleMouseDown(view, event) {
+  const startEvent = event;
+  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 && cellUnderMouse(view, startEvent).pos != $anchor.pos) {
+    setCellSelection($anchor, startEvent);
+    startEvent.preventDefault();
+  } else if (!startDOMCell) {
+    return;
+  }
+  function setCellSelection($anchor2, event2) {
+    let $head = cellUnderMouse(view, event2);
+    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 tr = view.state.tr.setSelection(selection);
+      if (starting)
+        tr.setMeta(tableEditingKey, $anchor2.pos);
+      view.dispatch(tr);
+    }
+  }
+  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(event2) {
+    const anchor = tableEditingKey.getState(view.state);
+    let $anchor2;
+    if (anchor != null) {
+      $anchor2 = view.state.doc.resolve(anchor);
+    } else if (domInCell(view, event2.target) != startDOMCell) {
+      $anchor2 = cellUnderMouse(view, startEvent);
+      if (!$anchor2)
+        return stop();
+    }
+    if ($anchor2)
+      setCellSelection($anchor2, event2);
+  }
+  view.root.addEventListener("mouseup", stop);
+  view.root.addEventListener("dragstart", stop);
+  view.root.addEventListener("mousemove", move);
+}
+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 maybeSetSelection(state, dispatch, selection) {
+  if (selection.eq(state.selection))
+    return false;
+  if (dispatch)
+    dispatch(state.tr.setSelection(selection).scrollIntoView());
+  return true;
+}
+function atEndOfCell(view, axis, dir) {
+  if (!(view.state.selection instanceof TextSelection))
+    return null;
+  const { $head } = view.state.selection;
+  for (let d = $head.depth - 1; d >= 0; d--) {
+    const parent = $head.node(d), index = dir < 0 ? $head.index(d) : $head.indexAfter(d);
+    if (index != (dir < 0 ? 0 : parent.childCount))
+      return null;
+    if (parent.type.spec["tableRole"] == "cell" || parent.type.spec["tableRole"] == "header_cell") {
+      const cellPos = $head.before(d);
+      const dirStr = axis == "vert" ? dir > 0 ? "down" : "up" : dir > 0 ? "right" : "left";
+      return view.endOfTextblock(dirStr) ? cellPos : null;
+    }
+  }
+  return null;
+}
+function arrow(axis, dir) {
+  return (state, dispatch, view) => {
+    const sel = state.selection;
+    if (sel instanceof CellSelection) {
+      return maybeSetSelection(state, dispatch, Selection.near(sel.$headCell, dir));
+    }
+    if (axis != "horiz" && !sel.empty)
+      return false;
+    const end = atEndOfCell(view, axis, dir);
+    if (end == null)
+      return false;
+    if (axis == "horiz") {
+      return maybeSetSelection(state, dispatch, Selection.near(state.doc.resolve(sel.head + dir), dir));
+    } else {
+      const $cell = state.doc.resolve(end), $next = nextCell($cell, axis, dir);
+      let newSel;
+      if ($next)
+        newSel = Selection.near($next, 1);
+      else if (dir < 0)
+        newSel = Selection.near(state.doc.resolve($cell.before(-1)), -1);
+      else
+        newSel = Selection.near(state.doc.resolve($cell.after(-1)), 1);
+      return maybeSetSelection(state, dispatch, newSel);
+    }
+  };
+}
+function shiftArrow(axis, dir) {
+  return (state, dispatch, view) => {
+    let sel = state.selection;
+    if (!(sel instanceof CellSelection)) {
+      const end = atEndOfCell(view, axis, dir);
+      if (end == null)
+        return false;
+      sel = new CellSelection(state.doc.resolve(end));
+    }
+    const $head = nextCell(sel.$headCell, axis, dir);
+    if (!$head)
+      return false;
+    return maybeSetSelection(state, dispatch, new CellSelection(sel.$anchorCell, $head));
+  };
+}
+function deleteCellSelection(state, dispatch) {
+  const sel = state.selection;
+  if (!(sel instanceof CellSelection))
+    return false;
+  if (dispatch) {
+    const tr = state.tr, baseContent = tableNodeTypes(state.schema).cell.createAndFill().content;
+    sel.forEachCell((cell, pos) => {
+      if (!cell.content.eq(baseContent))
+        tr.replace(tr.mapping.map(pos + 1), tr.mapping.map(pos + cell.nodeSize - 1), new Slice(baseContent, 0, 0));
+    });
+    if (tr.docChanged)
+      dispatch(tr);
+  }
+  return true;
+}
+const 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 handlePaste(view, _, slice) {
+  if (!isInTable(view.state))
+    return false;
+  let cells = pastedCells(slice);
+  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, slice))]
+      };
+    const table2 = sel.$anchorCell.node(-1), start = sel.$anchorCell.start(-1);
+    const rect = TableMap.get(table2).rectBetween(sel.$anchorCell.pos - start, sel.$headCell.pos - start);
+    cells = clipCells(cells, rect.right - rect.left, rect.bottom - rect.top);
+    insertCells(view.state, view.dispatch, start, rect, cells);
+    return true;
+  } else if (cells) {
+    const $cell = selectionCell(view.state), start = $cell.start(-1);
+    insertCells(view.state, view.dispatch, start, TableMap.get($cell.node(-1)).findCell($cell.pos - start), cells);
+    return true;
+  } else {
+    return false;
+  }
+}
+function tableEditing({ allowTableNodeSelection = false } = {}) {
+  return new Plugin({
+    key: tableEditingKey,
+    state: {
+      init() {
+        return null;
+      },
+      apply(tr, cur) {
+        const set = tr.getMeta(tableEditingKey);
+        if (set != null)
+          return set == -1 ? null : set;
+        if (cur == null || !tr.docChanged)
+          return cur;
+        const { deleted, pos } = tr.mapping.mapResult(cur);
+        return deleted ? null : pos;
+      }
+    },
+    props: {
+      decorations: drawCellSelection,
+      handleDOMEvents: {
+        mousedown: handleMouseDown
+      },
+      createSelectionBetween(view) {
+        if (tableEditingKey.getState(view.state) != null)
+          return view.state.selection;
+        return null;
+      },
+      handleTripleClick,
+      handleKeyDown,
+      handlePaste
+    },
+    appendTransaction(_, oldState, state) {
+      return normalizeSelection(state, fixTables(state, oldState), allowTableNodeSelection);
+    }
+  });
+}
 const SupportedKeys$1 = {
   NextCell: "NextCell",
   PrevCell: "PrevCell",