@milkdown/preset-gfm 7.6.3 → 7.7.0

package/lib/index.es.js

@@ -1,759 +1,890 @@
-import { expectDomTypeError as K } from "@milkdown/exception";
-import { paragraphSchema as De, listItemSchema as Ee } from "@milkdown/preset-commonmark";
-import { InputRule as ne } from "@milkdown/prose/inputrules";
-import { $markAttr as Oe, $markSchema as He, $inputRule as F, $useKeymap as le, $command as g, $nodeSchema as C, $prose as v, $remark as Be } from "@milkdown/utils";
-import { tableNodes as Le, TableMap as h, CellSelection as k, goToNextCell as re, isInTable as G, deleteTable as Ke, deleteColumn as Fe, deleteRow as Ge, selectedRect as ae, addColumnBefore as We, addColumnAfter as ze, setCellAttr as je, columnResizing as Ve, tableEditing as Ue } from "@milkdown/prose/tables";
-import { commandsCtx as A } from "@milkdown/core";
-import { toggleMark as Xe } from "@milkdown/prose/commands";
-import { markRule as qe, findParentNodeClosestToPos as se, cloneTr as _, findParentNodeType as Je } from "@milkdown/prose";
-import { Selection as ce, TextSelection as Qe, Plugin as Ye, PluginKey as Ze } from "@milkdown/prose/state";
-import { imeSpan as et } from "prosemirror-safari-ime-span";
-import tt from "remark-gfm";
-function i(e, t) {
-  return Object.assign(e, {
+import { expectDomTypeError } from "@milkdown/exception";
+import { paragraphSchema, listItemSchema } from "@milkdown/preset-commonmark";
+import { InputRule } from "@milkdown/prose/inputrules";
+import { $markAttr, $markSchema, $inputRule, $useKeymap, $command, $nodeSchema, $prose, $remark } from "@milkdown/utils";
+import { tableNodes, TableMap, CellSelection, goToNextCell, isInTable, deleteTable, deleteColumn, deleteRow, selectedRect, addColumnBefore, addColumnAfter, setCellAttr, columnResizing, tableEditing } from "@milkdown/prose/tables";
+import { commandsCtx } from "@milkdown/core";
+import { toggleMark } from "@milkdown/prose/commands";
+import { markRule, findParentNodeClosestToPos, cloneTr, findParentNodeType } from "@milkdown/prose";
+import { Selection, TextSelection, Plugin, PluginKey } from "@milkdown/prose/state";
+import { imeSpan } from "prosemirror-safari-ime-span";
+import remarkGFM from "remark-gfm";
+function withMeta(plugin, meta) {
+  Object.assign(plugin, {
     meta: {
       package: "@milkdown/preset-gfm",
-      ...t
+      ...meta
     }
-  }), e;
+  });
+  return plugin;
 }
-const W = Oe("strike_through");
-i(W, {
+const strikethroughAttr = $markAttr("strike_through");
+withMeta(strikethroughAttr, {
   displayName: "Attr<strikethrough>",
   group: "Strikethrough"
 });
-const T = He("strike_through", (e) => ({
+const strikethroughSchema = $markSchema("strike_through", (ctx) => ({
   parseDOM: [
     { tag: "del" },
     {
       style: "text-decoration",
-      getAttrs: (t) => t === "line-through"
+      getAttrs: (value) => value === "line-through"
     }
   ],
-  toDOM: (t) => ["del", e.get(W.key)(t)],
+  toDOM: (mark) => ["del", ctx.get(strikethroughAttr.key)(mark)],
   parseMarkdown: {
-    match: (t) => t.type === "delete",
-    runner: (t, n, o) => {
-      t.openMark(o), t.next(n.children), t.closeMark(o);
+    match: (node) => node.type === "delete",
+    runner: (state, node, markType) => {
+      state.openMark(markType);
+      state.next(node.children);
+      state.closeMark(markType);
     }
   },
   toMarkdown: {
-    match: (t) => t.type.name === "strike_through",
-    runner: (t, n) => {
-      t.withMark(n, "delete");
+    match: (mark) => mark.type.name === "strike_through",
+    runner: (state, mark) => {
+      state.withMark(mark, "delete");
     }
   }
 }));
-i(T.mark, {
+withMeta(strikethroughSchema.mark, {
   displayName: "MarkSchema<strikethrough>",
   group: "Strikethrough"
 });
-i(T.ctx, {
+withMeta(strikethroughSchema.ctx, {
   displayName: "MarkSchemaCtx<strikethrough>",
   group: "Strikethrough"
 });
-const z = g(
+const toggleStrikethroughCommand = $command(
   "ToggleStrikeThrough",
-  (e) => () => Xe(T.type(e))
+  (ctx) => () => {
+    return toggleMark(strikethroughSchema.type(ctx));
+  }
 );
-i(z, {
+withMeta(toggleStrikethroughCommand, {
   displayName: "Command<ToggleStrikethrough>",
   group: "Strikethrough"
 });
-const ie = F((e) => qe(/~([^~]+)~$/, T.type(e)));
-i(ie, {
+const strikethroughInputRule = $inputRule((ctx) => {
+  return markRule(/~([^~]+)~$/, strikethroughSchema.type(ctx));
+});
+withMeta(strikethroughInputRule, {
   displayName: "InputRule<strikethrough>",
   group: "Strikethrough"
 });
-const j = le("strikeThroughKeymap", {
+const strikethroughKeymap = $useKeymap("strikeThroughKeymap", {
   ToggleStrikethrough: {
     shortcuts: "Mod-Alt-x",
-    command: (e) => {
-      const t = e.get(A);
-      return () => t.call(z.key);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(toggleStrikethroughCommand.key);
     }
   }
 });
-i(j.ctx, {
+withMeta(strikethroughKeymap.ctx, {
   displayName: "KeymapCtx<strikethrough>",
   group: "Strikethrough"
 });
-i(j.shortcuts, {
+withMeta(strikethroughKeymap.shortcuts, {
   displayName: "Keymap<strikethrough>",
   group: "Strikethrough"
 });
-const S = Le({
+const originalSchema = tableNodes({
   tableGroup: "block",
   cellContent: "paragraph",
   cellAttributes: {
     alignment: {
       default: "left",
-      getFromDOM: (e) => e.style.textAlign || "left",
-      setDOMAttr: (e, t) => {
-        t.style = `text-align: ${e || "left"}`;
+      getFromDOM: (dom) => dom.style.textAlign || "left",
+      setDOMAttr: (value, attrs) => {
+        attrs.style = `text-align: ${value || "left"}`;
       }
     }
   }
-}), N = C("table", () => ({
-  ...S.table,
+});
+const tableSchema = $nodeSchema("table", () => ({
+  ...originalSchema.table,
   content: "table_header_row table_row+",
-  disableDropCursor: !0,
+  disableDropCursor: true,
   parseMarkdown: {
-    match: (e) => e.type === "table",
-    runner: (e, t, n) => {
-      const o = t.align, l = t.children.map((r, s) => ({
-        ...r,
-        align: o,
-        isHeader: s === 0
+    match: (node) => node.type === "table",
+    runner: (state, node, type) => {
+      const align = node.align;
+      const children = node.children.map((x, i) => ({
+        ...x,
+        align,
+        isHeader: i === 0
       }));
-      e.openNode(n), e.next(l), e.closeNode();
+      state.openNode(type);
+      state.next(children);
+      state.closeNode();
     }
   },
   toMarkdown: {
-    match: (e) => e.type.name === "table",
-    runner: (e, t) => {
-      var l;
-      const n = (l = t.content.firstChild) == null ? void 0 : l.content;
-      if (!n) return;
-      const o = [];
-      n.forEach((r) => {
-        o.push(r.attrs.alignment);
-      }), e.openNode("table", void 0, { align: o }), e.next(t.content), e.closeNode();
+    match: (node) => node.type.name === "table",
+    runner: (state, node) => {
+      var _a;
+      const firstLine = (_a = node.content.firstChild) == null ? void 0 : _a.content;
+      if (!firstLine) return;
+      const align = [];
+      firstLine.forEach((cell) => {
+        align.push(cell.attrs.alignment);
+      });
+      state.openNode("table", void 0, { align });
+      state.next(node.content);
+      state.closeNode();
     }
   }
 }));
-i(N.node, {
+withMeta(tableSchema.node, {
   displayName: "NodeSchema<table>",
   group: "Table"
 });
-i(N.ctx, {
+withMeta(tableSchema.ctx, {
   displayName: "NodeSchemaCtx<table>",
   group: "Table"
 });
-const $ = C("table_header_row", () => ({
-  ...S.table_row,
-  disableDropCursor: !0,
+const tableHeaderRowSchema = $nodeSchema("table_header_row", () => ({
+  ...originalSchema.table_row,
+  disableDropCursor: true,
   content: "(table_header)*",
   parseDOM: [{ tag: "tr[data-is-header]" }],
   toDOM() {
-    return ["tr", { "data-is-header": !0 }, 0];
+    return ["tr", { "data-is-header": true }, 0];
   },
   parseMarkdown: {
-    match: (e) => !!(e.type === "tableRow" && e.isHeader),
-    runner: (e, t, n) => {
-      const o = t.align, l = t.children.map((r, s) => ({
-        ...r,
-        align: o[s],
-        isHeader: t.isHeader
+    match: (node) => Boolean(node.type === "tableRow" && node.isHeader),
+    runner: (state, node, type) => {
+      const align = node.align;
+      const children = node.children.map((x, i) => ({
+        ...x,
+        align: align[i],
+        isHeader: node.isHeader
       }));
-      e.openNode(n), e.next(l), e.closeNode();
+      state.openNode(type);
+      state.next(children);
+      state.closeNode();
     }
   },
   toMarkdown: {
-    match: (e) => e.type.name === "table_header_row",
-    runner: (e, t) => {
-      e.openNode("tableRow", void 0, { isHeader: !0 }), e.next(t.content), e.closeNode();
+    match: (node) => node.type.name === "table_header_row",
+    runner: (state, node) => {
+      state.openNode("tableRow", void 0, { isHeader: true });
+      state.next(node.content);
+      state.closeNode();
     }
   }
 }));
-i($.node, {
+withMeta(tableHeaderRowSchema.node, {
   displayName: "NodeSchema<tableHeaderRow>",
   group: "Table"
 });
-i($.ctx, {
+withMeta(tableHeaderRowSchema.ctx, {
   displayName: "NodeSchemaCtx<tableHeaderRow>",
   group: "Table"
 });
-const R = C("table_row", () => ({
-  ...S.table_row,
-  disableDropCursor: !0,
+const tableRowSchema = $nodeSchema("table_row", () => ({
+  ...originalSchema.table_row,
+  disableDropCursor: true,
   content: "(table_cell)*",
   parseMarkdown: {
-    match: (e) => e.type === "tableRow",
-    runner: (e, t, n) => {
-      const o = t.align, l = t.children.map((r, s) => ({
-        ...r,
-        align: o[s]
+    match: (node) => node.type === "tableRow",
+    runner: (state, node, type) => {
+      const align = node.align;
+      const children = node.children.map((x, i) => ({
+        ...x,
+        align: align[i]
       }));
-      e.openNode(n), e.next(l), e.closeNode();
+      state.openNode(type);
+      state.next(children);
+      state.closeNode();
     }
   },
   toMarkdown: {
-    match: (e) => e.type.name === "table_row",
-    runner: (e, t) => {
-      e.openNode("tableRow"), e.next(t.content), e.closeNode();
+    match: (node) => node.type.name === "table_row",
+    runner: (state, node) => {
+      state.openNode("tableRow");
+      state.next(node.content);
+      state.closeNode();
     }
   }
 }));
-i(R.node, {
+withMeta(tableRowSchema.node, {
   displayName: "NodeSchema<tableRow>",
   group: "Table"
 });
-i(R.ctx, {
+withMeta(tableRowSchema.ctx, {
   displayName: "NodeSchemaCtx<tableRow>",
   group: "Table"
 });
-const x = C("table_cell", () => ({
-  ...S.table_cell,
-  disableDropCursor: !0,
+const tableCellSchema = $nodeSchema("table_cell", () => ({
+  ...originalSchema.table_cell,
+  disableDropCursor: true,
   parseMarkdown: {
-    match: (e) => e.type === "tableCell" && !e.isHeader,
-    runner: (e, t, n) => {
-      const o = t.align;
-      e.openNode(n, { alignment: o }).openNode(e.schema.nodes.paragraph).next(t.children).closeNode().closeNode();
+    match: (node) => node.type === "tableCell" && !node.isHeader,
+    runner: (state, node, type) => {
+      const align = node.align;
+      state.openNode(type, { alignment: align }).openNode(state.schema.nodes.paragraph).next(node.children).closeNode().closeNode();
     }
   },
   toMarkdown: {
-    match: (e) => e.type.name === "table_cell",
-    runner: (e, t) => {
-      e.openNode("tableCell").next(t.content).closeNode();
+    match: (node) => node.type.name === "table_cell",
+    runner: (state, node) => {
+      state.openNode("tableCell").next(node.content).closeNode();
     }
   }
 }));
-i(x.node, {
+withMeta(tableCellSchema.node, {
   displayName: "NodeSchema<tableCell>",
   group: "Table"
 });
-i(x.ctx, {
+withMeta(tableCellSchema.ctx, {
   displayName: "NodeSchemaCtx<tableCell>",
   group: "Table"
 });
-const I = C("table_header", () => ({
-  ...S.table_header,
-  disableDropCursor: !0,
+const tableHeaderSchema = $nodeSchema("table_header", () => ({
+  ...originalSchema.table_header,
+  disableDropCursor: true,
   parseMarkdown: {
-    match: (e) => e.type === "tableCell" && !!e.isHeader,
-    runner: (e, t, n) => {
-      const o = t.align;
-      e.openNode(n, { alignment: o }), e.openNode(e.schema.nodes.paragraph), e.next(t.children), e.closeNode(), e.closeNode();
+    match: (node) => node.type === "tableCell" && !!node.isHeader,
+    runner: (state, node, type) => {
+      const align = node.align;
+      state.openNode(type, { alignment: align });
+      state.openNode(state.schema.nodes.paragraph);
+      state.next(node.children);
+      state.closeNode();
+      state.closeNode();
     }
   },
   toMarkdown: {
-    match: (e) => e.type.name === "table_header",
-    runner: (e, t) => {
-      e.openNode("tableCell"), e.next(t.content), e.closeNode();
+    match: (node) => node.type.name === "table_header",
+    runner: (state, node) => {
+      state.openNode("tableCell");
+      state.next(node.content);
+      state.closeNode();
     }
   }
 }));
-i(I.node, {
+withMeta(tableHeaderSchema.node, {
   displayName: "NodeSchema<tableHeader>",
   group: "Table"
 });
-i(I.ctx, {
+withMeta(tableHeaderSchema.ctx, {
   displayName: "NodeSchemaCtx<tableHeader>",
   group: "Table"
 });
-function de(e, t = 3, n = 3) {
-  const o = Array(n).fill(0).map(() => x.type(e).createAndFill()), l = Array(n).fill(0).map(() => I.type(e).createAndFill()), r = Array(t).fill(0).map(
-    (s, c) => c === 0 ? $.type(e).create(null, l) : R.type(e).create(null, o)
+function createTable(ctx, rowsCount = 3, colsCount = 3) {
+  const cells = Array(colsCount).fill(0).map(() => tableCellSchema.type(ctx).createAndFill());
+  const headerCells = Array(colsCount).fill(0).map(() => tableHeaderSchema.type(ctx).createAndFill());
+  const rows = Array(rowsCount).fill(0).map(
+    (_, i) => i === 0 ? tableHeaderRowSchema.type(ctx).create(null, headerCells) : tableRowSchema.type(ctx).create(null, cells)
   );
-  return N.type(e).create(null, r);
+  return tableSchema.type(ctx).create(null, rows);
 }
-function M(e) {
-  return se(
-    (t) => t.type.spec.tableRole === "table"
-  )(e);
+function findTable($pos) {
+  return findParentNodeClosestToPos(
+    (node) => node.type.spec.tableRole === "table"
+  )($pos);
 }
-function y(e, t) {
-  const n = M(t.$from);
-  if (!n) return;
-  const o = h.get(n.node);
-  if (!(e < 0 || e >= o.width))
-    return o.cellsInRect({
-      left: e,
-      right: e + 1,
-      top: 0,
-      bottom: o.height
-    }).map((l) => {
-      const r = n.node.nodeAt(l);
-      if (!r) return;
-      const s = l + n.start;
-      return {
-        pos: s,
-        start: s + 1,
-        node: r
-      };
-    }).filter((l) => l != null);
+function getCellsInCol(columnIndex, selection) {
+  const table = findTable(selection.$from);
+  if (!table) return void 0;
+  const map = TableMap.get(table.node);
+  if (columnIndex < 0 || columnIndex >= map.width) return void 0;
+  return map.cellsInRect({
+    left: columnIndex,
+    right: columnIndex + 1,
+    top: 0,
+    bottom: map.height
+  }).map((pos) => {
+    const node = table.node.nodeAt(pos);
+    if (!node) return void 0;
+    const start = pos + table.start;
+    return {
+      pos: start,
+      start: start + 1,
+      node
+    };
+  }).filter((x) => x != null);
 }
-function w(e, t) {
-  const n = M(t.$from);
-  if (!n) return;
-  const o = h.get(n.node);
-  if (!(e < 0 || e >= o.height))
-    return o.cellsInRect({
-      left: 0,
-      right: o.width,
-      top: e,
-      bottom: e + 1
-    }).map((l) => {
-      const r = n.node.nodeAt(l);
-      if (!r) return;
-      const s = l + n.start;
-      return {
-        pos: s,
-        start: s + 1,
-        node: r
-      };
-    }).filter((l) => l != null);
+function getCellsInRow(rowIndex, selection) {
+  const table = findTable(selection.$from);
+  if (!table) return void 0;
+  const map = TableMap.get(table.node);
+  if (rowIndex < 0 || rowIndex >= map.height) return void 0;
+  return map.cellsInRect({
+    left: 0,
+    right: map.width,
+    top: rowIndex,
+    bottom: rowIndex + 1
+  }).map((pos) => {
+    const node = table.node.nodeAt(pos);
+    if (!node) return void 0;
+    const start = pos + table.start;
+    return {
+      pos: start,
+      start: start + 1,
+      node
+    };
+  }).filter((x) => x != null);
 }
-function ot(e) {
-  const t = M(e.$from);
-  if (!t) return;
-  const n = h.get(t.node);
-  return n.cellsInRect({
+function getAllCellsInTable(selection) {
+  const table = findTable(selection.$from);
+  if (!table) return;
+  const map = TableMap.get(table.node);
+  const cells = map.cellsInRect({
     left: 0,
-    right: n.width,
+    right: map.width,
     top: 0,
-    bottom: n.height
-  }).map((l) => {
-    const r = t.node.nodeAt(l), s = l + t.start;
-    return { pos: s, start: s + 1, node: r };
+    bottom: map.height
+  });
+  return cells.map((nodePos) => {
+    const node = table.node.nodeAt(nodePos);
+    const pos = nodePos + table.start;
+    return { pos, start: pos + 1, node };
   });
 }
-function nt(e) {
-  const t = ot(e.selection);
-  if (t && t[0]) {
-    const n = e.doc.resolve(t[0].pos), o = t[t.length - 1];
-    if (o) {
-      const l = e.doc.resolve(o.pos);
-      return _(e.setSelection(new k(l, n)));
+function selectTable(tr) {
+  const cells = getAllCellsInTable(tr.selection);
+  if (cells && cells[0]) {
+    const $firstCell = tr.doc.resolve(cells[0].pos);
+    const last = cells[cells.length - 1];
+    if (last) {
+      const $lastCell = tr.doc.resolve(last.pos);
+      return cloneTr(tr.setSelection(new CellSelection($lastCell, $firstCell)));
     }
   }
-  return e;
+  return tr;
 }
-function me(e, t, { map: n, tableStart: o, table: l }, r) {
-  const s = Array(r).fill(0).reduce((d, p, a) => d + l.child(a).nodeSize, o), c = Array(n.width).fill(0).map((d, p) => {
-    const a = l.nodeAt(n.map[p]);
-    return x.type(e).createAndFill({ alignment: a == null ? void 0 : a.attrs.alignment });
+function addRowWithAlignment(ctx, tr, { map, tableStart, table }, row) {
+  const rowPos = Array(row).fill(0).reduce((acc, _, i) => {
+    return acc + table.child(i).nodeSize;
+  }, tableStart);
+  const cells = Array(map.width).fill(0).map((_, col) => {
+    const headerCol = table.nodeAt(map.map[col]);
+    return tableCellSchema.type(ctx).createAndFill({ alignment: headerCol == null ? void 0 : headerCol.attrs.alignment });
   });
-  return t.insert(s, R.type(e).create(null, c)), t;
+  tr.insert(rowPos, tableRowSchema.type(ctx).create(null, cells));
+  return tr;
 }
-function ue(e) {
-  return (t, n) => (o) => {
-    n = n ?? o.selection.from;
-    const l = o.doc.resolve(n), r = se(
-      (d) => d.type.name === "table"
-    )(l), s = r ? {
-      node: r.node,
-      from: r.start
-    } : void 0, c = e === "row";
-    if (s) {
-      const d = h.get(s.node);
-      if (t >= 0 && t < (c ? d.height : d.width)) {
-        const p = d.positionAt(
-          c ? t : d.height - 1,
-          c ? d.width - 1 : t,
-          s.node
-        ), a = o.doc.resolve(s.from + p), m = c ? k.rowSelection : k.colSelection, u = d.positionAt(
-          c ? t : 0,
-          c ? 0 : t,
-          s.node
-        ), f = o.doc.resolve(s.from + u);
-        return _(
-          o.setSelection(
-            m(a, f)
+function selectLine(type) {
+  return (index, pos) => (tr) => {
+    pos = pos ?? tr.selection.from;
+    const $pos = tr.doc.resolve(pos);
+    const $node = findParentNodeClosestToPos(
+      (node) => node.type.name === "table"
+    )($pos);
+    const table = $node ? {
+      node: $node.node,
+      from: $node.start
+    } : void 0;
+    const isRowSelection = type === "row";
+    if (table) {
+      const map = TableMap.get(table.node);
+      if (index >= 0 && index < (isRowSelection ? map.height : map.width)) {
+        const lastCell = map.positionAt(
+          isRowSelection ? index : map.height - 1,
+          isRowSelection ? map.width - 1 : index,
+          table.node
+        );
+        const $lastCell = tr.doc.resolve(table.from + lastCell);
+        const createCellSelection = isRowSelection ? CellSelection.rowSelection : CellSelection.colSelection;
+        const firstCell = map.positionAt(
+          isRowSelection ? index : 0,
+          isRowSelection ? 0 : index,
+          table.node
+        );
+        const $firstCell = tr.doc.resolve(table.from + firstCell);
+        return cloneTr(
+          tr.setSelection(
+            createCellSelection($lastCell, $firstCell)
           )
         );
       }
     }
-    return o;
+    return tr;
   };
 }
-const lt = ue("row"), rt = ue("col");
-function Z(e) {
-  return e[0].map((t, n) => e.map((o) => o[n]));
+const selectRow = selectLine("row");
+const selectCol = selectLine("col");
+function transpose(array) {
+  return array[0].map((_, i) => {
+    return array.map((column) => column[i]);
+  });
 }
-function pe(e, t) {
-  const n = [], o = h.get(e);
-  for (let r = 0; r < o.height; r++) {
-    const s = e.child(r), c = [];
-    for (let d = 0; d < o.width; d++) {
-      if (!t[r][d]) continue;
-      const p = o.map[r * o.width + d], a = t[r][d], u = e.nodeAt(p).type.createChecked(
-        Object.assign({}, a.attrs),
-        a.content,
-        a.marks
+function convertArrayOfRowsToTableNode(tableNode, arrayOfNodes) {
+  const rowsPM = [];
+  const map = TableMap.get(tableNode);
+  for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
+    const row = tableNode.child(rowIndex);
+    const rowCells = [];
+    for (let colIndex = 0; colIndex < map.width; colIndex++) {
+      if (!arrayOfNodes[rowIndex][colIndex]) continue;
+      const cellPos = map.map[rowIndex * map.width + colIndex];
+      const cell = arrayOfNodes[rowIndex][colIndex];
+      const oldCell = tableNode.nodeAt(cellPos);
+      const newCell = oldCell.type.createChecked(
+        Object.assign({}, cell.attrs),
+        cell.content,
+        cell.marks
       );
-      c.push(u);
+      rowCells.push(newCell);
     }
-    n.push(s.type.createChecked(s.attrs, c, s.marks));
+    rowsPM.push(row.type.createChecked(row.attrs, rowCells, row.marks));
   }
-  return e.type.createChecked(
-    e.attrs,
-    n,
-    e.marks
+  const newTable = tableNode.type.createChecked(
+    tableNode.attrs,
+    rowsPM,
+    tableNode.marks
   );
+  return newTable;
 }
-function fe(e) {
-  const t = h.get(e), n = [];
-  for (let o = 0; o < t.height; o++) {
-    const l = [], r = {};
-    for (let s = 0; s < t.width; s++) {
-      const c = t.map[o * t.width + s], d = e.nodeAt(c), p = t.findCell(c);
-      if (r[c] || p.top !== o) {
-        l.push(null);
+function convertTableNodeToArrayOfRows(tableNode) {
+  const map = TableMap.get(tableNode);
+  const rows = [];
+  for (let rowIndex = 0; rowIndex < map.height; rowIndex++) {
+    const rowCells = [];
+    const seen = {};
+    for (let colIndex = 0; colIndex < map.width; colIndex++) {
+      const cellPos = map.map[rowIndex * map.width + colIndex];
+      const cell = tableNode.nodeAt(cellPos);
+      const rect = map.findCell(cellPos);
+      if (seen[cellPos] || rect.top !== rowIndex) {
+        rowCells.push(null);
         continue;
       }
-      r[c] = !0, l.push(d);
+      seen[cellPos] = true;
+      rowCells.push(cell);
     }
-    n.push(l);
+    rows.push(rowCells);
   }
-  return n;
+  return rows;
 }
-function ge(e, t, n, o) {
-  const l = t[0] > n[0] ? -1 : 1, r = e.splice(t[0], t.length), s = r.length % 2 === 0 ? 1 : 0;
-  let c;
-  return c = l === -1 ? n[0] : n[n.length - 1] - s, e.splice(c, 0, ...r), e;
+function moveRowInArrayOfRows(rows, indexesOrigin, indexesTarget, directionOverride) {
+  const direction = indexesOrigin[0] > indexesTarget[0] ? -1 : 1;
+  const rowsExtracted = rows.splice(indexesOrigin[0], indexesOrigin.length);
+  const positionOffset = rowsExtracted.length % 2 === 0 ? 1 : 0;
+  let target;
+  {
+    target = direction === -1 ? indexesTarget[0] : indexesTarget[indexesTarget.length - 1] - positionOffset;
+  }
+  rows.splice(target, 0, ...rowsExtracted);
+  return rows;
 }
-function at(e, t, n, o) {
-  let l = Z(fe(e.node));
-  return l = ge(l, t, n), l = Z(l), pe(e.node, l);
+function moveTableColumn(table, indexesOrigin, indexesTarget, direction) {
+  let rows = transpose(convertTableNodeToArrayOfRows(table.node));
+  rows = moveRowInArrayOfRows(rows, indexesOrigin, indexesTarget);
+  rows = transpose(rows);
+  return convertArrayOfRowsToTableNode(table.node, rows);
 }
-function st(e, t, n, o) {
-  let l = fe(e.node);
-  return l = ge(l, t, n), pe(e.node, l);
+function moveTableRow(table, indexesOrigin, indexesTarget, direction) {
+  let rows = convertTableNodeToArrayOfRows(table.node);
+  rows = moveRowInArrayOfRows(rows, indexesOrigin, indexesTarget);
+  return convertArrayOfRowsToTableNode(table.node, rows);
 }
-function ee(e, t) {
-  let n = e, o = e;
-  for (let a = e; a >= 0; a--) {
-    const m = y(a, t.selection);
-    m && m.forEach((u) => {
-      const f = u.node.attrs.colspan + a - 1;
-      f >= n && (n = a), f > o && (o = f);
-    });
+function getSelectionRangeInColumn(columnIndex, tr) {
+  let startIndex = columnIndex;
+  let endIndex = columnIndex;
+  for (let i = columnIndex; i >= 0; i--) {
+    const cells = getCellsInCol(i, tr.selection);
+    if (cells) {
+      cells.forEach((cell) => {
+        const maybeEndIndex = cell.node.attrs.colspan + i - 1;
+        if (maybeEndIndex >= startIndex) startIndex = i;
+        if (maybeEndIndex > endIndex) endIndex = maybeEndIndex;
+      });
+    }
   }
-  for (let a = e; a <= o; a++) {
-    const m = y(a, t.selection);
-    m && m.forEach((u) => {
-      const f = u.node.attrs.colspan + a - 1;
-      u.node.attrs.colspan > 1 && f > o && (o = f);
-    });
+  for (let i = columnIndex; i <= endIndex; i++) {
+    const cells = getCellsInCol(i, tr.selection);
+    if (cells) {
+      cells.forEach((cell) => {
+        const maybeEndIndex = cell.node.attrs.colspan + i - 1;
+        if (cell.node.attrs.colspan > 1 && maybeEndIndex > endIndex)
+          endIndex = maybeEndIndex;
+      });
+    }
   }
-  const l = [];
-  for (let a = n; a <= o; a++) {
-    const m = y(a, t.selection);
-    m && m.length && l.push(a);
+  const indexes = [];
+  for (let i = startIndex; i <= endIndex; i++) {
+    const maybeCells = getCellsInCol(i, tr.selection);
+    if (maybeCells && maybeCells.length) indexes.push(i);
   }
-  n = l[0], o = l[l.length - 1];
-  const r = y(n, t.selection), s = w(0, t.selection), c = t.doc.resolve(
-    r[r.length - 1].pos
+  startIndex = indexes[0];
+  endIndex = indexes[indexes.length - 1];
+  const firstSelectedColumnCells = getCellsInCol(startIndex, tr.selection);
+  const firstRowCells = getCellsInRow(0, tr.selection);
+  const $anchor = tr.doc.resolve(
+    firstSelectedColumnCells[firstSelectedColumnCells.length - 1].pos
   );
-  let d;
-  for (let a = o; a >= n; a--) {
-    const m = y(a, t.selection);
-    if (m && m.length) {
-      for (let u = s.length - 1; u >= 0; u--)
-        if (s[u].pos === m[0].pos) {
-          d = m[0];
+  let headCell;
+  for (let i = endIndex; i >= startIndex; i--) {
+    const columnCells = getCellsInCol(i, tr.selection);
+    if (columnCells && columnCells.length) {
+      for (let j = firstRowCells.length - 1; j >= 0; j--) {
+        if (firstRowCells[j].pos === columnCells[0].pos) {
+          headCell = columnCells[0];
           break;
         }
-      if (d) break;
+      }
+      if (headCell) break;
     }
   }
-  const p = t.doc.resolve(d.pos);
-  return { $anchor: c, $head: p, indexes: l };
+  const $head = tr.doc.resolve(headCell.pos);
+  return { $anchor, $head, indexes };
 }
-function te(e, t) {
-  let n = e, o = e;
-  for (let a = e; a >= 0; a--)
-    w(a, t.selection).forEach((u) => {
-      const f = u.node.attrs.rowspan + a - 1;
-      f >= n && (n = a), f > o && (o = f);
+function getSelectionRangeInRow(rowIndex, tr) {
+  let startIndex = rowIndex;
+  let endIndex = rowIndex;
+  for (let i = rowIndex; i >= 0; i--) {
+    const cells = getCellsInRow(i, tr.selection);
+    cells.forEach((cell) => {
+      const maybeEndIndex = cell.node.attrs.rowspan + i - 1;
+      if (maybeEndIndex >= startIndex) startIndex = i;
+      if (maybeEndIndex > endIndex) endIndex = maybeEndIndex;
     });
-  for (let a = e; a <= o; a++)
-    w(a, t.selection).forEach((u) => {
-      const f = u.node.attrs.rowspan + a - 1;
-      u.node.attrs.rowspan > 1 && f > o && (o = f);
+  }
+  for (let i = rowIndex; i <= endIndex; i++) {
+    const cells = getCellsInRow(i, tr.selection);
+    cells.forEach((cell) => {
+      const maybeEndIndex = cell.node.attrs.rowspan + i - 1;
+      if (cell.node.attrs.rowspan > 1 && maybeEndIndex > endIndex)
+        endIndex = maybeEndIndex;
     });
-  const l = [];
-  for (let a = n; a <= o; a++) {
-    const m = w(a, t.selection);
-    m && m.length && l.push(a);
   }
-  n = l[0], o = l[l.length - 1];
-  const r = w(n, t.selection), s = y(0, t.selection), c = t.doc.resolve(
-    r[r.length - 1].pos
+  const indexes = [];
+  for (let i = startIndex; i <= endIndex; i++) {
+    const maybeCells = getCellsInRow(i, tr.selection);
+    if (maybeCells && maybeCells.length) indexes.push(i);
+  }
+  startIndex = indexes[0];
+  endIndex = indexes[indexes.length - 1];
+  const firstSelectedRowCells = getCellsInRow(startIndex, tr.selection);
+  const firstColumnCells = getCellsInCol(0, tr.selection);
+  const $anchor = tr.doc.resolve(
+    firstSelectedRowCells[firstSelectedRowCells.length - 1].pos
   );
-  let d;
-  for (let a = o; a >= n; a--) {
-    const m = w(a, t.selection);
-    if (m && m.length) {
-      for (let u = s.length - 1; u >= 0; u--)
-        if (s[u].pos === m[0].pos) {
-          d = m[0];
+  let headCell;
+  for (let i = endIndex; i >= startIndex; i--) {
+    const rowCells = getCellsInRow(i, tr.selection);
+    if (rowCells && rowCells.length) {
+      for (let j = firstColumnCells.length - 1; j >= 0; j--) {
+        if (firstColumnCells[j].pos === rowCells[0].pos) {
+          headCell = rowCells[0];
           break;
         }
-      if (d) break;
+      }
+      if (headCell) break;
     }
   }
-  const p = t.doc.resolve(d.pos);
-  return { $anchor: c, $head: p, indexes: l };
+  const $head = tr.doc.resolve(headCell.pos);
+  return { $anchor, $head, indexes };
 }
-function ct(e) {
-  const { tr: t, origin: n, target: o, select: l = !0, pos: r } = e, s = r != null ? t.doc.resolve(r) : t.selection.$from, c = M(s);
-  if (!c) return t;
-  const { indexes: d } = ee(n, t), { indexes: p } = ee(o, t);
-  if (d.includes(o)) return t;
-  const a = at(
-    c,
-    d,
-    p
-  ), m = _(t).replaceWith(
-    c.pos,
-    c.pos + c.node.nodeSize,
-    a
+function moveCol(moveColParams) {
+  const { tr, origin, target, select = true, pos } = moveColParams;
+  const $pos = pos != null ? tr.doc.resolve(pos) : tr.selection.$from;
+  const table = findTable($pos);
+  if (!table) return tr;
+  const { indexes: indexesOriginColumn } = getSelectionRangeInColumn(origin, tr);
+  const { indexes: indexesTargetColumn } = getSelectionRangeInColumn(target, tr);
+  if (indexesOriginColumn.includes(target)) return tr;
+  const newTable = moveTableColumn(
+    table,
+    indexesOriginColumn,
+    indexesTargetColumn
+  );
+  const _tr = cloneTr(tr).replaceWith(
+    table.pos,
+    table.pos + table.node.nodeSize,
+    newTable
   );
-  if (!l) return m;
-  const u = h.get(a), f = c.start, b = o, P = u.positionAt(u.height - 1, b, a), D = m.doc.resolve(f + P), E = k.colSelection, O = u.positionAt(0, b, a), H = m.doc.resolve(f + O);
-  return m.setSelection(E(D, H));
+  if (!select) return _tr;
+  const map = TableMap.get(newTable);
+  const start = table.start;
+  const index = target;
+  const lastCell = map.positionAt(map.height - 1, index, newTable);
+  const $lastCell = _tr.doc.resolve(start + lastCell);
+  const createCellSelection = CellSelection.colSelection;
+  const firstCell = map.positionAt(0, index, newTable);
+  const $firstCell = _tr.doc.resolve(start + firstCell);
+  return _tr.setSelection(createCellSelection($lastCell, $firstCell));
 }
-function it(e) {
-  const { tr: t, origin: n, target: o, select: l = !0, pos: r } = e, s = r != null ? t.doc.resolve(r) : t.selection.$from, c = M(s);
-  if (!c) return t;
-  const { indexes: d } = te(n, t), { indexes: p } = te(o, t);
-  if (d.includes(o)) return t;
-  const a = st(c, d, p), m = _(t).replaceWith(
-    c.pos,
-    c.pos + c.node.nodeSize,
-    a
+function moveRow(moveRowParams) {
+  const { tr, origin, target, select = true, pos } = moveRowParams;
+  const $pos = pos != null ? tr.doc.resolve(pos) : tr.selection.$from;
+  const table = findTable($pos);
+  if (!table) return tr;
+  const { indexes: indexesOriginRow } = getSelectionRangeInRow(origin, tr);
+  const { indexes: indexesTargetRow } = getSelectionRangeInRow(target, tr);
+  if (indexesOriginRow.includes(target)) return tr;
+  const newTable = moveTableRow(table, indexesOriginRow, indexesTargetRow);
+  const _tr = cloneTr(tr).replaceWith(
+    table.pos,
+    table.pos + table.node.nodeSize,
+    newTable
   );
-  if (!l) return m;
-  const u = h.get(a), f = c.start, b = o, P = u.positionAt(b, u.width - 1, a), D = m.doc.resolve(f + P), E = k.rowSelection, O = u.positionAt(b, 0, a), H = m.doc.resolve(f + O);
-  return m.setSelection(E(D, H));
+  if (!select) return _tr;
+  const map = TableMap.get(newTable);
+  const start = table.start;
+  const index = target;
+  const lastCell = map.positionAt(index, map.width - 1, newTable);
+  const $lastCell = _tr.doc.resolve(start + lastCell);
+  const createCellSelection = CellSelection.rowSelection;
+  const firstCell = map.positionAt(index, 0, newTable);
+  const $firstCell = _tr.doc.resolve(start + firstCell);
+  return _tr.setSelection(createCellSelection($lastCell, $firstCell));
 }
-const V = g(
+const goToPrevTableCellCommand = $command(
   "GoToPrevTableCell",
-  () => () => re(-1)
+  () => () => goToNextCell(-1)
 );
-i(V, {
+withMeta(goToPrevTableCellCommand, {
   displayName: "Command<goToPrevTableCellCommand>",
   group: "Table"
 });
-const U = g(
+const goToNextTableCellCommand = $command(
   "GoToNextTableCell",
-  () => () => re(1)
+  () => () => goToNextCell(1)
 );
-i(U, {
+withMeta(goToNextTableCellCommand, {
   displayName: "Command<goToNextTableCellCommand>",
   group: "Table"
 });
-const X = g(
+const exitTable = $command(
   "ExitTable",
-  (e) => () => (t, n) => {
-    if (!G(t)) return !1;
-    const { $head: o } = t.selection, l = Je(o, N.type(e));
-    if (!l) return !1;
-    const { to: r } = l, s = t.tr.replaceWith(
-      r,
-      r,
-      De.type(e).createAndFill()
+  (ctx) => () => (state, dispatch) => {
+    if (!isInTable(state)) return false;
+    const { $head } = state.selection;
+    const table = findParentNodeType($head, tableSchema.type(ctx));
+    if (!table) return false;
+    const { to } = table;
+    const tr = state.tr.replaceWith(
+      to,
+      to,
+      paragraphSchema.type(ctx).createAndFill()
     );
-    return s.setSelection(ce.near(s.doc.resolve(r), 1)).scrollIntoView(), n == null || n(s), !0;
+    tr.setSelection(Selection.near(tr.doc.resolve(to), 1)).scrollIntoView();
+    dispatch == null ? void 0 : dispatch(tr);
+    return true;
   }
 );
-i(X, {
+withMeta(exitTable, {
   displayName: "Command<breakTableCommand>",
   group: "Table"
 });
-const he = g(
+const insertTableCommand = $command(
   "InsertTable",
-  (e) => ({ row: t, col: n } = {}) => (o, l) => {
-    const { selection: r, tr: s } = o, { from: c } = r, d = de(e, t, n), p = s.replaceSelectionWith(d), a = ce.findFrom(p.doc.resolve(c), 1, !0);
-    return a && p.setSelection(a), l == null || l(p), !0;
+  (ctx) => ({ row, col } = {}) => (state, dispatch) => {
+    const { selection, tr } = state;
+    const { from } = selection;
+    const table = createTable(ctx, row, col);
+    const _tr = tr.replaceSelectionWith(table);
+    const sel = Selection.findFrom(_tr.doc.resolve(from), 1, true);
+    if (sel) _tr.setSelection(sel);
+    dispatch == null ? void 0 : dispatch(_tr);
+    return true;
   }
 );
-i(he, {
+withMeta(insertTableCommand, {
   displayName: "Command<insertTableCommand>",
   group: "Table"
 });
-const be = g(
+const moveRowCommand = $command(
   "MoveRow",
-  () => ({ from: e, to: t, pos: n } = {}) => (o, l) => {
-    const { tr: r } = o;
-    return !!(l == null ? void 0 : l(
-      it({ tr: r, origin: e ?? 0, target: t ?? 0, pos: n, select: !0 })
-    ));
+  () => ({ from, to, pos } = {}) => (state, dispatch) => {
+    const { tr } = state;
+    const result = dispatch == null ? void 0 : dispatch(
+      moveRow({ tr, origin: from ?? 0, target: to ?? 0, pos, select: true })
+    );
+    return Boolean(result);
   }
 );
-i(be, {
+withMeta(moveRowCommand, {
   displayName: "Command<moveRowCommand>",
   group: "Table"
 });
-const Ce = g(
+const moveColCommand = $command(
   "MoveCol",
-  () => ({ from: e, to: t, pos: n } = {}) => (o, l) => {
-    const { tr: r } = o;
-    return !!(l == null ? void 0 : l(
-      ct({ tr: r, origin: e ?? 0, target: t ?? 0, pos: n, select: !0 })
-    ));
+  () => ({ from, to, pos } = {}) => (state, dispatch) => {
+    const { tr } = state;
+    const result = dispatch == null ? void 0 : dispatch(
+      moveCol({ tr, origin: from ?? 0, target: to ?? 0, pos, select: true })
+    );
+    return Boolean(result);
   }
 );
-i(Ce, {
+withMeta(moveColCommand, {
   displayName: "Command<moveColCommand>",
   group: "Table"
 });
-const ye = g(
+const selectRowCommand = $command(
   "SelectRow",
-  () => (e = { index: 0 }) => (t, n) => {
-    const { tr: o } = t;
-    return !!(n == null ? void 0 : n(lt(e.index, e.pos)(o)));
+  () => (payload = { index: 0 }) => (state, dispatch) => {
+    const { tr } = state;
+    const result = dispatch == null ? void 0 : dispatch(selectRow(payload.index, payload.pos)(tr));
+    return Boolean(result);
   }
 );
-i(ye, {
+withMeta(selectRowCommand, {
   displayName: "Command<selectRowCommand>",
   group: "Table"
 });
-const we = g(
+const selectColCommand = $command(
   "SelectCol",
-  () => (e = { index: 0 }) => (t, n) => {
-    const { tr: o } = t;
-    return !!(n == null ? void 0 : n(rt(e.index, e.pos)(o)));
+  () => (payload = { index: 0 }) => (state, dispatch) => {
+    const { tr } = state;
+    const result = dispatch == null ? void 0 : dispatch(selectCol(payload.index, payload.pos)(tr));
+    return Boolean(result);
   }
 );
-i(we, {
+withMeta(selectColCommand, {
   displayName: "Command<selectColCommand>",
   group: "Table"
 });
-const ke = g(
+const selectTableCommand = $command(
   "SelectTable",
-  () => () => (e, t) => {
-    const { tr: n } = e;
-    return !!(t == null ? void 0 : t(nt(n)));
+  () => () => (state, dispatch) => {
+    const { tr } = state;
+    const result = dispatch == null ? void 0 : dispatch(selectTable(tr));
+    return Boolean(result);
   }
 );
-i(ke, {
+withMeta(selectTableCommand, {
   displayName: "Command<selectTableCommand>",
   group: "Table"
 });
-const Ne = g(
+const deleteSelectedCellsCommand = $command(
   "DeleteSelectedCells",
-  () => () => (e, t) => {
-    const { selection: n } = e;
-    if (!(n instanceof k)) return !1;
-    const o = n.isRowSelection(), l = n.isColSelection();
-    return o && l ? Ke(e, t) : l ? Fe(e, t) : Ge(e, t);
+  () => () => (state, dispatch) => {
+    const { selection } = state;
+    if (!(selection instanceof CellSelection)) return false;
+    const isRow = selection.isRowSelection();
+    const isCol = selection.isColSelection();
+    if (isRow && isCol) return deleteTable(state, dispatch);
+    if (isCol) return deleteColumn(state, dispatch);
+    else return deleteRow(state, dispatch);
   }
 );
-i(Ne, {
+withMeta(deleteSelectedCellsCommand, {
   displayName: "Command<deleteSelectedCellsCommand>",
   group: "Table"
 });
-const Te = g(
+const addColBeforeCommand = $command(
   "AddColBefore",
-  () => () => We
+  () => () => addColumnBefore
 );
-i(Te, {
+withMeta(addColBeforeCommand, {
   displayName: "Command<addColBeforeCommand>",
   group: "Table"
 });
-const Se = g(
+const addColAfterCommand = $command(
   "AddColAfter",
-  () => () => ze
+  () => () => addColumnAfter
 );
-i(Se, {
+withMeta(addColAfterCommand, {
   displayName: "Command<addColAfterCommand>",
   group: "Table"
 });
-const Re = g(
+const addRowBeforeCommand = $command(
   "AddRowBefore",
-  (e) => () => (t, n) => {
-    if (!G(t)) return !1;
-    if (n) {
-      const o = ae(t);
-      n(me(e, t.tr, o, o.top));
+  (ctx) => () => (state, dispatch) => {
+    if (!isInTable(state)) return false;
+    if (dispatch) {
+      const rect = selectedRect(state);
+      dispatch(addRowWithAlignment(ctx, state.tr, rect, rect.top));
     }
-    return !0;
+    return true;
   }
 );
-i(Re, {
+withMeta(addRowBeforeCommand, {
   displayName: "Command<addRowBeforeCommand>",
   group: "Table"
 });
-const xe = g(
+const addRowAfterCommand = $command(
   "AddRowAfter",
-  (e) => () => (t, n) => {
-    if (!G(t)) return !1;
-    if (n) {
-      const o = ae(t);
-      n(me(e, t.tr, o, o.bottom));
+  (ctx) => () => (state, dispatch) => {
+    if (!isInTable(state)) return false;
+    if (dispatch) {
+      const rect = selectedRect(state);
+      dispatch(addRowWithAlignment(ctx, state.tr, rect, rect.bottom));
     }
-    return !0;
+    return true;
   }
 );
-i(xe, {
+withMeta(addRowAfterCommand, {
   displayName: "Command<addRowAfterCommand>",
   group: "Table"
 });
-const Me = g(
+const setAlignCommand = $command(
   "SetAlign",
-  () => (e = "left") => je("alignment", e)
+  () => (alignment = "left") => setCellAttr("alignment", alignment)
 );
-i(Me, {
+withMeta(setAlignCommand, {
   displayName: "Command<setAlignCommand>",
   group: "Table"
 });
-const Ae = F(
-  (e) => new ne(
+const insertTableInputRule = $inputRule(
+  (ctx) => new InputRule(
     /^\|(?<col>\d+)[xX](?<row>\d+)\|\s$/,
-    (t, n, o, l) => {
-      var d, p;
-      const r = t.doc.resolve(o);
-      if (!r.node(-1).canReplaceWith(
-        r.index(-1),
-        r.indexAfter(-1),
-        N.type(e)
+    (state, match, start, end) => {
+      var _a, _b;
+      const $start = state.doc.resolve(start);
+      if (!$start.node(-1).canReplaceWith(
+        $start.index(-1),
+        $start.indexAfter(-1),
+        tableSchema.type(ctx)
       ))
         return null;
-      const s = de(
-        e,
-        Number((d = n.groups) == null ? void 0 : d.row),
-        Number((p = n.groups) == null ? void 0 : p.col)
-      ), c = t.tr.replaceRangeWith(o, l, s);
-      return c.setSelection(Qe.create(c.doc, o + 3)).scrollIntoView();
+      const row = Math.max(Number(((_a = match.groups) == null ? void 0 : _a.row) ?? 0), 2);
+      const tableNode = createTable(ctx, row, Number((_b = match.groups) == null ? void 0 : _b.col));
+      const tr = state.tr.replaceRangeWith(start, end, tableNode);
+      return tr.setSelection(TextSelection.create(tr.doc, start + 3)).scrollIntoView();
     }
   )
 );
-i(Ae, {
+withMeta(insertTableInputRule, {
   displayName: "InputRule<insertTableInputRule>",
   group: "Table"
 });
-const q = le("tableKeymap", {
+const tableKeymap = $useKeymap("tableKeymap", {
   NextCell: {
     shortcuts: ["Mod-]", "Tab"],
-    command: (e) => {
-      const t = e.get(A);
-      return () => t.call(U.key);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(goToNextTableCellCommand.key);
     }
   },
   PrevCell: {
     shortcuts: ["Mod-[", "Shift-Tab"],
-    command: (e) => {
-      const t = e.get(A);
-      return () => t.call(V.key);
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(goToPrevTableCellCommand.key);
     }
   },
   ExitTable: {
-    shortcuts: ["Mod-Enter"],
-    command: (e) => {
-      const t = e.get(A);
-      return () => t.call(X.key);
+    shortcuts: ["Mod-Enter", "Enter"],
+    command: (ctx) => {
+      const commands2 = ctx.get(commandsCtx);
+      return () => commands2.call(exitTable.key);
     }
   }
 });
-i(q.ctx, {
+withMeta(tableKeymap.ctx, {
   displayName: "KeymapCtx<table>",
   group: "Table"
 });
-i(q.shortcuts, {
+withMeta(tableKeymap.shortcuts, {
   displayName: "Keymap<table>",
   group: "Table"
 });
-const B = "footnote_definition", oe = "footnoteDefinition", J = C(
+const id$1 = "footnote_definition";
+const markdownId = "footnoteDefinition";
+const footnoteDefinitionSchema = $nodeSchema(
   "footnote_definition",
   () => ({
     group: "block",
     content: "block+",
-    defining: !0,
+    defining: true,
     attrs: {
       label: {
         default: ""
@@ -761,62 +892,63 @@ const B = "footnote_definition", oe = "footnoteDefinition", J = C(
     },
     parseDOM: [
       {
-        tag: `dl[data-type="${B}"]`,
-        getAttrs: (e) => {
-          if (!(e instanceof HTMLElement)) throw K(e);
+        tag: `dl[data-type="${id$1}"]`,
+        getAttrs: (dom) => {
+          if (!(dom instanceof HTMLElement)) throw expectDomTypeError(dom);
           return {
-            label: e.dataset.label
+            label: dom.dataset.label
           };
         },
         contentElement: "dd"
       }
     ],
-    toDOM: (e) => {
-      const t = e.attrs.label;
+    toDOM: (node) => {
+      const label = node.attrs.label;
       return [
         "dl",
         {
           // TODO: add a prosemirror plugin to sync label on change
-          "data-label": t,
-          "data-type": B
+          "data-label": label,
+          "data-type": id$1
         },
-        ["dt", t],
+        ["dt", label],
         ["dd", 0]
       ];
     },
     parseMarkdown: {
-      match: ({ type: e }) => e === oe,
-      runner: (e, t, n) => {
-        e.openNode(n, {
-          label: t.label
-        }).next(t.children).closeNode();
+      match: ({ type }) => type === markdownId,
+      runner: (state, node, type) => {
+        state.openNode(type, {
+          label: node.label
+        }).next(node.children).closeNode();
       }
     },
     toMarkdown: {
-      match: (e) => e.type.name === B,
-      runner: (e, t) => {
-        e.openNode(oe, void 0, {
-          label: t.attrs.label,
-          identifier: t.attrs.label
-        }).next(t.content).closeNode();
+      match: (node) => node.type.name === id$1,
+      runner: (state, node) => {
+        state.openNode(markdownId, void 0, {
+          label: node.attrs.label,
+          identifier: node.attrs.label
+        }).next(node.content).closeNode();
       }
     }
   })
 );
-i(J.ctx, {
+withMeta(footnoteDefinitionSchema.ctx, {
   displayName: "NodeSchemaCtx<footnodeDef>",
   group: "footnote"
 });
-i(J.node, {
+withMeta(footnoteDefinitionSchema.node, {
   displayName: "NodeSchema<footnodeDef>",
   group: "footnote"
 });
-const L = "footnote_reference", Q = C(
+const id = "footnote_reference";
+const footnoteReferenceSchema = $nodeSchema(
   "footnote_reference",
   () => ({
     group: "inline",
-    inline: !0,
-    atom: !0,
+    inline: true,
+    atom: true,
     attrs: {
       label: {
         default: ""
@@ -824,300 +956,341 @@ const L = "footnote_reference", Q = C(
     },
     parseDOM: [
       {
-        tag: `sup[data-type="${L}"]`,
-        getAttrs: (e) => {
-          if (!(e instanceof HTMLElement)) throw K(e);
+        tag: `sup[data-type="${id}"]`,
+        getAttrs: (dom) => {
+          if (!(dom instanceof HTMLElement)) throw expectDomTypeError(dom);
           return {
-            label: e.dataset.label
+            label: dom.dataset.label
           };
         }
       }
     ],
-    toDOM: (e) => {
-      const t = e.attrs.label;
+    toDOM: (node) => {
+      const label = node.attrs.label;
       return [
         "sup",
         {
           // TODO: add a prosemirror plugin to sync label on change
-          "data-label": t,
-          "data-type": L
+          "data-label": label,
+          "data-type": id
         },
-        t
+        label
       ];
     },
     parseMarkdown: {
-      match: ({ type: e }) => e === "footnoteReference",
-      runner: (e, t, n) => {
-        e.addNode(n, {
-          label: t.label
+      match: ({ type }) => type === "footnoteReference",
+      runner: (state, node, type) => {
+        state.addNode(type, {
+          label: node.label
         });
       }
     },
     toMarkdown: {
-      match: (e) => e.type.name === L,
-      runner: (e, t) => {
-        e.addNode("footnoteReference", void 0, void 0, {
-          label: t.attrs.label,
-          identifier: t.attrs.label
+      match: (node) => node.type.name === id,
+      runner: (state, node) => {
+        state.addNode("footnoteReference", void 0, void 0, {
+          label: node.attrs.label,
+          identifier: node.attrs.label
         });
       }
     }
   })
 );
-i(Q.ctx, {
+withMeta(footnoteReferenceSchema.ctx, {
   displayName: "NodeSchemaCtx<footnodeRef>",
   group: "footnote"
 });
-i(Q.node, {
+withMeta(footnoteReferenceSchema.node, {
   displayName: "NodeSchema<footnodeRef>",
   group: "footnote"
 });
-const ve = Ee.extendSchema(
-  (e) => (t) => {
-    const n = e(t);
-    return {
-      ...n,
-      attrs: {
-        ...n.attrs,
-        checked: {
-          default: null
-        }
-      },
-      parseDOM: [
-        {
-          tag: 'li[data-item-type="task"]',
-          getAttrs: (o) => {
-            if (!(o instanceof HTMLElement)) throw K(o);
-            return {
-              label: o.dataset.label,
-              listType: o.dataset.listType,
-              spread: o.dataset.spread,
-              checked: o.dataset.checked ? o.dataset.checked === "true" : null
-            };
+const extendListItemSchemaForTask = listItemSchema.extendSchema(
+  (prev) => {
+    return (ctx) => {
+      const baseSchema = prev(ctx);
+      return {
+        ...baseSchema,
+        attrs: {
+          ...baseSchema.attrs,
+          checked: {
+            default: null
           }
         },
-        ...(n == null ? void 0 : n.parseDOM) || []
-      ],
-      toDOM: (o) => n.toDOM && o.attrs.checked == null ? n.toDOM(o) : [
-        "li",
-        {
-          "data-item-type": "task",
-          "data-label": o.attrs.label,
-          "data-list-type": o.attrs.listType,
-          "data-spread": o.attrs.spread,
-          "data-checked": o.attrs.checked
+        parseDOM: [
+          {
+            tag: 'li[data-item-type="task"]',
+            getAttrs: (dom) => {
+              if (!(dom instanceof HTMLElement)) throw expectDomTypeError(dom);
+              return {
+                label: dom.dataset.label,
+                listType: dom.dataset.listType,
+                spread: dom.dataset.spread,
+                checked: dom.dataset.checked ? dom.dataset.checked === "true" : null
+              };
+            }
+          },
+          ...(baseSchema == null ? void 0 : baseSchema.parseDOM) || []
+        ],
+        toDOM: (node) => {
+          if (baseSchema.toDOM && node.attrs.checked == null)
+            return baseSchema.toDOM(node);
+          return [
+            "li",
+            {
+              "data-item-type": "task",
+              "data-label": node.attrs.label,
+              "data-list-type": node.attrs.listType,
+              "data-spread": node.attrs.spread,
+              "data-checked": node.attrs.checked
+            },
+            0
+          ];
         },
-        0
-      ],
-      parseMarkdown: {
-        match: ({ type: o }) => o === "listItem",
-        runner: (o, l, r) => {
-          if (l.checked == null) {
-            n.parseMarkdown.runner(o, l, r);
-            return;
+        parseMarkdown: {
+          match: ({ type }) => type === "listItem",
+          runner: (state, node, type) => {
+            if (node.checked == null) {
+              baseSchema.parseMarkdown.runner(state, node, type);
+              return;
+            }
+            const label = node.label != null ? `${node.label}.` : "•";
+            const checked = node.checked != null ? Boolean(node.checked) : null;
+            const listType = node.label != null ? "ordered" : "bullet";
+            const spread = node.spread != null ? `${node.spread}` : "true";
+            state.openNode(type, { label, listType, spread, checked });
+            state.next(node.children);
+            state.closeNode();
           }
-          const s = l.label != null ? `${l.label}.` : "•", c = l.checked != null ? !!l.checked : null, d = l.label != null ? "ordered" : "bullet", p = l.spread != null ? `${l.spread}` : "true";
-          o.openNode(r, { label: s, listType: d, spread: p, checked: c }), o.next(l.children), o.closeNode();
-        }
-      },
-      toMarkdown: {
-        match: (o) => o.type.name === "list_item",
-        runner: (o, l) => {
-          if (l.attrs.checked == null) {
-            n.toMarkdown.runner(o, l);
-            return;
+        },
+        toMarkdown: {
+          match: (node) => node.type.name === "list_item",
+          runner: (state, node) => {
+            if (node.attrs.checked == null) {
+              baseSchema.toMarkdown.runner(state, node);
+              return;
+            }
+            const label = node.attrs.label;
+            const listType = node.attrs.listType;
+            const spread = node.attrs.spread === "true";
+            const checked = node.attrs.checked;
+            state.openNode("listItem", void 0, {
+              label,
+              listType,
+              spread,
+              checked
+            });
+            state.next(node.content);
+            state.closeNode();
           }
-          const r = l.attrs.label, s = l.attrs.listType, c = l.attrs.spread === "true", d = l.attrs.checked;
-          o.openNode("listItem", void 0, {
-            label: r,
-            listType: s,
-            spread: c,
-            checked: d
-          }), o.next(l.content), o.closeNode();
         }
-      }
+      };
     };
   }
 );
-i(ve, {
+withMeta(extendListItemSchemaForTask, {
   displayName: "NodeSchema<listItem>",
   group: "ListItem"
 });
-const _e = F(() => new ne(
-  /^\[(?<checked>\s|x)\]\s$/,
-  (e, t, n, o) => {
-    var a;
-    const l = e.doc.resolve(n);
-    let r = 0, s = l.node(r);
-    for (; s && s.type.name !== "list_item"; )
-      r--, s = l.node(r);
-    if (!s || s.attrs.checked != null) return null;
-    const c = ((a = t.groups) == null ? void 0 : a.checked) === "x", d = l.before(r), p = e.tr;
-    return p.deleteRange(n, o).setNodeMarkup(d, void 0, {
-      ...s.attrs,
-      checked: c
-    }), p;
-  }
-));
-i(_e, {
+const wrapInTaskListInputRule = $inputRule(() => {
+  return new InputRule(
+    /^\[(?<checked>\s|x)\]\s$/,
+    (state, match, start, end) => {
+      var _a;
+      const pos = state.doc.resolve(start);
+      let depth = 0;
+      let node = pos.node(depth);
+      while (node && node.type.name !== "list_item") {
+        depth--;
+        node = pos.node(depth);
+      }
+      if (!node || node.attrs.checked != null) return null;
+      const checked = Boolean(((_a = match.groups) == null ? void 0 : _a.checked) === "x");
+      const finPos = pos.before(depth);
+      const tr = state.tr;
+      tr.deleteRange(start, end).setNodeMarkup(finPos, void 0, {
+        ...node.attrs,
+        checked
+      });
+      return tr;
+    }
+  );
+});
+withMeta(wrapInTaskListInputRule, {
   displayName: "InputRule<wrapInTaskListInputRule>",
   group: "ListItem"
 });
-const dt = [
-  j,
-  q
-].flat(), mt = [
-  Ae,
-  _e
-], ut = [ie], $e = v(() => et);
-i($e, {
+const keymap = [
+  strikethroughKeymap,
+  tableKeymap
+].flat();
+const inputRules = [
+  insertTableInputRule,
+  wrapInTaskListInputRule
+];
+const markInputRules = [strikethroughInputRule];
+const autoInsertSpanPlugin = $prose(() => imeSpan);
+withMeta(autoInsertSpanPlugin, {
   displayName: "Prose<autoInsertSpanPlugin>",
   group: "Prose"
 });
-const pt = v(() => Ve({}));
-i(pt, {
+const columnResizingPlugin = $prose(() => columnResizing({}));
+withMeta(columnResizingPlugin, {
   displayName: "Prose<columnResizingPlugin>",
   group: "Prose"
 });
-const Ie = v(
-  () => Ue({ allowTableNodeSelection: !0 })
+const tableEditingPlugin = $prose(
+  () => tableEditing({ allowTableNodeSelection: true })
 );
-i(Ie, {
+withMeta(tableEditingPlugin, {
   displayName: "Prose<tableEditingPlugin>",
   group: "Prose"
 });
-const Y = Be("remarkGFM", () => tt);
-i(Y.plugin, {
+const remarkGFMPlugin = $remark("remarkGFM", () => remarkGFM);
+withMeta(remarkGFMPlugin.plugin, {
   displayName: "Remark<remarkGFMPlugin>",
   group: "Remark"
 });
-i(Y.options, {
+withMeta(remarkGFMPlugin.options, {
   displayName: "RemarkConfig<remarkGFMPlugin>",
   group: "Remark"
 });
-const ft = new Ze("MILKDOWN_KEEP_TABLE_ALIGN_PLUGIN");
-function gt(e, t) {
-  let n = 0;
-  return t.forEach((o, l, r) => {
-    o === e && (n = r);
-  }), n;
+const pluginKey = new PluginKey("MILKDOWN_KEEP_TABLE_ALIGN_PLUGIN");
+function getChildIndex(node, parent) {
+  let index = 0;
+  parent.forEach((child, _offset, i) => {
+    if (child === node) index = i;
+  });
+  return index;
 }
-const Pe = v(() => new Ye({
-  key: ft,
-  appendTransaction: (e, t, n) => {
-    let o;
-    const l = (r, s) => {
-      if (o || (o = n.tr), r.type.name !== "table_cell") return;
-      const c = n.doc.resolve(s), d = c.node(c.depth), a = c.node(c.depth - 1).firstChild;
-      if (!a) return;
-      const m = gt(r, d), u = a.maybeChild(m);
-      if (!u) return;
-      const f = u.attrs.alignment, b = r.attrs.alignment;
-      f !== b && o.setNodeMarkup(s, void 0, { ...r.attrs, alignment: f });
-    };
-    return t.doc !== n.doc && n.doc.descendants(l), o;
-  }
-}));
-i(Pe, {
+const keepTableAlignPlugin = $prose(() => {
+  return new Plugin({
+    key: pluginKey,
+    appendTransaction: (_tr, oldState, state) => {
+      let tr;
+      const check = (node, pos) => {
+        if (!tr) tr = state.tr;
+        if (node.type.name !== "table_cell") return;
+        const $pos = state.doc.resolve(pos);
+        const tableRow = $pos.node($pos.depth);
+        const table = $pos.node($pos.depth - 1);
+        const tableHeaderRow = table.firstChild;
+        if (!tableHeaderRow) return;
+        const index = getChildIndex(node, tableRow);
+        const headerCell = tableHeaderRow.maybeChild(index);
+        if (!headerCell) return;
+        const align = headerCell.attrs.alignment;
+        const currentAlign = node.attrs.alignment;
+        if (align === currentAlign) return;
+        tr.setNodeMarkup(pos, void 0, { ...node.attrs, alignment: align });
+      };
+      if (oldState.doc !== state.doc) state.doc.descendants(check);
+      return tr;
+    }
+  });
+});
+withMeta(keepTableAlignPlugin, {
   displayName: "Prose<keepTableAlignPlugin>",
   group: "Prose"
 });
-const ht = [
-  Pe,
-  $e,
-  Y,
-  Ie
-].flat(), bt = [
-  ve,
-  N,
-  $,
-  R,
-  I,
-  x,
-  J,
-  Q,
-  W,
-  T
-].flat(), Ct = [
-  U,
-  V,
-  X,
-  he,
-  be,
-  Ce,
-  ye,
-  we,
-  ke,
-  Ne,
-  Re,
-  xe,
-  Te,
-  Se,
-  Me,
-  z
-], _t = [
-  bt,
-  mt,
-  ut,
-  dt,
-  Ct,
-  ht
+const plugins = [
+  keepTableAlignPlugin,
+  autoInsertSpanPlugin,
+  remarkGFMPlugin,
+  tableEditingPlugin
+].flat();
+const schema = [
+  extendListItemSchemaForTask,
+  tableSchema,
+  tableHeaderRowSchema,
+  tableRowSchema,
+  tableHeaderSchema,
+  tableCellSchema,
+  footnoteDefinitionSchema,
+  footnoteReferenceSchema,
+  strikethroughAttr,
+  strikethroughSchema
+].flat();
+const commands = [
+  goToNextTableCellCommand,
+  goToPrevTableCellCommand,
+  exitTable,
+  insertTableCommand,
+  moveRowCommand,
+  moveColCommand,
+  selectRowCommand,
+  selectColCommand,
+  selectTableCommand,
+  deleteSelectedCellsCommand,
+  addRowBeforeCommand,
+  addRowAfterCommand,
+  addColBeforeCommand,
+  addColAfterCommand,
+  setAlignCommand,
+  toggleStrikethroughCommand
+];
+const gfm = [
+  schema,
+  inputRules,
+  markInputRules,
+  keymap,
+  commands,
+  plugins
 ].flat();
 export {
-  Se as addColAfterCommand,
-  Te as addColBeforeCommand,
-  xe as addRowAfterCommand,
-  Re as addRowBeforeCommand,
-  me as addRowWithAlignment,
-  $e as autoInsertSpanPlugin,
-  pt as columnResizingPlugin,
-  Ct as commands,
-  de as createTable,
-  Ne as deleteSelectedCellsCommand,
-  X as exitTable,
-  ve as extendListItemSchemaForTask,
-  M as findTable,
-  J as footnoteDefinitionSchema,
-  Q as footnoteReferenceSchema,
-  ot as getAllCellsInTable,
-  y as getCellsInCol,
-  w as getCellsInRow,
-  _t as gfm,
-  U as goToNextTableCellCommand,
-  V as goToPrevTableCellCommand,
-  mt as inputRules,
-  he as insertTableCommand,
-  Ae as insertTableInputRule,
-  Pe as keepTableAlignPlugin,
-  dt as keymap,
-  ut as markInputRules,
-  ct as moveCol,
-  Ce as moveColCommand,
-  it as moveRow,
-  be as moveRowCommand,
-  ht as plugins,
-  Y as remarkGFMPlugin,
-  bt as schema,
-  rt as selectCol,
-  we as selectColCommand,
-  ue as selectLine,
-  lt as selectRow,
-  ye as selectRowCommand,
-  nt as selectTable,
-  ke as selectTableCommand,
-  Me as setAlignCommand,
-  W as strikethroughAttr,
-  ie as strikethroughInputRule,
-  j as strikethroughKeymap,
-  T as strikethroughSchema,
-  x as tableCellSchema,
-  Ie as tableEditingPlugin,
-  $ as tableHeaderRowSchema,
-  I as tableHeaderSchema,
-  q as tableKeymap,
-  R as tableRowSchema,
-  N as tableSchema,
-  z as toggleStrikethroughCommand,
-  _e as wrapInTaskListInputRule
+  addColAfterCommand,
+  addColBeforeCommand,
+  addRowAfterCommand,
+  addRowBeforeCommand,
+  addRowWithAlignment,
+  autoInsertSpanPlugin,
+  columnResizingPlugin,
+  commands,
+  createTable,
+  deleteSelectedCellsCommand,
+  exitTable,
+  extendListItemSchemaForTask,
+  findTable,
+  footnoteDefinitionSchema,
+  footnoteReferenceSchema,
+  getAllCellsInTable,
+  getCellsInCol,
+  getCellsInRow,
+  gfm,
+  goToNextTableCellCommand,
+  goToPrevTableCellCommand,
+  inputRules,
+  insertTableCommand,
+  insertTableInputRule,
+  keepTableAlignPlugin,
+  keymap,
+  markInputRules,
+  moveCol,
+  moveColCommand,
+  moveRow,
+  moveRowCommand,
+  plugins,
+  remarkGFMPlugin,
+  schema,
+  selectCol,
+  selectColCommand,
+  selectLine,
+  selectRow,
+  selectRowCommand,
+  selectTable,
+  selectTableCommand,
+  setAlignCommand,
+  strikethroughAttr,
+  strikethroughInputRule,
+  strikethroughKeymap,
+  strikethroughSchema,
+  tableCellSchema,
+  tableEditingPlugin,
+  tableHeaderRowSchema,
+  tableHeaderSchema,
+  tableKeymap,
+  tableRowSchema,
+  tableSchema,
+  toggleStrikethroughCommand,
+  wrapInTaskListInputRule
 };
 //# sourceMappingURL=index.es.js.map