@milkdown/preset-gfm 6.2.0 → 6.3.2

package/lib/index.es.js

@@ -1,66 +1,37 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key2, value) => key2 in obj ? __defProp(obj, key2, { enumerable: true, configurable: true, writable: true, value }) : obj[key2] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-import { SupportedKeys as SupportedKeys$2, commonmark, commands as commands$1 } from "@milkdown/preset-commonmark";
-export { InsertHardbreak, InsertHr, InsertImage, LiftListItem, ModifyImage, ModifyLink, SinkListItem, SplitListItem, ToggleBold, ToggleInlineCode, ToggleItalic, ToggleLink, TurnIntoCodeFence, TurnIntoHeading, TurnIntoText, WrapInBlockquote, WrapInBulletList, WrapInOrderedList, blockquote, bulletList, codeFence, codeInline, commonmark, commonmarkNodes, commonmarkPlugins, doc, em, hardbreak, heading, hr, image, link, listItem, orderedList, paragraph, strong, text } from "@milkdown/preset-commonmark";
-import { $prose, createNode, createPlugin, createShortcut, createMark, AtomList, $remark } from "@milkdown/utils";
-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, SelectionRange, TextSelection } from "@milkdown/prose/state";
-import { toggleMark, wrapIn } from "@milkdown/prose/commands";
-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({
+import { SupportedKeys as st, commonmark as rt, commands as it } from "@milkdown/preset-commonmark";
+import { InsertHardbreak as ho, InsertHr as mo, InsertImage as go, LiftListItem as wo, ModifyImage as bo, ModifyLink as Co, SinkListItem as yo, SplitListItem as ko, ToggleBold as Ao, ToggleInlineCode as Mo, ToggleItalic as So, ToggleLink as No, TurnIntoCodeFence as xo, TurnIntoHeading as Ro, TurnIntoText as To, WrapInBlockquote as Lo, WrapInBulletList as vo, WrapInOrderedList as Eo, blockquote as Io, bulletList as $o, codeFence as Do, codeInline as Oo, commonmark as _o, commonmarkNodes as zo, commonmarkPlugins as Fo, doc as Bo, em as Po, HardbreakFilterPluginKey as Wo, heading as Ho, hr as jo, image as Ko, link as qo, listItem as Uo, orderedList as Xo, paragraph as Vo, strong as Zo, text as Go } from "@milkdown/preset-commonmark";
+import { $prose as ct, createNode as be, createPlugin as at, createShortcut as $, createMark as dt, AtomList as ut, $remark as ft } from "@milkdown/utils";
+import pt from "remark-gfm";
+import { inputRules as ht, InputRule as Ce, wrappingInputRule as Ve } from "@milkdown/prose/inputrules";
+import { createCmdKey as R, editorViewCtx as ee, createCmd as N, commandsCtx as Ze, themeManagerCtx as L, ThemeIcon as v, ThemeBorder as mt, ThemeShadow as gt, getPalette as wt, ThemeSize as xe, schemaCtx as re } from "@milkdown/core";
+import { expectDomTypeError as ye, missingRootElement as bt } from "@milkdown/exception";
+import { findSelectedNodeOfType as B, findParentNode as Ct, cloneTr as Ge, calculateNodePosition as yt, browser as Re, markRule as Te } from "@milkdown/prose";
+import { PluginKey as F, NodeSelection as te, Plugin as W, Selection as S, SelectionRange as kt, TextSelection as D } from "@milkdown/prose/state";
+import { toggleMark as At, wrapIn as Mt } from "@milkdown/prose/commands";
+import { Fragment as E, Slice as O } from "@milkdown/prose/model";
+import { Decoration as ke, DecorationSet as Ae } from "@milkdown/prose/view";
+import { keydownHandler as St } from "@milkdown/prose/keymap";
+import { Transform as Nt } from "@milkdown/prose/transform";
+import { splitListItem as xt, sinkListItem as Rt, liftListItem as Tt } from "@milkdown/prose/schema-list";
+const Lt = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&//=]*)$/, vt = () => ht({
   rules: [
-    new InputRule(urlRegex, (state, match, start, end) => {
-      var _a;
-      const { schema: schema2 } = state;
-      const [text2] = match;
-      if (!text2)
-        return null;
-      const link2 = (_a = schema2.marks["link"]) == null ? void 0 : _a.create({ href: text2 });
-      if (!link2)
+    new Ce(Lt, (o, e, t, n) => {
+      var a;
+      const { schema: l } = o, [s] = e;
+      if (!s)
         return null;
-      return state.tr.replaceWith(start, end, schema2.text(text2)).addMark(start, text2.length + start, link2);
+      const r = (a = l.marks.link) == null ? void 0 : a.create({ href: s });
+      return r ? o.tr.replaceWith(t, n, l.text(s)).addMark(t, s.length + t, r) : null;
     })
   ]
-});
-const urlPlugin = $prose(() => proseUrlPlugin());
-const getFootnoteRefId = (label) => `footnote-ref-${label}`;
-const getFootnoteDefId = (label) => `footnote-def-${label}`;
-const key$2 = new PluginKey("MILKDOWN_FOOTNOTE_DEF_INPUT");
-const ModifyFootnoteDef = createCmdKey("ModifyFootnoteDef");
-const footnoteDefinition = createNode((utils) => {
-  const id2 = "footnote_definition";
-  const markdownId = "footnoteDefinition";
+}), Et = ct(() => vt()), Je = (o) => `footnote-ref-${o}`, Ye = (o) => `footnote-def-${o}`, It = new F("MILKDOWN_FOOTNOTE_DEF_INPUT"), Le = R("ModifyFootnoteDef"), $t = be((o) => {
+  const e = "footnote_definition", t = "footnoteDefinition";
   return {
-    id: id2,
-    schema: (ctx) => ({
+    id: e,
+    schema: (n) => ({
       group: "block",
       content: "block+",
-      defining: true,
+      defining: !0,
       attrs: {
         label: {
           default: ""
@@ -68,148 +39,115 @@ const footnoteDefinition = createNode((utils) => {
       },
       parseDOM: [
         {
-          tag: `div[data-type="${id2}"]`,
-          getAttrs: (dom) => {
-            if (!(dom instanceof HTMLElement)) {
-              throw new Error();
-            }
+          tag: `div[data-type="${e}"]`,
+          getAttrs: (l) => {
+            if (!(l instanceof HTMLElement))
+              throw ye(l);
             return {
-              label: dom.dataset["label"]
+              label: l.dataset.label
             };
-          }
+          },
+          contentElement: "dd"
         }
       ],
-      toDOM: (node) => {
-        const label = node.attrs["label"];
-        const className = utils.getClassName(node.attrs, "footnote-definition");
-        const dt = document.createElement("dt");
-        dt.textContent = `[${label}]:`;
-        dt.onclick = () => {
-          const view = ctx.get(editorViewCtx);
-          const selection = NodeSelection.create(view.state.doc, view.state.selection.from - 2);
-          view.dispatch(view.state.tr.setSelection(selection));
-        };
-        const a = document.createElement("a");
-        a.href = `#${getFootnoteRefId(label)}`;
-        a.contentEditable = "false";
-        a.textContent = "\u21A9";
-        a.onmousedown = (e) => {
-          e.preventDefault();
+      toDOM: (l) => {
+        const s = l.attrs.label, r = o.getClassName(l.attrs, "footnote-definition"), a = document.createElement("dt");
+        a.textContent = `[${s}]:`, a.onclick = () => {
+          const c = n.get(ee), d = te.create(c.state.doc, c.state.selection.from - 2);
+          c.dispatch(c.state.tr.setSelection(d));
         };
-        return [
+        const i = document.createElement("a");
+        return i.href = `#${Je(s)}`, i.contentEditable = "false", i.textContent = "\u21A9", i.onmousedown = (c) => {
+          c.preventDefault();
+        }, [
           "div",
           {
-            class: className,
-            "data-label": label,
-            "data-type": id2,
-            id: getFootnoteDefId(label)
+            class: r,
+            "data-label": s,
+            "data-type": e,
+            id: Ye(s)
           },
-          ["div", { class: "footnote-definition_content" }, dt, ["dd", 0]],
-          ["div", { class: "footnote-definition_anchor" }, a]
+          ["div", { class: "footnote-definition_content" }, a, ["dd", 0]],
+          ["div", { class: "footnote-definition_anchor" }, i]
         ];
       },
       parseMarkdown: {
-        match: ({ type }) => type === markdownId,
-        runner: (state, node, type) => {
-          state.openNode(type, {
-            label: node["label"]
-          }).next(node.children).closeNode();
+        match: ({ type: l }) => l === t,
+        runner: (l, s, r) => {
+          l.openNode(r, {
+            label: s.label
+          }).next(s.children).closeNode();
         }
       },
       toMarkdown: {
-        match: (node) => node.type.name === id2,
-        runner: (state, node) => {
-          state.openNode(markdownId, void 0, {
-            label: node.attrs["label"],
-            identifier: node.attrs["label"]
-          }).next(node.content).closeNode();
+        match: (l) => l.type.name === e,
+        runner: (l, s) => {
+          l.openNode(t, void 0, {
+            label: s.attrs.label,
+            identifier: s.attrs.label
+          }).next(s.content).closeNode();
         }
       }
     }),
-    commands: (nodeType) => [
-      createCmd(ModifyFootnoteDef, (label = "") => (state, dispatch) => {
-        const node = findSelectedNodeOfType(state.selection, nodeType);
-        if (!node)
-          return false;
-        const { tr } = state;
-        const _tr = tr.setNodeMarkup(node.pos, void 0, __spreadProps(__spreadValues({}, node.node.attrs), { label }));
-        dispatch == null ? void 0 : dispatch(_tr.setSelection(NodeSelection.create(_tr.doc, node.pos)));
-        return true;
+    commands: (n) => [
+      N(Le, (l = "") => (s, r) => {
+        const a = B(s.selection, n);
+        if (!a)
+          return !1;
+        const { tr: i } = s, c = i.setNodeMarkup(a.pos, void 0, { ...a.node.attrs, label: l });
+        return r == null || r(c.setSelection(te.create(c.doc, a.pos))), !0;
       })
     ],
-    inputRules: (nodeType) => [
-      wrappingInputRule(/(?:\[\^)([^:]+)(?::)$/, nodeType, (match) => {
-        var _a;
-        const label = (_a = match[1]) != null ? _a : "footnote";
+    inputRules: (n) => [
+      Ve(/(?:\[\^)([^:]+)(?::)$/, n, (l) => {
+        var r;
         return {
-          label
+          label: (r = l[1]) != null ? r : "footnote"
         };
-      }, () => false)
+      }, () => !1)
     ],
-    prosePlugins: (type, ctx) => {
-      return [
-        new Plugin({
-          key: key$2,
-          view: (editorView) => {
-            const inputChipRenderer = utils.themeManager.get("input-chip", {
-              width: "12em",
-              placeholder: "Input Footnote Label",
-              onUpdate: (value) => {
-                ctx.get(commandsCtx).call(ModifyFootnoteDef, value);
-              },
-              isBindMode: true
-            });
-            if (!inputChipRenderer)
-              return {};
-            const shouldDisplay = (view) => Boolean(type && findSelectedNodeOfType(view.state.selection, type));
-            const getCurrentLabel = (view) => {
-              const result = findSelectedNodeOfType(view.state.selection, type);
-              if (!result)
-                return;
-              const value = result.node.attrs["label"];
-              return value;
-            };
-            const renderByView = (view) => {
-              if (!view.editable) {
-                return;
-              }
-              const display = shouldDisplay(view);
-              if (display) {
-                inputChipRenderer.show(view);
-                inputChipRenderer.update(getCurrentLabel(view));
-              } else {
-                inputChipRenderer.hide();
-              }
-            };
-            inputChipRenderer.init(editorView);
-            renderByView(editorView);
-            return {
-              update: (view, prevState) => {
-                const isEqualSelection = (prevState == null ? void 0 : prevState.doc.eq(view.state.doc)) && prevState.selection.eq(view.state.selection);
-                if (isEqualSelection)
-                  return;
-                renderByView(view);
-              },
-              destroy: () => {
-                inputChipRenderer.destroy();
-              }
-            };
-          }
-        })
-      ];
-    }
+    prosePlugins: (n, l) => [
+      new W({
+        key: It,
+        view: (s) => {
+          const r = o.themeManager.get("input-chip", {
+            width: "12em",
+            placeholder: "Input Footnote Label",
+            onUpdate: (d) => {
+              l.get(Ze).call(Le, d);
+            },
+            isBindMode: !0
+          });
+          if (!r)
+            return {};
+          const a = (d) => Boolean(n && B(d.state.selection, n)), i = (d) => {
+            const u = B(d.state.selection, n);
+            return u ? u.node.attrs.label : void 0;
+          }, c = (d) => {
+            if (!d.editable)
+              return;
+            a(d) ? (r.show(d), r.update(i(d))) : r.hide();
+          };
+          return r.init(s), c(s), {
+            update: (d, u) => {
+              (u == null ? void 0 : u.doc.eq(d.state.doc)) && u.selection.eq(d.state.selection) || c(d);
+            },
+            destroy: () => {
+              r.destroy();
+            }
+          };
+        }
+      })
+    ]
   };
-});
-const ModifyFootnoteRef = createCmdKey("ModifyFootnoteRef");
-const key$1 = new PluginKey("MILKDOWN_FOOTNOTE_REF_INPUT");
-const footnoteReference = createNode((utils) => {
-  const id2 = "footnote_reference";
+}), ve = R("ModifyFootnoteRef"), Dt = new F("MILKDOWN_FOOTNOTE_REF_INPUT"), Ot = be((o) => {
+  const e = "footnote_reference";
   return {
-    id: id2,
-    schema: (ctx) => ({
+    id: e,
+    schema: (t) => ({
       group: "inline",
-      inline: true,
-      atom: true,
+      inline: !0,
+      atom: !0,
       attrs: {
         label: {
           default: ""
@@ -217,521 +155,396 @@ const footnoteReference = createNode((utils) => {
       },
       parseDOM: [
         {
-          tag: `sup[data-type="${id2}"]`,
-          getAttrs: (dom) => {
-            if (!(dom instanceof HTMLElement)) {
-              throw new Error();
-            }
+          tag: `sup[data-type="${e}"]`,
+          getAttrs: (n) => {
+            if (!(n instanceof HTMLElement))
+              throw ye(n);
             return {
-              label: dom.dataset["label"]
+              label: n.dataset.label
             };
           }
         }
       ],
-      toDOM: (node) => {
-        const label = node.attrs["label"];
-        const a = document.createElement("a");
-        const href = `#${getFootnoteDefId(label)}`;
-        a.href = href;
-        a.textContent = `[${label}]`;
-        a.onclick = (e) => {
-          const view = ctx.get(editorViewCtx);
-          if (view.editable) {
-            e.preventDefault();
-          }
-        };
-        a.ondblclick = () => {
-          const view = ctx.get(editorViewCtx);
-          if (view.editable) {
-            window.location.href = href;
-          }
-        };
-        return [
+      toDOM: (n) => {
+        const l = n.attrs.label, s = document.createElement("a"), r = `#${Ye(l)}`;
+        return s.href = r, s.textContent = `[${l}]`, s.onclick = (a) => {
+          t.get(ee).editable && a.preventDefault();
+        }, s.ondblclick = () => {
+          t.get(ee).editable && (window.location.href = r);
+        }, [
           "sup",
           {
-            "data-label": label,
-            "data-type": id2,
-            id: getFootnoteRefId(label)
+            "data-label": l,
+            "data-type": e,
+            id: Je(l)
           },
-          a
+          s
         ];
       },
       parseMarkdown: {
-        match: ({ type }) => type === "footnoteReference",
-        runner: (state, node, type) => {
-          state.addNode(type, {
-            label: node["label"]
+        match: ({ type: n }) => n === "footnoteReference",
+        runner: (n, l, s) => {
+          n.addNode(s, {
+            label: l.label
           });
         }
       },
       toMarkdown: {
-        match: (node) => node.type.name === id2,
-        runner: (state, node) => {
-          state.addNode("footnoteReference", void 0, void 0, {
-            label: node.attrs["label"],
-            identifier: node.attrs["label"]
+        match: (n) => n.type.name === e,
+        runner: (n, l) => {
+          n.addNode("footnoteReference", void 0, void 0, {
+            label: l.attrs.label,
+            identifier: l.attrs.label
           });
         }
       }
     }),
-    commands: (nodeType) => [
-      createCmd(ModifyFootnoteRef, (label = "") => (state, dispatch) => {
-        const node = findSelectedNodeOfType(state.selection, nodeType);
-        if (!node)
-          return false;
-        const { tr } = state;
-        const _tr = tr.setNodeMarkup(node.pos, void 0, __spreadProps(__spreadValues({}, node.node.attrs), { label }));
-        dispatch == null ? void 0 : dispatch(_tr.setSelection(NodeSelection.create(_tr.doc, node.pos)));
-        return true;
+    commands: (t) => [
+      N(ve, (n = "") => (l, s) => {
+        const r = B(l.selection, t);
+        if (!r)
+          return !1;
+        const { tr: a } = l, i = a.setNodeMarkup(r.pos, void 0, { ...r.node.attrs, label: n });
+        return s == null || s(i.setSelection(te.create(i.doc, r.pos))), !0;
       })
     ],
-    inputRules: (nodeType) => [
-      new InputRule(/(?:\[\^)([^\]]+)(?:\])$/, (state, match, start, end) => {
-        const $start = state.doc.resolve(start);
-        const index = $start.index();
-        const $end = state.doc.resolve(end);
-        if (!$start.parent.canReplaceWith(index, $end.index(), nodeType)) {
+    inputRules: (t) => [
+      new Ce(/(?:\[\^)([^\]]+)(?:\])$/, (n, l, s, r) => {
+        const a = n.doc.resolve(s), i = a.index(), c = n.doc.resolve(r);
+        if (!a.parent.canReplaceWith(i, c.index(), t))
           return null;
-        }
-        const label = match[1];
-        return state.tr.replaceRangeWith(start, end, nodeType.create({
-          label
+        const d = l[1];
+        return n.tr.replaceRangeWith(s, r, t.create({
+          label: d
         }));
       })
     ],
-    prosePlugins: (type, ctx) => {
-      const inputChipRenderer = utils.themeManager.get("input-chip", {
+    prosePlugins: (t, n) => {
+      const l = o.themeManager.get("input-chip", {
         width: "12em",
         placeholder: "Input Footnote Label",
-        onUpdate: (value) => {
-          ctx.get(commandsCtx).call(ModifyFootnoteRef, value);
+        onUpdate: (i) => {
+          n.get(Ze).call(ve, i);
         },
-        isBindMode: true
+        isBindMode: !0
       });
-      if (!inputChipRenderer)
+      if (!l)
         return [];
-      const shouldDisplay = (view) => Boolean(type && findSelectedNodeOfType(view.state.selection, type));
-      const getCurrentLabel = (view) => {
-        const result = findSelectedNodeOfType(view.state.selection, type);
-        if (!result)
-          return;
-        const value = result.node.attrs["label"];
-        return value;
-      };
-      const renderByView = (view) => {
-        if (!view.editable) {
+      const s = (i) => Boolean(t && B(i.state.selection, t)), r = (i) => {
+        const c = B(i.state.selection, t);
+        return c ? c.node.attrs.label : void 0;
+      }, a = (i) => {
+        if (!i.editable)
           return;
-        }
-        const display = shouldDisplay(view);
-        if (display) {
-          inputChipRenderer.show(view);
-          inputChipRenderer.update(getCurrentLabel(view));
-        } else {
-          inputChipRenderer.hide();
-        }
+        s(i) ? (l.show(i), l.update(r(i))) : l.hide();
       };
       return [
-        new Plugin({
-          key: key$1,
-          view: (editorView) => {
-            inputChipRenderer.init(editorView);
-            renderByView(editorView);
-            return {
-              update: (view, prevState) => {
-                const isEqualSelection = (prevState == null ? void 0 : prevState.doc.eq(view.state.doc)) && prevState.selection.eq(view.state.selection);
-                if (isEqualSelection)
-                  return;
-                renderByView(view);
-              },
-              destroy: () => {
-                inputChipRenderer.destroy();
-              }
-            };
-          }
+        new W({
+          key: Dt,
+          view: (i) => (l.init(i), a(i), {
+            update: (c, d) => {
+              (d == null ? void 0 : d.doc.eq(c.state.doc)) && d.selection.eq(c.state.selection) || a(c);
+            },
+            destroy: () => {
+              l.destroy();
+            }
+          })
         })
       ];
     }
   };
-});
-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)];
-    }
+}), Qe = /* @__PURE__ */ new WeakMap(), _t = (o) => Qe.get(o), zt = (o, e) => (Qe.set(o, e), e);
+class Ee {
+  constructor(e, t, n, l) {
+    this.left = e, this.top = t, this.right = n, this.bottom = l;
   }
-  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);
+}
+class g {
+  constructor(e, t, n, l) {
+    this.width = e, this.height = t, this.map = n, this.problems = l, this.width = e, this.height = t, this.map = n, this.problems = l;
+  }
+  findCell(e) {
+    for (let t = 0; t < this.map.length; t++) {
+      const n = this.map[t];
+      if (n != e)
+        continue;
+      const l = t % this.width, s = t / this.width | 0;
+      let r = l + 1, a = s + 1;
+      for (let i = 1; r < this.width && this.map[t + i] == n; i++)
+        r++;
+      for (let i = 1; a < this.height && this.map[t + this.width * i] == n; i++)
+        a++;
+      return new Ee(l, s, r, a);
+    }
+    throw new RangeError("No cell with offset " + e + " found");
+  }
+  colCount(e) {
+    for (let t = 0; t < this.map.length; t++)
+      if (this.map[t] == e)
+        return t % this.width;
+    throw new RangeError("No cell with offset " + e + " found");
+  }
+  nextCell(e, t, n) {
+    const { left: l, right: s, top: r, bottom: a } = this.findCell(e);
+    return t == "horiz" ? (n < 0 ? l == 0 : s == this.width) ? void 0 : this.map[r * this.width + (n < 0 ? l - 1 : s)] : (n < 0 ? r == 0 : a == this.height) ? void 0 : this.map[l + this.width * (n < 0 ? r - 1 : a)];
+  }
+  rectBetween(e, t) {
+    const { left: n, right: l, top: s, bottom: r } = this.findCell(e), { left: a, right: i, top: c, bottom: d } = this.findCell(t);
+    return new Ee(Math.min(n, a), Math.min(s, c), Math.max(l, i), Math.max(r, d));
+  }
+  cellsInRect(e) {
+    const t = [], n = {};
+    for (let l = e.top; l < e.bottom; l++)
+      for (let s = e.left; s < e.right; s++) {
+        const r = l * this.width + s, a = this.map[r];
+        n[a] || (n[a] = !0, (s != e.left || !s || this.map[r - 1] != a) && (l != e.top || !l || this.map[r - this.width] != a) && t.push(a));
       }
-    }
-    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];
+    return t;
+  }
+  positionAt(e, t, n) {
+    for (let l = 0, s = 0; ; l++) {
+      const r = s + n.child(l).nodeSize;
+      if (l == e) {
+        let a = t + e * this.width;
+        const i = (e + 1) * this.width;
+        for (; a < i && this.map[a] < s; )
+          a++;
+        return a == i ? r - 1 : this.map[a];
       }
-      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)
+      s = r;
+    }
+  }
+  static get(e) {
+    return _t(e) || zt(e, Ft(e));
+  }
+}
+function Ft(o) {
+  if (o.type.spec.tableRole != "table")
+    throw new RangeError("Not a table node: " + o.type.name);
+  const e = Bt(o), t = o.childCount, n = [], l = [];
+  let s = 0, r;
+  for (let c = 0, d = e * t; c < d; c++)
+    n[c] = 0;
+  for (let c = 0, d = 0; c < t; c++) {
+    const u = o.child(c);
+    d++;
+    for (let h = 0; ; h++) {
+      for (; s < n.length && n[s] != 0; )
+        s++;
+      if (h == u.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({
+      const b = u.child(h), { colspan: w, rowspan: C, colwidth: Ne } = b.attrs;
+      for (let H = 0; H < C; H++) {
+        if (H + c >= t) {
+          (r || (r = [])).push({
             type: "overlong_rowspan",
-            pos,
-            n: rowspan - h
+            pos: d,
+            n: C - 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]++;
-            }
+        const le = s + H * e;
+        for (let _ = 0; _ < w; _++) {
+          n[le + _] == 0 ? n[le + _] = d : (r || (r = [])).push({
+            type: "collision",
+            row: c,
+            pos: d,
+            n: w - _
+          });
+          const X = Ne && Ne[_];
+          if (X) {
+            const j = (le + _) % e * 2, se = l[j];
+            se == null || se != X && l[j + 1] == 1 ? (l[j] = X, l[j + 1] = 1) : se == X && l[j + 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"];
+      s += w, d += b.nodeSize;
+    }
+    const f = (c + 1) * e;
+    let p = 0;
+    for (; s < f; )
+      n[s++] == 0 && p++;
+    p && (r || (r = [])).push({ type: "missing", row: c, n: p }), d++;
+  }
+  const a = new g(e, t, n, r);
+  let i = !1;
+  for (let c = 0; !i && c < l.length; c += 2)
+    l[c] != null && l[c + 1] < t && (i = !0);
+  return i && Pt(a, l, o), a;
+}
+function Bt(o) {
+  let e = -1, t = !1;
+  for (let n = 0; n < o.childCount; n++) {
+    const l = o.child(n);
+    let s = 0;
+    if (t)
+      for (let r = 0; r < n; r++) {
+        const a = o.child(r);
+        for (let i = 0; i < a.childCount; i++) {
+          const c = a.child(i);
+          r + c.attrs.rowspan > n && (s += c.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;
+    for (let r = 0; r < l.childCount; r++) {
+      const a = l.child(r);
+      s += a.attrs.colspan, a.attrs.rowspan > 1 && (t = !0);
     }
-    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])
+    e == -1 ? e = s : e != s && (e = Math.max(e, s));
+  }
+  return e;
+}
+function Pt(o, e, t) {
+  o.problems || (o.problems = []);
+  for (let n = 0, l = {}; n < o.map.length; n++) {
+    const s = o.map[n];
+    if (l[s])
       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
-      });
+    l[s] = !0;
+    const r = t.nodeAt(s);
+    let a = null;
+    for (let i = 0; i < r.attrs.colspan; i++) {
+      const c = (n + i) % o.width, d = e[c * 2];
+      d != null && (!r.attrs.colwidth || r.attrs.colwidth[i] != d) && ((a || (a = Wt(r.attrs)))[i] = d);
+    }
+    a && o.problems.unshift({
+      type: "colwidth mismatch",
+      pos: s,
+      colwidth: a
+    });
   }
 }
-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));
+function Wt(o) {
+  if (o.colwidth)
+    return o.colwidth.slice();
+  const e = [];
+  for (let t = 0; t < o.colspan; t++)
+    e.push(0);
+  return e;
+}
+class m extends S {
+  constructor(e, t = e) {
+    const n = e.node(-1), l = g.get(n), s = e.start(-1), r = l.rectBetween(e.pos - s, t.pos - s), a = e.node(0), i = l.cellsInRect(r).filter((d) => d != t.pos - s);
+    i.unshift(t.pos - s);
+    const c = i.map((d) => {
+      const u = n.nodeAt(d), f = d + s + 1;
+      return new kt(a.resolve(f), a.resolve(f + u.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);
+    super(c[0].$from, c[0].$to, c), this.$anchorCell = e, this.$headCell = t, this.$anchorCell = e, this.$headCell = t;
+  }
+  map(e, t) {
+    const n = e.resolve(t.map(this.$anchorCell.pos)), l = e.resolve(t.map(this.$headCell.pos));
+    if (de(n) && de(l) && Se(n, l)) {
+      const s = this.$anchorCell.node(-1) != n.node(-1);
+      return s && this.isRowSelection() ? m.rowSelection(n, l) : s && this.isColSelection() ? m.colSelection(n, l) : new m(n, l);
     }
-    return TextSelection.between($anchorCell, $headCell);
+    return D.between(n, l);
   }
   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);
+    const e = this.$anchorCell.node(-1), t = g.get(e), n = this.$anchorCell.start(-1), l = t.rectBetween(this.$anchorCell.pos - n, this.$headCell.pos - n), s = {}, r = [];
+    for (let i = l.top; i < l.bottom; i++) {
+      const c = [];
+      for (let d = i * t.width + l.left, u = l.left; u < l.right; u++, d++) {
+        const f = t.map[d];
+        if (!s[f]) {
+          s[f] = !0;
+          const p = t.findCell(f);
+          let h = e.nodeAt(f);
+          const b = l.left - p.left, w = p.right - l.right;
+          if (b > 0 || w > 0) {
+            let C = h.attrs;
+            b > 0 && (C = z(C, 0, b)), w > 0 && (C = z(C, C.colspan - w, w)), p.left < l.left ? h = h.type.createAndFill(C) : h = h.type.create(C, h.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);
+          if (p.top < l.top || p.bottom > l.bottom) {
+            const C = y(h.attrs, "rowspan", Math.min(p.bottom, l.bottom) - Math.max(p.top, l.top));
+            p.top < l.top ? h = h.type.createAndFill(C) : h = h.type.create(C, h.content);
           }
-          rowContent.push(cell);
+          c.push(h);
         }
       }
-      rows.push(table2.child(row).copy(Fragment.from(rowContent)));
+      r.push(e.child(i).copy(E.from(c)));
     }
-    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 a = this.isColSelection() && this.isRowSelection() ? e : r;
+    return new O(E.from(a), 1, 1);
+  }
+  replace(e, t = O.empty) {
+    const n = e.steps.length, l = this.ranges;
+    for (let r = 0; r < l.length; r++) {
+      const { $from: a, $to: i } = l[r], c = e.mapping.slice(n);
+      e.replace(c.map(a.pos), c.map(i.pos), r ? O.empty : t);
     }
-    const sel = Selection.findFrom(tr.doc.resolve(tr.mapping.slice(mapFrom).map(this.to)), -1);
-    if (sel)
-      tr.setSelection(sel);
+    const s = S.findFrom(e.doc.resolve(e.mapping.slice(n).map(this.to)), -1);
+    s && e.setSelection(s);
   }
-  replaceWith(tr, node) {
-    this.replace(tr, new Slice(Fragment.from(node), 0, 0));
+  replaceWith(e, t) {
+    this.replace(e, new O(E.from(t), 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]);
+  forEachCell(e) {
+    const t = this.$anchorCell.node(-1), n = g.get(t), l = this.$anchorCell.start(-1), s = n.cellsInRect(n.rectBetween(this.$anchorCell.pos - l, this.$headCell.pos - l));
+    for (let r = 0; r < s.length; r++)
+      e(t.nodeAt(s[r]), l + s[r]);
   }
   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);
+    const e = this.$anchorCell.index(-1), t = this.$headCell.index(-1);
+    if (Math.min(e, t) > 0)
+      return !1;
+    const n = e + this.$anchorCell.nodeAfter.attrs.rowspan, l = t + this.$headCell.nodeAfter.attrs.rowspan;
+    return Math.max(n, l) == this.$headCell.node(-1).childCount;
+  }
+  static colSelection(e, t = e) {
+    const n = g.get(e.node(-1)), l = e.start(-1), s = n.findCell(e.pos - l), r = n.findCell(t.pos - l), a = e.node(0);
+    if (s.top <= r.top) {
+      if (s.top > 0) {
+        const i = n.map[s.left];
+        e = a.resolve(l + i);
       }
-      if (headRect.bottom < map.height) {
-        const pos = map.map[map.width * (map.height - 1) + headRect.right - 1];
-        $headCell = doc2.resolve(start + pos);
+      if (r.bottom < n.height) {
+        const i = n.map[n.width * (n.height - 1) + r.right - 1];
+        t = a.resolve(l + i);
       }
     } else {
-      if (headRect.top > 0) {
-        const left = map.map[anchorRect.left];
-        $headCell = doc2.resolve(start + left);
+      if (r.top > 0) {
+        const i = n.map[s.left];
+        t = a.resolve(l + i);
       }
-      if (anchorRect.bottom < map.height) {
-        const pos = map.map[map.width * (map.height - 1) + anchorRect.right - 1];
-        $anchorCell = doc2.resolve(start + pos);
+      if (s.bottom < n.height) {
+        const i = n.map[n.width * (n.height - 1) + s.right - 1];
+        e = a.resolve(l + i);
       }
     }
-    return new CellSelection($anchorCell, $headCell);
+    return new m(e, t);
   }
   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);
+    const e = g.get(this.$anchorCell.node(-1)), t = this.$anchorCell.start(-1), n = e.colCount(this.$anchorCell.pos - t), l = e.colCount(this.$headCell.pos - t);
+    if (Math.min(n, l) > 0)
+      return !1;
+    const s = n + this.$anchorCell.nodeAfter.attrs.colspan, r = l + this.$headCell.nodeAfter.attrs.colspan;
+    return Math.max(s, r) == e.width;
+  }
+  eq(e) {
+    return e instanceof m && e.$anchorCell.pos == this.$anchorCell.pos && e.$headCell.pos == this.$headCell.pos;
+  }
+  static rowSelection(e, t = e) {
+    const n = g.get(e.node(-1)), l = e.start(-1), s = n.findCell(e.pos - l), r = n.findCell(t.pos - l), a = e.node(0);
+    if (s.left <= r.left) {
+      if (s.left > 0) {
+        const i = n.map[s.top * n.width];
+        e = a.resolve(l + i);
       }
-      if (headRect.right < map.width) {
-        const pos = map.map[map.width * (headRect.top + 1) - 1];
-        $headCell = doc2.resolve(start + pos);
+      if (r.right < n.width) {
+        const i = n.map[n.width * (r.top + 1) - 1];
+        t = a.resolve(l + i);
       }
     } else {
-      if (headRect.left > 0) {
-        const pos = map.map[headRect.top * map.width];
-        $headCell = doc2.resolve(start + pos);
+      if (r.left > 0) {
+        const i = n.map[r.top * n.width];
+        t = a.resolve(l + i);
       }
-      if (anchorRect.right < map.width) {
-        const pos = map.map[map.width * (anchorRect.top + 1) - 1];
-        $anchorCell = doc2.resolve(start + pos);
+      if (s.right < n.width) {
+        const i = n.map[n.width * (s.top + 1) - 1];
+        e = a.resolve(l + i);
       }
     }
-    return new CellSelection($anchorCell, $headCell);
+    return new m(e, t);
   }
   toJSON() {
     return {
@@ -740,148 +553,119 @@ class CellSelection extends Selection {
       head: this.$headCell.pos
     };
   }
-  static fromJSON(doc2, json) {
-    return new CellSelection(doc2.resolve(json.anchor), doc2.resolve(json.head));
+  static fromJSON(e, t) {
+    return new m(e.resolve(t.anchor), e.resolve(t.head));
   }
-  static create(doc2, anchorCell, headCell = anchorCell) {
-    return new CellSelection(doc2.resolve(anchorCell), doc2.resolve(headCell));
+  static create(e, t, n = t) {
+    return new m(e.resolve(t), e.resolve(n));
   }
   getBookmark() {
-    return new CellBookmark(this.$anchorCell.pos, this.$headCell.pos);
+    return new Me(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;
+m.prototype.visible = !1;
+S.jsonID("cell", m);
+class Me {
+  constructor(e, t) {
+    this.anchor = e, this.head = t, this.anchor = e, this.head = t;
   }
-  map(mapping) {
-    return new CellBookmark(mapping.map(this.anchor), mapping.map(this.head));
+  map(e) {
+    return new Me(e.map(this.anchor), e.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);
+  resolve(e) {
+    const t = e.resolve(this.anchor), n = e.resolve(this.head);
+    return t.parent.type.spec.tableRole == "row" && n.parent.type.spec.tableRole == "row" && t.index() < t.parent.childCount && n.index() < n.parent.childCount && Se(t, n) ? new m(t, n) : S.near(n, 1);
   }
 }
-function drawCellSelection(state) {
-  if (!(state.selection instanceof CellSelection))
+function Ht(o) {
+  if (!(o.selection instanceof m))
     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;
+  const e = [];
+  return o.selection.forEachCell((t, n) => {
+    e.push(ke.node(n, n + t.nodeSize, { class: "selectedCell" }));
+  }), Ae.create(o.doc, e);
+}
+function jt({ $from: o, $to: e }) {
+  if (o.pos == e.pos || o.pos < o.pos - 6)
+    return !1;
+  let t = o.pos, n = e.pos, l = o.depth;
+  for (; l >= 0 && !(o.after(l + 1) < o.end(l)); l--, t++)
+    ;
+  for (let s = e.depth; s >= 0 && !(e.before(s + 1) > e.start(s)); s--, n--)
+    ;
+  return t == n && /row|table/.test(o.node(l).type.spec.tableRole);
+}
+function Kt({ $from: o, $to: e }) {
+  let t, n;
+  for (let l = o.depth; l > 0; l--) {
+    const s = o.node(l);
+    if (s.type.spec.tableRole === "cell" || s.type.spec.tableRole === "header_cell") {
+      t = s;
       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;
+  for (let l = e.depth; l > 0; l--) {
+    const s = e.node(l);
+    if (s.type.spec.tableRole === "cell" || s.type.spec.tableRole === "header_cell") {
+      n = s;
       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
+  return t !== n && e.parentOffset === 0;
+}
+function qt(o, e, t) {
+  const n = (e || o).selection, l = (e || o).doc;
+  let s, r;
+  if (n instanceof te && (r = n.node.type.spec.tableRole)) {
+    if (r == "cell" || r == "header_cell")
+      s = m.create(l, n.from);
+    else if (r == "row") {
+      const a = l.resolve(n.from + 1);
+      s = m.rowSelection(a, a);
+    } else if (!t) {
+      const a = g.get(n.node), i = n.from + 1, c = a.map[a.width * a.height - 1], d = i + c;
+      s = m.create(l, i + 1, d);
+    }
+  } else
+    n instanceof D && jt(n) ? s = D.create(l, n.from) : n instanceof D && Kt(n) && (s = D.create(l, n.$from.start(), n.$from.end()));
+  return s && (e || (e = o.tr)).setSelection(s), e;
+}
+function Ie(o, e) {
+  const t = o.getAttribute("data-colwidth"), n = t && /^\d+(,\d+)*$/.test(t) ? t.split(",").map((r) => Number(r)) : null, l = Number(o.getAttribute("colspan") || 1), s = {
+    colspan: l,
+    rowspan: Number(o.getAttribute("rowspan") || 1),
+    colwidth: n && n.length == l ? n : 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 = {
+  for (const r in e) {
+    const a = e[r].getFromDOM, i = a && a(o);
+    i != null && (s[r] = i);
+  }
+  return s;
+}
+function $e(o, e) {
+  const t = {};
+  o.attrs.colspan != 1 && (t.colspan = o.attrs.colspan), o.attrs.rowspan != 1 && (t.rowspan = o.attrs.rowspan), o.attrs.colwidth && (t["data-colwidth"] = o.attrs.colwidth.join(","));
+  for (const n in e) {
+    const l = e[n].setDOMAttr;
+    l && l(o.attrs[n], t);
+  }
+  return t;
+}
+function Ut(o) {
+  const e = o.cellAttributes || {}, t = {
     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 = {
+  for (const s in e)
+    t[s] = { default: e[s].default };
+  const n = t;
+  return {
     table: {
       content: "table_row+",
       tableRole: "table",
-      isolating: true,
-      group: options.tableGroup,
+      isolating: !0,
+      group: o.tableGroup,
       parseDOM: [{ tag: "table" }],
       toDOM() {
         return ["table", ["tbody", 0]];
@@ -896,401 +680,471 @@ function tableNodesSpecCreator(options) {
       }
     },
     table_cell: {
-      content: options.cellContent,
-      attrs: finalAttrs,
+      content: o.cellContent,
+      attrs: n,
       tableRole: "cell",
-      isolating: true,
-      parseDOM: [{ tag: "td", getAttrs: (dom) => getCellAttrs(dom, extraAttrs) }],
-      toDOM(node) {
-        return ["td", setCellAttrs(node, extraAttrs), 0];
+      isolating: !0,
+      parseDOM: [{ tag: "td", getAttrs: (s) => Ie(s, e) }],
+      toDOM(s) {
+        return ["td", $e(s, e), 0];
       }
     },
     table_header: {
-      content: options.cellContent,
-      attrs: finalAttrs,
+      content: o.cellContent,
+      attrs: n,
       tableRole: "header_cell",
-      isolating: true,
-      parseDOM: [{ tag: "th", getAttrs: (dom) => getCellAttrs(dom, extraAttrs) }],
-      toDOM(node) {
-        return ["th", setCellAttrs(node, extraAttrs), 0];
+      isolating: !0,
+      parseDOM: [{ tag: "th", getAttrs: (s) => Ie(s, e) }],
+      toDOM(s) {
+        return ["th", $e(s, e), 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;
+}
+function A(o) {
+  let e = o.cached.tableNodeTypes;
+  if (!e) {
+    e = o.cached.tableNodeTypes = {};
+    for (const t in o.nodes) {
+      const n = o.nodes[t], l = n == null ? void 0 : n.spec.tableRole;
+      l && (e[l] = n);
     }
   }
-  return result;
+  return e;
 }
-const schema = tableNodesSpecCreator({
+const V = Ut({
   tableGroup: "block",
   cellContent: "paragraph",
   cellAttributes: {
     alignment: {
       default: "left",
-      getFromDOM: (dom) => dom.style.textAlign || "left",
-      setDOMAttr: (value, attrs) => {
-        attrs["style"] = `text-align: ${value || "left"}`;
+      getFromDOM: (o) => o.style.textAlign || "left",
+      setDOMAttr: (o, e) => {
+        e.style = `text-align: ${o || "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;
-  }
-  const { $head } = state.selection;
-  const pos = $head.after();
-  const tr = state.tr.replaceWith(pos, pos, node.createAndFill());
-  tr.setSelection(Selection.near(tr.doc.resolve(pos), 1));
-  dispatch == null ? void 0 : dispatch(tr.scrollIntoView());
-  return true;
+function U(o) {
+  for (let e = o.depth - 1; e > 0; e--)
+    if (o.node(e).type.spec.tableRole == "row")
+      return o.node(0).resolve(o.before(e + 1));
+}
+function de(o) {
+  return o.parent.type.spec.tableRole == "row" ? o.nodeAfter : null;
+}
+function Xt(o) {
+  return o.node(0).resolve(o.pos + o.nodeAfter.nodeSize);
+}
+function Se(o, e) {
+  return o.depth == e.depth && o.pos >= e.start(-1) && o.pos <= e.end(-1);
+}
+function et(o, e, t) {
+  const n = o.start(-1), s = g.get(o.node(-1)).nextCell(o.pos - n, e, t);
+  return s == null ? null : o.node(0).resolve(n + s);
+}
+function y(o, e, t) {
+  const n = {};
+  for (const l in o)
+    n[l] = o[l];
+  return n[e] = t, n;
+}
+function z(o, e, t = 1) {
+  const n = y(o, "colspan", o.colspan - t);
+  if (n.colwidth) {
+    const l = n.colwidth;
+    n.colwidth = l.slice(), l.splice(e, t), l.some((s) => s > 0) || (n.colwidth = null);
+  }
+  return n;
+}
+function M(o) {
+  const e = o.selection.$head;
+  for (let t = e.depth; t > 0; t--)
+    if (e.node(t).type.spec.tableRole == "row")
+      return !0;
+  return !1;
+}
+function ne(o) {
+  const e = o.selection;
+  return e instanceof m ? e.$anchorCell.pos > e.$headCell.pos ? e.$anchorCell : e.$headCell : e.node && e.node.type.spec.tableRole == "cell" ? e.$anchor : U(e.$head) || Vt(e.$head);
+}
+function Vt(o) {
+  for (let e = o.nodeAfter, t = o.pos; e; e = e.firstChild, t++) {
+    const n = e.type.spec.tableRole;
+    if (n == "cell" || n == "header_cell")
+      return o.doc.resolve(t);
+  }
+  for (let e = o.nodeBefore, t = o.pos; e; e = e.lastChild, t--) {
+    const n = e.type.spec.tableRole;
+    if (n == "cell" || n == "header_cell")
+      return o.doc.resolve(t - e.nodeSize);
+  }
+}
+function Zt(o, e, t = 1) {
+  const n = y(o, "colspan", o.colspan + t);
+  if (n.colwidth) {
+    const l = n.colwidth;
+    n.colwidth = l.slice();
+    for (let s = 0; s < t; s++)
+      l.splice(e, 0, 0);
+  }
+  return n;
+}
+function Gt(o, e, t) {
+  const n = A(e.type.schema).header_cell;
+  for (let l = 0; l < o.height; l++) {
+    const s = o.map[t + l * o.width];
+    if (e.nodeAt(s).type != n)
+      return !1;
+  }
+  return !0;
+}
+const Jt = (o) => (e, t) => {
+  if (!M(e))
+    return !1;
+  const { $head: n } = e.selection, l = n.after(), s = e.tr.replaceWith(l, l, o.createAndFill());
+  return s.setSelection(S.near(s.doc.resolve(l), 1)), t == null || t(s.scrollIntoView()), !0;
 };
-const findTable = (selection) => findParentNode((node) => node.type.spec["tableRole"] === "table")(selection);
-const getCellsInColumn = (columnIndex) => (selection) => {
-  const table2 = findTable(selection);
-  if (!table2)
-    return void 0;
-  const map = TableMap.get(table2.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 = table2.node.nodeAt(pos);
-    if (!node)
-      throw new Error();
-    const start = pos + table2.start;
-    return {
-      pos: start,
-      start: start + 1,
-      node
-    };
-  });
+function P(o) {
+  const e = o.selection, t = ne(o), n = t.node(-1), l = t.start(-1), s = g.get(n);
+  let r;
+  return e instanceof m ? r = s.rectBetween(e.$anchorCell.pos - l, e.$headCell.pos - l) : r = s.findCell(t.pos - l), r.tableStart = l, r.map = s, r.table = n, r;
+}
+function tt(o, { map: e, tableStart: t, table: n }, l) {
+  e = e, n = n, t = t;
+  let s = l > 0 ? -1 : 0;
+  Gt(e, n, l + s) && (s = l == 0 || l == e.width ? null : 0);
+  for (let r = 0; r < e.height; r++) {
+    const a = r * e.width + l;
+    if (l > 0 && l < e.width && e.map[a - 1] == e.map[a]) {
+      const i = e.map[a], c = n.nodeAt(i);
+      o.setNodeMarkup(o.mapping.map(t + i), null, Zt(c.attrs, l - e.colCount(i))), r += c.attrs.rowspan - 1;
+    } else {
+      const i = e.map[a + s], c = s == null ? A(n.type.schema).cell : n.nodeAt(i).type, d = e.positionAt(r, l, n);
+      o.insert(o.mapping.map(t + d), c.createAndFill());
+    }
+  }
+  return o;
+}
+const Yt = (o, e) => {
+  if (!M(o))
+    return !1;
+  if (e) {
+    const t = P(o);
+    e(tt(o.tr, t, t.left));
+  }
+  return !0;
+}, Qt = (o, e) => {
+  if (!M(o))
+    return !1;
+  if (e) {
+    const t = P(o);
+    e(tt(o.tr, t, t.right));
+  }
+  return !0;
 };
-const getCellsInRow = (rowIndex) => (selection) => {
-  const table2 = findTable(selection);
-  if (!table2)
-    return void 0;
-  const map = TableMap.get(table2.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 = table2.node.nodeAt(pos);
-    if (!node)
-      throw new Error();
-    const start = pos + table2.start;
-    return {
-      pos: start,
-      start: start + 1,
-      node
-    };
-  });
+function en(o, { map: e, table: t, tableStart: n }, l) {
+  e = e, t = t, n = n;
+  const s = o.mapping.maps.length;
+  for (let r = 0; r < e.height; ) {
+    const a = r * e.width + l, i = e.map[a], c = t.nodeAt(i);
+    if (l > 0 && e.map[a - 1] == i || l < e.width - 1 && e.map[a + 1] == i)
+      o.setNodeMarkup(o.mapping.slice(s).map(n + i), null, z(c.attrs, l - e.colCount(i)));
+    else {
+      const d = o.mapping.slice(s).map(n + i);
+      o.delete(d, d + c.nodeSize);
+    }
+    r += c.attrs.rowspan;
+  }
+}
+const tn = (o, e) => {
+  if (!M(o))
+    return !1;
+  if (e) {
+    const t = P(o), n = o.tr;
+    if (t.left == 0 && t.right == t.map.width)
+      return !1;
+    for (let l = t.right - 1; en(n, t, l), l != t.left; l--)
+      t.table = t.tableStart ? n.doc.nodeAt(t.tableStart - 1) : n.doc, t.map = g.get(t.table);
+    e(n);
+  }
+  return !0;
 };
-const createTable = (schema2, rowsCount = 3, colsCount = 3) => {
-  const { cell: tableCell, header_cell: tableHeader, row: tableRow, table: table2 } = tableNodeTypes(schema2);
-  const cells = Array(colsCount).fill(0).map(() => tableCell.createAndFill(null));
-  const headerCells = Array(colsCount).fill(0).map(() => tableHeader.createAndFill(null));
-  const rows = Array(rowsCount).fill(0).map((_, i) => tableRow.create(null, i === 0 ? headerCells : cells));
-  return table2.create(null, rows);
+function nn(o, { map: e, tableStart: t, table: n }, l) {
+  e = e, n = n, t = t;
+  let s = 0;
+  for (let i = 0; i < l; i++)
+    s += n.child(i).nodeSize;
+  const r = s + n.child(l).nodeSize, a = o.mapping.maps.length;
+  o.delete(s + t, r + t);
+  for (let i = 0, c = l * e.width; i < e.width; i++, c++) {
+    const d = e.map[c];
+    if (l > 0 && d == e.map[c - e.width]) {
+      const u = n.nodeAt(d).attrs;
+      o.setNodeMarkup(o.mapping.slice(a).map(d + t), null, y(u, "rowspan", u.rowspan - 1)), i += u.colspan - 1;
+    } else if (l < e.width && d == e.map[c + e.width]) {
+      const u = n.nodeAt(d), f = u.type.create(y(u.attrs, "rowspan", u.attrs.rowspan - 1), u.content), p = e.positionAt(l + 1, i, n);
+      o.insert(o.mapping.slice(a).map(t + p), f), i += u.attrs.colspan - 1;
+    }
+  }
+}
+const on = (o, e) => {
+  if (!M(o))
+    return !1;
+  if (e) {
+    const t = P(o), n = o.tr;
+    if (t.top == 0 && t.bottom == t.map.height)
+      return !1;
+    for (let l = t.bottom - 1; nn(n, t, l), l != t.top; l--)
+      t.table = t.tableStart ? n.doc.nodeAt(t.tableStart - 1) : n.doc, t.map = g.get(t.table);
+    e(n);
+  }
+  return !0;
 };
-const selectLine = (type) => (index) => (tr) => {
-  const table2 = findTable(tr.selection);
-  const isRowSelection = type === "row";
-  if (table2) {
-    const map = TableMap.get(table2.node);
-    if (index >= 0 && index < (isRowSelection ? map.height : map.width)) {
-      const lastCell = map.positionAt(isRowSelection ? index : map.height - 1, isRowSelection ? map.width - 1 : index, table2.node);
-      const $lastCell = tr.doc.resolve(table2.start + lastCell);
-      const createCellSelection = isRowSelection ? CellSelection.rowSelection : CellSelection.colSelection;
-      const firstCell = map.positionAt(isRowSelection ? index : 0, isRowSelection ? 0 : index, table2.node);
-      const $firstCell = tr.doc.resolve(table2.start + firstCell);
-      return cloneTr(tr.setSelection(createCellSelection($lastCell, $firstCell)));
+function ie(o, e) {
+  return (t, n) => {
+    if (!M(t))
+      return !1;
+    const l = ne(t);
+    if (l.nodeAfter.attrs[o] === e)
+      return !1;
+    if (n) {
+      const s = t.tr;
+      t.selection instanceof m ? t.selection.forEachCell((r, a) => {
+        r.attrs[o] !== e && s.setNodeMarkup(a, null, y(r.attrs, o, e));
+      }) : s.setNodeMarkup(l.pos, null, y(l.nodeAfter.attrs, o, e)), n(s);
+    }
+    return !0;
+  };
+}
+function ln(o, e) {
+  if (e < 0) {
+    const t = o.nodeBefore;
+    if (t)
+      return o.pos - t.nodeSize;
+    for (let n = o.index(-1) - 1, l = o.before(); n >= 0; n--) {
+      const s = o.node(-1).child(n);
+      if (s.childCount)
+        return l - 1 - s.lastChild.nodeSize;
+      l -= s.nodeSize;
     }
-  }
-  return tr;
-};
-const getCellsInTable = (selection) => {
-  const table2 = findTable(selection);
-  if (!table2) {
+  } else {
+    if (o.index() < o.parent.childCount - 1)
+      return o.pos + o.nodeAfter.nodeSize;
+    const t = o.node(-1);
+    for (let n = o.indexAfter(-1), l = o.after(); n < t.childCount; n++) {
+      const s = t.child(n);
+      if (s.childCount)
+        return l + 1;
+      l += s.nodeSize;
+    }
+  }
+}
+function De(o) {
+  return (e, t) => {
+    if (!M(e))
+      return !1;
+    const n = ln(ne(e), o);
+    if (n == null)
+      return !1;
+    if (t) {
+      const l = e.doc.resolve(n);
+      t(e.tr.setSelection(D.between(l, Xt(l))).scrollIntoView());
+    }
+    return !0;
+  };
+}
+const sn = (o, e) => {
+  const t = o.selection.$anchor;
+  for (let n = t.depth; n > 0; n--)
+    if (t.node(n).type.spec.tableRole == "table")
+      return e && e(o.tr.delete(t.before(n), t.after(n)).scrollIntoView()), !0;
+  return !1;
+}, oe = (o) => Ct((e) => e.type.spec.tableRole === "table")(o), rn = (o) => (e) => {
+  const t = oe(e);
+  if (!t)
     return;
-  }
-  const map = TableMap.get(table2.node);
-  const cells = map.cellsInRect({
+  const n = g.get(t.node);
+  if (!(o < 0 || o >= n.width))
+    return n.cellsInRect({ left: o, right: o + 1, top: 0, bottom: n.height }).map((l) => {
+      const s = t.node.nodeAt(l);
+      if (!s)
+        return;
+      const r = l + t.start;
+      return {
+        pos: r,
+        start: r + 1,
+        node: s
+      };
+    }).filter((l) => l != null);
+}, cn = (o) => (e) => {
+  const t = oe(e);
+  if (!t)
+    return;
+  const n = g.get(t.node);
+  if (!(o < 0 || o >= n.height))
+    return n.cellsInRect({ left: 0, right: n.width, top: o, bottom: o + 1 }).map((l) => {
+      const s = t.node.nodeAt(l);
+      if (!s)
+        return;
+      const r = l + t.start;
+      return {
+        pos: r,
+        start: r + 1,
+        node: s
+      };
+    }).filter((l) => l != null);
+}, Oe = (o, e = 3, t = 3) => {
+  const { cell: n, header_cell: l, row: s, table: r } = A(o), a = Array(t).fill(0).map(() => n.createAndFill(null)), i = Array(t).fill(0).map(() => l.createAndFill(null)), c = Array(e).fill(0).map((d, u) => s.create(null, u === 0 ? i : a));
+  return r.create(null, c);
+}, _e = (o) => (e) => (t) => {
+  const n = oe(t.selection), l = o === "row";
+  if (n) {
+    const s = g.get(n.node);
+    if (e >= 0 && e < (l ? s.height : s.width)) {
+      const r = s.positionAt(l ? e : s.height - 1, l ? s.width - 1 : e, n.node), a = t.doc.resolve(n.start + r), i = l ? m.rowSelection : m.colSelection, c = s.positionAt(l ? e : 0, l ? 0 : e, n.node), d = t.doc.resolve(n.start + c);
+      return Ge(t.setSelection(i(a, d)));
+    }
+  }
+  return t;
+}, an = (o) => {
+  const e = oe(o);
+  if (!e)
+    return;
+  const t = g.get(e.node);
+  return t.cellsInRect({
     left: 0,
-    right: map.width,
+    right: t.width,
     top: 0,
-    bottom: map.height
-  });
-  return cells.map((nodePos) => {
-    const node = table2.node.nodeAt(nodePos);
-    const pos = nodePos + table2.start;
-    return { pos, start: pos + 1, node };
+    bottom: t.height
+  }).map((l) => {
+    const s = e.node.nodeAt(l), r = l + e.start;
+    return { pos: r, start: r + 1, node: s };
   });
-};
-const selectTable = (tr) => {
-  const cells = getCellsInTable(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)));
+}, dn = (o) => {
+  const e = an(o.selection);
+  if (e && e[0]) {
+    const t = o.doc.resolve(e[0].pos), n = e[e.length - 1];
+    if (n) {
+      const l = o.doc.resolve(n.pos);
+      return Ge(o.setSelection(new m(l, t)));
     }
   }
-  return tr;
+  return o;
 };
-function addRowWithAlignment(tr, { map, tableStart, table: table2 }, row) {
-  const rowPos = Array(row).fill(0).reduce((acc, _, i) => {
-    return acc + table2.child(i).nodeSize;
-  }, tableStart);
-  const { cell: cellType, row: rowType } = tableNodeTypes(table2.type.schema);
-  const cells = Array(map.width).fill(0).map((_, col) => {
-    const headerCol = table2.nodeAt(map.map[col]);
-    return cellType.createAndFill({ alignment: headerCol == null ? void 0 : headerCol.attrs["alignment"] });
+function ze(o, { map: e, tableStart: t, table: n }, l) {
+  const s = Array(l).fill(0).reduce((c, d, u) => c + n.child(u).nodeSize, t), { cell: r, row: a } = A(n.type.schema), i = Array(e.width).fill(0).map((c, d) => {
+    const u = n.nodeAt(e.map[d]);
+    return r.createAndFill({ alignment: u == null ? void 0 : u.attrs.alignment });
   });
-  tr.insert(rowPos, rowType.create(null, cells));
-  return tr;
-}
-const getCellSelection = (view) => view.state.selection;
-const isFirstRowSelected = (selection) => {
-  const map = TableMap.get(selection.$anchorCell.node(-1));
-  const start = selection.$anchorCell.start(-1);
-  const cells = map.cellsInRect({
+  return o.insert(s, a.create(null, i)), o;
+}
+const T = (o) => o.state.selection, un = (o) => {
+  const e = g.get(o.$anchorCell.node(-1)), t = o.$anchorCell.start(-1), n = e.cellsInRect({
     left: 0,
-    right: map.width,
+    right: e.width,
     top: 0,
     bottom: 1
-  });
-  const selectedCells = map.cellsInRect(map.rectBetween(selection.$anchorCell.pos - start, selection.$headCell.pos - start));
-  for (let i = 0, count = cells.length; i < count; i++) {
-    if (selectedCells.indexOf(cells[i]) === -1) {
-      return false;
-    }
-  }
-  return true;
-};
-const calculateItem = (actions, view) => {
-  Object.values(actions).forEach((item) => {
-    var _a;
-    const disable = (_a = item.disable) == null ? void 0 : _a.call(item, view);
-    if (disable) {
-      item.$.classList.add("hide");
+  }), l = e.cellsInRect(e.rectBetween(o.$anchorCell.pos - t, o.$headCell.pos - t));
+  for (let s = 0, r = n.length; s < r; s++)
+    if (l.indexOf(n[s]) === -1)
+      return !1;
+  return !0;
+}, fn = (o, e) => {
+  Object.values(o).forEach((t) => {
+    var l;
+    if ((l = t.disable) == null ? void 0 : l.call(t, e)) {
+      t.$.classList.add("hide");
       return;
     }
-    item.$.classList.remove("hide");
+    t.$.classList.remove("hide");
   });
-};
-const createActions = (ctx) => {
-  var _a, _b, _c, _d, _e, _f, _g, _h;
+}, pn = (o) => {
+  var e, t, n, l, s, r, a, i;
   return {
     [0]: {
-      $: (_a = ctx.get(themeManagerCtx).get(ThemeIcon, "leftArrow")) == null ? void 0 : _a.dom,
-      command: () => addColumnBefore,
-      disable: (view) => !getCellSelection(view).isColSelection()
+      $: (e = o.get(L).get(v, "leftArrow")) == null ? void 0 : e.dom,
+      command: () => Yt,
+      disable: (c) => !T(c).isColSelection()
     },
     [1]: {
-      $: (_b = ctx.get(themeManagerCtx).get(ThemeIcon, "rightArrow")) == null ? void 0 : _b.dom,
-      command: () => addColumnAfter,
-      disable: (view) => !getCellSelection(view).isColSelection()
+      $: (t = o.get(L).get(v, "rightArrow")) == null ? void 0 : t.dom,
+      command: () => Qt,
+      disable: (c) => !T(c).isColSelection()
     },
     [2]: {
-      $: (_c = ctx.get(themeManagerCtx).get(ThemeIcon, "upArrow")) == null ? void 0 : _c.dom,
-      command: () => (state, dispatch) => {
-        if (!isInTable(state))
-          return false;
-        if (dispatch) {
-          const rect = selectedRect(state);
-          dispatch(addRowWithAlignment(state.tr, rect, rect.top));
+      $: (n = o.get(L).get(v, "upArrow")) == null ? void 0 : n.dom,
+      command: () => (c, d) => {
+        if (!M(c))
+          return !1;
+        if (d) {
+          const u = P(c);
+          d(ze(c.tr, u, u.top));
         }
-        return true;
+        return !0;
       },
-      disable: (view) => !getCellSelection(view).isRowSelection() || getCellSelection(view).$head.parent.type.name === "table_header"
+      disable: (c) => !T(c).isRowSelection() || T(c).$head.parent.type.name === "table_header"
     },
     [3]: {
-      $: (_d = ctx.get(themeManagerCtx).get(ThemeIcon, "downArrow")) == null ? void 0 : _d.dom,
-      command: () => (state, dispatch) => {
-        if (!isInTable(state))
-          return false;
-        if (dispatch) {
-          const rect = selectedRect(state);
-          dispatch(addRowWithAlignment(state.tr, rect, rect.bottom));
+      $: (l = o.get(L).get(v, "downArrow")) == null ? void 0 : l.dom,
+      command: () => (c, d) => {
+        if (!M(c))
+          return !1;
+        if (d) {
+          const u = P(c);
+          d(ze(c.tr, u, u.bottom));
         }
-        return true;
+        return !0;
       },
-      disable: (view) => !getCellSelection(view).isRowSelection()
+      disable: (c) => !T(c).isRowSelection()
     },
     [4]: {
-      $: (_e = ctx.get(themeManagerCtx).get(ThemeIcon, "alignLeft")) == null ? void 0 : _e.dom,
-      command: () => setCellAttr("alignment", "left"),
-      disable: (view) => !getCellSelection(view).isColSelection()
+      $: (s = o.get(L).get(v, "alignLeft")) == null ? void 0 : s.dom,
+      command: () => ie("alignment", "left"),
+      disable: (c) => !T(c).isColSelection()
     },
     [5]: {
-      $: (_f = ctx.get(themeManagerCtx).get(ThemeIcon, "alignCenter")) == null ? void 0 : _f.dom,
-      command: () => setCellAttr("alignment", "center"),
-      disable: (view) => !getCellSelection(view).isColSelection()
+      $: (r = o.get(L).get(v, "alignCenter")) == null ? void 0 : r.dom,
+      command: () => ie("alignment", "center"),
+      disable: (c) => !T(c).isColSelection()
     },
     [6]: {
-      $: (_g = ctx.get(themeManagerCtx).get(ThemeIcon, "alignRight")) == null ? void 0 : _g.dom,
-      command: () => setCellAttr("alignment", "right"),
-      disable: (view) => !getCellSelection(view).isColSelection()
+      $: (a = o.get(L).get(v, "alignRight")) == null ? void 0 : a.dom,
+      command: () => ie("alignment", "right"),
+      disable: (c) => !T(c).isColSelection()
     },
     [7]: {
-      $: (_h = ctx.get(themeManagerCtx).get(ThemeIcon, "delete")) == null ? void 0 : _h.dom,
-      command: (_, view) => {
-        const selection = getCellSelection(view);
-        const isCol = selection.isColSelection();
-        const isRow = selection.isRowSelection();
-        if (isCol && isRow) {
-          return deleteTable;
-        }
-        if (isCol) {
-          return deleteColumn;
-        }
-        return deleteRow;
+      $: (i = o.get(L).get(v, "delete")) == null ? void 0 : i.dom,
+      command: (c, d) => {
+        const u = T(d), f = u.isColSelection(), p = u.isRowSelection();
+        return f && p ? sn : f ? tn : on;
       },
-      disable: (view) => {
-        const selection = getCellSelection(view);
-        if (selection.isRowSelection()) {
-          if (selection.isColSelection()) {
-            return false;
-          }
-          return isFirstRowSelected(selection);
-        }
-        return false;
+      disable: (c) => {
+        const d = T(c);
+        return d.isRowSelection() ? d.isColSelection() ? !1 : un(d) : !1;
       }
     }
   };
-};
-const calculatePosition = (view, dom) => {
-  const { selection } = view.state;
-  const isCol = selection.isColSelection();
-  const isRow = selection.isRowSelection();
-  calculateNodePosition(view, dom, (selected, target, parent) => {
-    const $editor = dom.parentElement;
-    if (!$editor) {
-      throw new Error();
-    }
-    let left = !isRow ? selected.left - parent.left + (selected.width - target.width) / 2 : selected.left - parent.left - target.width / 2 - 8;
-    const top = selected.top - parent.top - target.height - (isCol ? 14 : 0) - 14 + $editor.scrollTop;
-    if (left < 0) {
-      left = 0;
-    }
-    return [top, left];
+}, hn = (o, e) => {
+  const { selection: t } = o.state, n = t.isColSelection(), l = t.isRowSelection();
+  yt(o, e, (s, r, a) => {
+    const i = e.parentElement;
+    if (!i)
+      throw bt();
+    let c = l ? s.left - a.left - r.width / 2 - 8 : s.left - a.left + (s.width - r.width) / 2;
+    const d = s.top - a.top - r.height - (n ? 14 : 0) - 14 + i.scrollTop;
+    return c < 0 && (c = 0), [d, c];
   });
 };
-var ToolTipPos = /* @__PURE__ */ ((ToolTipPos2) => {
-  ToolTipPos2["Left"] = "Left";
-  ToolTipPos2["Top"] = "Top";
-  ToolTipPos2["Point"] = "Point";
-  return ToolTipPos2;
-})(ToolTipPos || {});
-const injectStyle = (themeManager, { css, injectGlobal }) => {
-  const palette = getPalette(themeManager);
-  const radius = themeManager.get(ThemeSize, "radius");
-  const lineWidth = themeManager.get(ThemeSize, "lineWidth");
-  injectGlobal`
+var x = /* @__PURE__ */ ((o) => (o.Left = "Left", o.Top = "Top", o.Point = "Point", o))(x || {});
+const mn = (o, { css: e, injectGlobal: t }) => {
+  const n = wt(o), l = o.get(xe, "radius"), s = o.get(xe, "lineWidth");
+  return t`
         .milkdown {
             .tableWrapper {
                 table {
-                    width: calc(100% - 2em) !important;
-                    margin: 1em 0 1em 1em !important;
+                    width: calc(100% - 32px) !important;
+                    margin: 16px 0 16px 16px !important;
 
                     .milkdown-cell-left,
                     .milkdown-cell-point,
@@ -1306,34 +1160,34 @@ const injectStyle = (themeManager, { css, injectGlobal }) => {
                             width: 100%;
                             display: block;
                             transition: all 0.2s ease-in-out;
-                            background: ${palette("secondary", 0.12)};
+                            background: ${n("secondary", 0.12)};
                             content: '';
                         }
 
                         &:hover::after {
-                            background: ${palette("secondary", 0.38)};
+                            background: ${n("secondary", 0.38)};
                         }
                     }
 
                     .milkdown-cell-left {
-                        left: calc(-6px - 0.5em);
+                        left: -14px;
                         top: 0;
                         bottom: 0;
-                        width: 0.5em;
+                        width: 8px;
                     }
 
                     .milkdown-cell-top {
                         left: 0;
                         right: 0;
-                        top: calc(-6px - 0.5em);
-                        height: 0.5em;
+                        top: -14px;
+                        height: 8px;
                     }
 
                     .milkdown-cell-point {
-                        left: calc(-2px - 1em);
-                        top: calc(-2px - 1em);
-                        width: 1em;
-                        height: 1em;
+                        left: -18px;
+                        top: -18px;
+                        width: 16px;
+                        height: 16px;
 
                         .icon {
                             position: absolute;
@@ -1346,8 +1200,7 @@ const injectStyle = (themeManager, { css, injectGlobal }) => {
                 }
             }
         }
-    `;
-  return css`
+    `, e`
         display: inline-flex;
         cursor: pointer;
         z-index: 2;
@@ -1356,29 +1209,29 @@ const injectStyle = (themeManager, { css, injectGlobal }) => {
 
         position: absolute;
 
-        border-radius: ${radius};
+        border-radius: ${l};
 
-        ${themeManager.get(ThemeBorder, void 0)};
-        ${themeManager.get(ThemeShadow, void 0)};
+        ${o.get(mt, void 0)};
+        ${o.get(gt, void 0)};
 
         overflow: hidden;
-        background: ${palette("surface")};
+        background: ${n("surface")};
 
         .icon {
             position: relative;
-            color: ${palette("solid", 0.87)};
+            color: ${n("solid", 0.87)};
 
-            width: 2em;
-            line-height: 2em;
+            width: 48px;
+            line-height: 48px;
             text-align: center;
             transition: all 0.4s ease-in-out;
 
             &:hover {
-                background-color: ${palette("secondary", 0.12)};
+                background-color: ${n("secondary", 0.12)};
             }
 
             &.active {
-                color: ${palette("primary")};
+                color: ${n("primary")};
             }
 
             &:not(:last-child)::after {
@@ -1386,9 +1239,9 @@ const injectStyle = (themeManager, { css, injectGlobal }) => {
                 position: absolute;
                 right: 0;
                 top: 0;
-                width: ${lineWidth};
+                width: ${s};
                 bottom: 0;
-                background: ${palette("line")};
+                background: ${n("line")};
             }
         }
 
@@ -1397,1463 +1250,1024 @@ const injectStyle = (themeManager, { css, injectGlobal }) => {
             display: none;
         }
     `;
-};
-const calculateClassName = (pos) => {
-  switch (pos) {
-    case ToolTipPos.Left: {
+}, gn = (o) => {
+  switch (o) {
+    case x.Left:
       return "milkdown-cell-left";
-    }
-    case ToolTipPos.Top: {
+    case x.Top:
       return "milkdown-cell-top";
-    }
-    case ToolTipPos.Point:
-    default: {
+    case x.Point:
+    default:
       return "milkdown-cell-point";
-    }
   }
 };
-function createWidget(ctx, cell, pos, index = 0) {
-  return Decoration.widget(cell.pos + 1, (view) => {
-    var _a;
-    const div = document.createElement("div");
-    div.classList.add(calculateClassName(pos));
-    if (pos === ToolTipPos.Point) {
-      div.appendChild((_a = ctx.get(themeManagerCtx).get(ThemeIcon, "select")) == null ? void 0 : _a.dom);
-    }
-    div.addEventListener("mousedown", (e) => {
-      if (!view)
-        return;
-      e.preventDefault();
-      switch (pos) {
-        case ToolTipPos.Point: {
-          view.dispatch(selectTable(view.state.tr));
-          return;
-        }
-        case ToolTipPos.Left: {
-          view.dispatch(selectLine("row")(index)(view.state.tr));
-          return;
-        }
-        case ToolTipPos.Top: {
-          view.dispatch(selectLine("col")(index)(view.state.tr));
-          return;
-        }
-      }
-    });
-    return div;
-  });
-}
-const operatorPlugin = (ctx, utils) => {
-  return new Plugin({
-    key: new PluginKey("MILKDOWN_TABLE_OP"),
-    props: {
-      decorations: (state) => {
-        const decorations = [];
-        const leftCells = getCellsInColumn(0)(state.selection);
-        if (!leftCells)
-          return null;
-        const topCells = getCellsInRow(0)(state.selection);
-        if (!topCells)
-          return null;
-        const [topLeft] = leftCells;
-        decorations.push(createWidget(ctx, topLeft, ToolTipPos.Point));
-        leftCells.forEach((cell, i) => {
-          decorations.push(createWidget(ctx, cell, ToolTipPos.Left, i));
-        });
-        topCells.forEach((cell, i) => {
-          decorations.push(createWidget(ctx, cell, ToolTipPos.Top, i));
-        });
-        return DecorationSet.create(state.doc, decorations);
-      }
-    },
-    view: (editorView) => {
-      var _a;
-      const items = Object.fromEntries(Object.entries(createActions(ctx)).filter(([, value]) => value.$ != null));
-      const tooltip = document.createElement("div");
-      utils.themeManager.onFlush(() => {
-        const style = utils.getStyle((emotion) => injectStyle(utils.themeManager, emotion));
-        if (style) {
-          tooltip.classList.add(style);
-        }
-      });
-      tooltip.classList.add("table-tooltip", "hide");
-      Object.values(items).forEach(({ $ }) => tooltip.appendChild($));
-      (_a = editorView.dom.parentNode) == null ? void 0 : _a.appendChild(tooltip);
-      const listener = (e) => {
-        if (!editorView)
-          return;
-        e.stopPropagation();
-        e.preventDefault();
-        Object.values(items).forEach(({ $, command }) => {
-          if ($.contains(e.target)) {
-            command(e, editorView)(editorView.state, editorView.dispatch, editorView);
-          }
-        });
-      };
-      const hide = () => {
-        tooltip.classList.add("hide");
-      };
-      tooltip.addEventListener("mousedown", listener);
-      return {
-        update: (view, prevState) => {
-          const state = view.state;
-          if ((prevState == null ? void 0 : prevState.doc.eq(state.doc)) && prevState.selection.eq(state.selection))
+function ce(o, e, t, n = 0) {
+  return ke.widget(e.pos + 1, (l) => {
+    var r;
+    const s = document.createElement("div");
+    return s.classList.add(gn(t)), t === x.Point && s.appendChild((r = o.get(L).get(v, "select")) == null ? void 0 : r.dom), s.addEventListener("mousedown", (a) => {
+      if (!!l)
+        switch (a.preventDefault(), t) {
+          case x.Point: {
+            l.dispatch(dn(l.state.tr));
             return;
-          const isCellSelection = state.selection instanceof CellSelection;
-          if (!isCellSelection || !view.editable) {
-            hide();
+          }
+          case x.Left: {
+            l.dispatch(_e("row")(n)(l.state.tr));
             return;
           }
-          calculateItem(items, view);
-          if (Object.values(items).every(({ $ }) => $.classList.contains("hide"))) {
-            hide();
+          case x.Top: {
+            l.dispatch(_e("col")(n)(l.state.tr));
             return;
           }
-          tooltip.classList.remove("hide");
-          calculatePosition(view, tooltip);
-        },
-        destroy: () => {
-          tooltip.removeEventListener("mousedown", listener);
-          tooltip.remove();
         }
-      };
-    }
+    }), s;
   });
-};
-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;
+}
+const wn = (o, e) => new W({
+  key: new F("MILKDOWN_TABLE_OP"),
+  props: {
+    decorations: (t) => {
+      const n = [], l = rn(0)(t.selection);
+      if (!l)
+        return null;
+      const s = cn(0)(t.selection);
+      if (!s)
+        return null;
+      const [r] = l;
+      return n.push(ce(o, r, x.Point)), l.forEach((a, i) => {
+        n.push(ce(o, a, x.Left, i));
+      }), s.forEach((a, i) => {
+        n.push(ce(o, a, x.Top, i));
+      }), Ae.create(t.doc, n);
+    }
+  },
+  view: (t) => {
+    var a;
+    const n = Object.fromEntries(Object.entries(pn(o)).filter(([, i]) => i.$ != null)), l = document.createElement("div");
+    e.themeManager.onFlush(() => {
+      const i = e.getStyle((c) => mn(e.themeManager, c));
+      i && l.classList.add(i);
+    }), l.classList.add("table-tooltip", "hide"), Object.values(n).forEach(({ $: i }) => l.appendChild(i)), (a = t.dom.parentNode) == null || a.appendChild(l);
+    const s = (i) => {
+      !t || (i.stopPropagation(), i.preventDefault(), Object.values(n).forEach(({ $: c, command: d }) => {
+        c.contains(i.target) && d(i, t)(t.state, t.dispatch, t);
+      }));
+    }, r = () => {
+      l.classList.add("hide");
+    };
+    return l.addEventListener("mousedown", s), {
+      update: (i, c) => {
+        const d = i.state;
+        if ((c == null ? void 0 : c.doc.eq(d.doc)) && c.selection.eq(d.selection))
+          return;
+        if (!(d.selection instanceof m) || !i.editable) {
+          r();
+          return;
+        }
+        if (fn(n, i), Object.values(n).every(({ $: f }) => f.classList.contains("hide"))) {
+          r();
+          return;
+        }
+        l.classList.remove("hide"), hn(i, l);
+      },
+      destroy: () => {
+        l.removeEventListener("mousedown", s), l.remove();
+      }
+    };
+  }
+}), bn = (o) => o.type.name === "paragraph" && o.nodeSize === 2, Cn = (o) => o.type.name === "paragraph", yn = new F("plugin_autoInsertZeroSpace"), kn = () => new W({
+  key: yn,
+  props: {
+    handleDOMEvents: {
+      compositionstart(o) {
+        const { state: e, dispatch: t } = o, { tr: n, selection: l } = e, { $from: s } = l;
+        return Re.safari && M(e) && l.empty && bn(s.parent) && t(n.insertText("\u2060", s.start())), !1;
+      },
+      compositionend(o) {
+        const { state: e, dispatch: t } = o, { tr: n, selection: l } = e, { $from: s } = l;
+        return Re.safari && M(e) && l.empty && Cn(s.parent) && s.parent.textContent.startsWith("\u2060") && t(n.delete(s.start(), s.start() + 1)), !1;
       }
     }
   }
-  while (nextDOM) {
-    const after = nextDOM.nextSibling;
-    (_a = nextDOM.parentNode) == null ? void 0 : _a.removeChild(nextDOM);
-    nextDOM = after;
+});
+class An {
+  constructor(e, t) {
+    this.node = e, this.cellMinWidth = t, this.node = e, this.cellMinWidth = t, 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")), ue(e, this.colgroup, this.table, t), this.contentDOM = this.table.appendChild(document.createElement("tbody"));
   }
-  if (fixedWidth) {
-    table2.style.width = totalWidth + "px";
-    table2.style.minWidth = "";
-  } else {
-    table2.style.width = "";
-    table2.style.minWidth = totalWidth + "px";
+  update(e) {
+    return e.type != this.node.type ? !1 : (this.node = e, ue(e, this.colgroup, this.table, this.cellMinWidth), !0);
+  }
+  ignoreMutation(e) {
+    return e.type == "attributes" && (e.target == this.table || this.colgroup.contains(e.target));
   }
 }
-const key = new PluginKey("tableColumnResizing");
-function columnResizing({
-  handleWidth = 5,
-  cellMinWidth = 25,
-  View = TableView,
-  lastColumnResizable = true
+function ue(o, e, t, n, l, s) {
+  var d;
+  let r = 0, a = !0, i = e.firstChild;
+  const c = o.firstChild;
+  for (let u = 0, f = 0; u < c.childCount; u++) {
+    const { colspan: p, colwidth: h } = c.child(u).attrs;
+    for (let b = 0; b < p; b++, f++) {
+      const w = l == f ? s : h && h[b], C = w ? w + "px" : "";
+      r += w || n, w || (a = !1), i ? (i.style.width != C && (i.style.width = C), i = i.nextSibling) : e.appendChild(document.createElement("col")).style.width = C;
+    }
+  }
+  for (; i; ) {
+    const u = i.nextSibling;
+    (d = i.parentNode) == null || d.removeChild(i), i = u;
+  }
+  a ? (t.style.width = r + "px", t.style.minWidth = "") : (t.style.width = "", t.style.minWidth = r + "px");
+}
+const k = new F("tableColumnResizing");
+function Mn({
+  handleWidth: o = 5,
+  cellMinWidth: e = 25,
+  View: t = An,
+  lastColumnResizable: n = !0
 } = {}) {
-  const plugin = new Plugin({
-    key,
+  return new W({
+    key: k,
     state: {
-      init(_, state) {
-        this.spec.props.nodeViews[tableNodeTypes(state.schema).table.name] = (node) => new View(node, cellMinWidth);
-        return new ResizeState(-1, false);
+      init(s, r) {
+        return this.spec.props.nodeViews[A(r.schema).table.name] = (a) => new t(a, e), new q(-1, !1);
       },
-      apply(tr, prev) {
-        return prev.apply(tr);
+      apply(s, r) {
+        return r.apply(s);
       }
     },
     props: {
-      attributes(state) {
-        const pluginState = key.getState(state);
-        return pluginState.activeHandle > -1 ? { class: "resize-cursor" } : void 0;
+      attributes(s) {
+        return k.getState(s).activeHandle > -1 ? { class: "resize-cursor" } : void 0;
       },
       handleDOMEvents: {
-        mousemove(view, event) {
-          handleMouseMove(view, event, handleWidth, lastColumnResizable);
+        mousemove(s, r) {
+          Sn(s, r, o, n);
         },
-        mouseleave(view) {
-          handleMouseLeave(view);
+        mouseleave(s) {
+          Nn(s);
         },
-        mousedown(view, event) {
-          handleMouseDown$1(view, event, cellMinWidth);
+        mousedown(s, r) {
+          xn(s, r, e);
         }
       },
-      decorations(state) {
-        const pluginState = key.getState(state);
-        if (pluginState.activeHandle > -1)
-          return handleDecorations(state, pluginState.activeHandle);
-        return null;
+      decorations(s) {
+        const r = k.getState(s);
+        return r.activeHandle > -1 ? In(s, r.activeHandle) : 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) {
+}
+class q {
+  constructor(e, t) {
+    this.activeHandle = e, this.dragging = t, this.activeHandle = e, this.dragging = t;
+  }
+  apply(e) {
+    let t = this;
+    const n = e.getMeta(k);
+    if (n && n.setHandle != null)
+      return new q(n.setHandle, null);
+    if (n && n.setDragging !== void 0)
+      return new q(t.activeHandle, n.setDragging);
+    if (t.activeHandle > -1 && e.docChanged) {
+      let l = e.mapping.map(t.activeHandle, -1);
+      de(e.doc.resolve(l)) || (l = 0), t = new q(l, t.dragging);
+    }
+    return t;
+  }
+}
+function Sn(o, e, t, n) {
+  const l = k.getState(o.state);
+  if (!l.dragging) {
+    const s = Tn(e.target);
+    let r = -1;
+    if (s) {
+      const { left: a, right: i } = s.getBoundingClientRect();
+      e.clientX - a <= t ? r = Fe(o, e, "left") : i - e.clientX <= t && (r = Fe(o, e, "right"));
+    }
+    if (r != l.activeHandle) {
+      if (!n && r !== -1) {
+        const a = o.state.doc.resolve(r), i = a.node(-1), c = g.get(i), d = a.start(-1);
+        if (c.colCount(a.pos - d) + a.nodeAfter.attrs.colspan - 1 == c.width - 1)
           return;
-        }
       }
-      updateHandle(view, cell);
+      nt(o, r);
     }
   }
 }
-function handleMouseLeave(view) {
-  const pluginState = key.getState(view.state);
-  if (pluginState.activeHandle > -1 && !pluginState.dragging)
-    updateHandle(view, -1);
+function Nn(o) {
+  const e = k.getState(o.state);
+  e.activeHandle > -1 && !e.dragging && nt(o, -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 xn(o, e, t) {
+  const n = k.getState(o.state);
+  if (n.activeHandle == -1 || n.dragging)
+    return !1;
+  const l = o.state.doc.nodeAt(n.activeHandle), s = Rn(o, n.activeHandle, l.attrs);
+  o.dispatch(o.state.tr.setMeta(k, {
+    setDragging: { startX: e.clientX, startWidth: s }
   }));
-  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)
+  function r(i) {
+    window.removeEventListener("mouseup", r), window.removeEventListener("mousemove", a);
+    const c = k.getState(o.state);
+    c.dragging && (Ln(o, c.activeHandle, Be(c.dragging, i, t)), o.dispatch(o.state.tr.setMeta(k, { setDragging: null })));
+  }
+  function a(i) {
+    if (!i.which)
+      return r(i);
+    const c = k.getState(o.state), d = Be(c.dragging, i, t);
+    vn(o, c.activeHandle, d, t);
+  }
+  return window.addEventListener("mouseup", r), window.addEventListener("mousemove", a), e.preventDefault(), !0;
+}
+function Rn(o, e, { colspan: t, colwidth: n }) {
+  const l = n && n[n.length - 1];
+  if (l)
+    return l;
+  const s = o.domAtPos(e);
+  let a = s.node.childNodes[s.offset].offsetWidth, i = t;
+  if (n)
+    for (let c = 0; c < t; c++)
+      n[c] && (a -= n[c], i--);
+  return a / i;
+}
+function Tn(o) {
+  for (; o && o.nodeName != "TD" && o.nodeName != "TH"; )
+    o = o.classList.contains("ProseMirror") ? null : o.parentNode;
+  return o;
+}
+function Fe(o, e, t) {
+  const n = o.posAtCoords({ left: e.clientX, top: e.clientY });
+  if (!n)
     return -1;
-  const { pos } = found;
-  const $cell = cellAround(view.state.doc.resolve(pos));
-  if (!$cell)
+  const { pos: l } = n, s = U(o.state.doc.resolve(l));
+  if (!s)
     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])
+  if (t == "right")
+    return s.pos;
+  const r = g.get(s.node(-1)), a = s.start(-1), i = r.map.indexOf(s.pos - a);
+  return i % r.width == 0 ? -1 : a + r.map[i - 1];
+}
+function Be(o, e, t) {
+  const n = e.clientX - o.startX;
+  return Math.max(t, o.startWidth + n);
+}
+function nt(o, e) {
+  o.dispatch(o.state.tr.setMeta(k, { setHandle: e }));
+}
+function Ln(o, e, t) {
+  const n = o.state.doc.resolve(e), l = n.node(-1), s = g.get(l), r = n.start(-1), a = s.colCount(n.pos - r) + n.nodeAfter.attrs.colspan - 1, i = o.state.tr;
+  for (let c = 0; c < s.height; c++) {
+    const d = c * s.width + a;
+    if (c && s.map[d] == s.map[d - s.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)
+    const u = s.map[d], { attrs: f } = l.nodeAt(u), p = f.colspan == 1 ? 0 : a - s.colCount(u);
+    if (f.colwidth && f.colwidth[p] == t)
       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());
-    }
+    const h = f.colwidth ? f.colwidth.slice() : En(f.colspan);
+    h[p] = t, i.setNodeMarkup(r + u, null, y(f, "colwidth", h));
   }
-  return tr;
+  i.docChanged && o.dispatch(i);
 }
-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;
-    }
-  }
+function vn(o, e, t, n) {
+  const l = o.state.doc.resolve(e), s = l.node(-1), r = l.start(-1), a = g.get(s).colCount(l.pos - r) + l.nodeAfter.attrs.colspan - 1;
+  let i = o.domAtPos(l.start(-1)).node;
+  for (; i.nodeName != "TABLE"; )
+    i = i.parentNode;
+  ue(s, i.firstChild, i, n, a, t);
 }
-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 En(o) {
+  const e = [];
+  for (let t = 0; t < o; t++)
+    e.push(0);
+  return e;
 }
-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;
+function In(o, e) {
+  const t = [], n = o.doc.resolve(e), l = n.node(-1), s = g.get(l), r = n.start(-1), a = s.colCount(n.pos - r) + n.nodeAfter.attrs.colspan;
+  for (let i = 0; i < s.height; i++) {
+    const c = a + i * s.width - 1;
+    if ((a == s.width || s.map[c] != s.map[c + 1]) && (i == 0 || s.map[c - 1] != s.map[c - 1 - s.width])) {
+      const d = s.map[c], u = r + d + l.nodeAt(d).nodeSize - 1, f = document.createElement("div");
+      f.className = "column-resize-handle", t.push(ke.widget(u, f));
     }
   }
-  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;
-  };
+  return Ae.create(o.doc, t);
 }
-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)
+function $n(o) {
+  if (!o.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 {
+  let { content: e, openStart: t, openEnd: n } = o;
+  for (; e.childCount == 1 && (t > 0 && n > 0 || e.firstChild.type.spec.tableRole == "table"); )
+    t--, n--, e = e.firstChild.content;
+  const l = e.firstChild, s = l.type.spec.tableRole, r = l.type.schema, a = [];
+  if (s == "row")
+    for (let i = 0; i < e.childCount; i++) {
+      let c = e.child(i).content;
+      const d = i ? 0 : Math.max(0, t - 1), u = i < e.childCount - 1 ? 0 : Math.max(0, n - 1);
+      (d || u) && (c = fe(A(r).row, new O(c, d, u)).content), a.push(c);
+    }
+  else if (s == "cell" || s == "header_cell")
+    a.push(t || n ? fe(A(r).row, new O(e, t, n)).content : e);
+  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"];
+  return Dn(r, a);
+}
+function Dn(o, e) {
+  const t = [];
+  for (let l = 0; l < e.length; l++) {
+    const s = e[l];
+    for (let r = s.childCount - 1; r >= 0; r--) {
+      const { rowspan: a, colspan: i } = s.child(r).attrs;
+      for (let c = l; c < l + a; c++)
+        t[c] = (t[c] || 0) + i;
+    }
+  }
+  let n = 0;
+  for (let l = 0; l < t.length; l++)
+    n = Math.max(n, t[l]);
+  for (let l = 0; l < t.length; l++)
+    if (l >= e.length && e.push(E.empty), t[l] < n) {
+      const s = A(o).cell.createAndFill(), r = [];
+      for (let a = t[l]; a < n; a++)
+        r.push(s);
+      e[l] = e[l].append(E.from(r));
+    }
+  return { height: e.length, width: n, rows: e };
+}
+function fe(o, e) {
+  const t = o.createAndFill();
+  return new Nt(t).replace(0, t.content.size, e).doc;
+}
+function On({ width: o, height: e, rows: t }, n, l) {
+  if (o != n) {
+    const s = [], r = [];
+    for (let a = 0; a < t.length; a++) {
+      const i = t[a], c = [];
+      for (let d = s[a] || 0, u = 0; d < n; u++) {
+        let f = i.child(u % i.childCount);
+        d + f.attrs.colspan > n && (f = f.type.create(z(f.attrs, f.attrs.colspan, d + f.attrs.colspan - n), f.content)), c.push(f), d += f.attrs.colspan;
+        for (let p = 1; p < f.attrs.rowspan; p++)
+          s[a + p] = (s[a + p] || 0) + f.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;
+      r.push(E.from(c));
     }
+    t = r, o = n;
   }
-  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;
-        }
+  if (e != l) {
+    const s = [];
+    for (let r = 0, a = 0; r < l; r++, a++) {
+      const i = [], c = t[a % e];
+      for (let d = 0; d < c.childCount; d++) {
+        let u = c.child(d);
+        r + u.attrs.rowspan > l && (u = u.type.create(y(u.attrs, "rowspan", Math.max(1, l - u.attrs.rowspan)), u.content)), i.push(u);
       }
-      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;
+      s.push(E.from(i));
+    }
+    t = s, e = l;
+  }
+  return { width: o, height: e, rows: t };
+}
+function _n(o, e, t, n, l, s, r) {
+  const a = o.doc.type.schema, i = A(a);
+  let c, d;
+  if (l > e.width)
+    for (let u = 0, f = 0; u < e.height; u++) {
+      const p = t.child(u);
+      f += p.nodeSize;
+      const h = [];
+      let b;
+      p.lastChild == null || p.lastChild.type == i.cell ? b = c || (c = i.cell.createAndFill()) : b = d || (d = i.header_cell.createAndFill());
+      for (let w = e.width; w < l; w++)
+        h.push(b);
+      o.insert(o.mapping.slice(r).map(f - 1 + n), h);
+    }
+  if (s > e.height) {
+    const u = [];
+    for (let h = 0, b = (e.height - 1) * e.width; h < Math.max(e.width, l); h++) {
+      const w = h >= e.width ? !1 : t.nodeAt(e.map[b + h]).type == i.header_cell;
+      u.push(w ? d || (d = i.header_cell.createAndFill()) : c || (c = i.cell.createAndFill()));
+    }
+    const f = i.row.create(null, E.from(u)), p = [];
+    for (let h = e.height; h < s; h++)
+      p.push(f);
+    o.insert(o.mapping.slice(r).map(n + t.nodeSize - 2), p);
+  }
+  return !!(c || d);
+}
+function Pe(o, e, t, n, l, s, r, a) {
+  if (r == 0 || r == e.height)
+    return !1;
+  let i = !1;
+  for (let c = l; c < s; c++) {
+    const d = r * e.width + c, u = e.map[d];
+    if (e.map[d - e.width] == u) {
+      i = !0;
+      const f = t.nodeAt(u), { top: p, left: h } = e.findCell(u);
+      o.setNodeMarkup(o.mapping.slice(a).map(u + n), null, y(f.attrs, "rowspan", r - p)), o.insert(o.mapping.slice(a).map(e.positionAt(r, h, t)), f.type.createAndFill(y(f.attrs, "rowspan", p + f.attrs.rowspan - r))), c += f.attrs.colspan - 1;
+    }
+  }
+  return i;
+}
+function We(o, e, t, n, l, s, r, a) {
+  if (r == 0 || r == e.width)
+    return !1;
+  let i = !1;
+  for (let c = l; c < s; c++) {
+    const d = c * e.width + r, u = e.map[d];
+    if (e.map[d - 1] == u) {
+      i = !0;
+      const f = t.nodeAt(u), p = e.colCount(u), h = o.mapping.slice(a).map(u + n);
+      o.setNodeMarkup(h, null, z(f.attrs, r - p, f.attrs.colspan - (r - p))), o.insert(h + f.nodeSize, f.type.createAndFill(z(f.attrs, 0, r - p))), c += f.attrs.rowspan - 1;
+    }
+  }
+  return i;
+}
+function He(o, e, t, n, l) {
+  let s = t ? o.doc.nodeAt(t - 1) : o.doc, r = g.get(s);
+  const { top: a, left: i } = n, c = i + l.width, d = a + l.height, u = o.tr;
+  let f = 0;
+  function p() {
+    s = t ? u.doc.nodeAt(t - 1) : u.doc, r = g.get(s), f = u.mapping.maps.length;
+  }
+  _n(u, r, s, t, c, d, f) && p(), Pe(u, r, s, t, i, c, a, f) && p(), Pe(u, r, s, t, i, c, d, f) && p(), We(u, r, s, t, a, d, i, f) && p(), We(u, r, s, t, a, d, c, f) && p();
+  for (let h = a; h < d; h++) {
+    const b = r.positionAt(h, i, s), w = r.positionAt(h, c, s);
+    u.replace(u.mapping.slice(f).map(b + t), u.mapping.slice(f).map(w + t), new O(l.rows[h - a], 0, 0));
+  }
+  p(), u.setSelection(new m(u.doc.resolve(t + r.positionAt(a, i, s)), u.doc.resolve(t + r.positionAt(d - 1, c - 1, s)))), e(u);
+}
+const zn = new F("fix-tables");
+function ot(o, e, t, n) {
+  const l = o.childCount, s = e.childCount;
+  e:
+    for (let r = 0, a = 0; r < s; r++) {
+      const i = e.child(r);
+      for (let c = a, d = Math.min(l, r + 3); c < d; c++)
+        if (o.child(c) == i) {
+          a = c + 1, t += i.nodeSize;
+          continue e;
+        }
+      n(i, t), a < l && o.child(a).sameMarkup(i) ? ot(o.child(a), i, t + 1, n) : i.nodesBetween(0, i.content.size, n, t + 1), t += i.nodeSize;
     }
 }
-function fixTables(state, oldState) {
-  let tr;
-  const check = (node, pos) => {
-    if (node.type.spec["tableRole"] == "table")
-      tr = fixTable(state, node, pos, tr);
+function Fn(o, e) {
+  let t;
+  const n = (l, s) => {
+    l.type.spec.tableRole == "table" && (t = Bn(o, l, s, t));
   };
-  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 e ? e.doc != o.doc && ot(e.doc, o.doc, 0, n) : o.doc.descendants(n), t;
+}
+function Bn(o, e, t, n) {
+  const l = g.get(e);
+  if (!l.problems)
+    return n;
+  n || (n = o.tr);
+  const s = [];
+  for (let i = 0; i < l.height; i++)
+    s.push(0);
+  for (let i = 0; i < l.problems.length; i++) {
+    const c = l.problems[i];
+    if (c.type == "collision") {
+      const d = e.nodeAt(c.pos);
+      for (let u = 0; u < d.attrs.rowspan; u++)
+        s[c.row + u] += c.n;
+      n.setNodeMarkup(n.mapping.map(t + 1 + c.pos), null, z(d.attrs, d.attrs.colspan - c.n, c.n));
+    } else if (c.type == "missing")
+      s[c.row] += c.n;
+    else if (c.type == "overlong_rowspan") {
+      const d = e.nodeAt(c.pos);
+      n.setNodeMarkup(n.mapping.map(t + 1 + c.pos), null, y(d.attrs, "rowspan", d.attrs.rowspan - c.n));
+    } else if (c.type == "colwidth mismatch") {
+      const d = e.nodeAt(c.pos);
+      n.setNodeMarkup(n.mapping.map(t + 1 + c.pos), null, y(d.attrs, "colwidth", c.colwidth));
+    }
+  }
+  let r, a;
+  for (let i = 0; i < s.length; i++)
+    s[i] && (r == null && (r = i), a = i);
+  for (let i = 0, c = t + 1; i < l.height; i++) {
+    const d = e.child(i), u = c + d.nodeSize, f = s[i];
+    if (f > 0) {
+      let p = "cell";
+      d.firstChild && (p = d.firstChild.type.spec.tableRole);
+      const h = [];
+      for (let w = 0; w < f; w++)
+        h.push(A(o.schema)[p].createAndFill());
+      const b = (i == 0 || r == i - 1) && a == i ? c + 1 : u - 1;
+      n.insert(n.mapping.map(b), h);
+    }
+    c = u;
+  }
+  return n.setMeta(zn, { fixTables: !0 });
+}
+const I = new F("selectingCells");
+function je(o, e) {
+  for (; e && e != o.dom; e = e.parentNode)
+    if (e.nodeName == "TD" || e.nodeName == "TH")
+      return e;
+}
+function ae(o, e) {
+  const t = o.posAtCoords({ left: e.clientX, top: e.clientY });
+  return t && t ? U(o.state.doc.resolve(t.pos)) : null;
+}
+function Pn(o, e) {
+  const t = e;
+  if (t.ctrlKey || t.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) {
+  const n = je(o, t.target);
+  let l;
+  if (t.shiftKey && o.state.selection instanceof m)
+    s(o.state.selection.$anchorCell, t), t.preventDefault();
+  else if (t.shiftKey && n && (l = U(o.state.selection.$anchor)) != null && ae(o, t).pos != l.pos)
+    s(l, t), t.preventDefault();
+  else if (!n)
     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;
+  function s(i, c) {
+    let d = ae(o, c);
+    const u = I.getState(o.state) == null;
+    if (!d || !Se(i, d))
+      if (u)
+        d = i;
       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);
+    const f = new m(i, d);
+    if (u || !o.state.selection.eq(f)) {
+      const p = o.state.tr.setSelection(f);
+      u && p.setMeta(I, i.pos), o.dispatch(p);
     }
   }
-  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))
+  function r() {
+    o.root.removeEventListener("mouseup", r), o.root.removeEventListener("dragstart", r), o.root.removeEventListener("mousemove", a), I.getState(o.state) != null && o.dispatch(o.state.tr.setMeta(I, -1));
+  }
+  function a(i) {
+    const c = I.getState(o.state);
+    let d;
+    if (c != null)
+      d = o.state.doc.resolve(c);
+    else if (je(o, i.target) != n && (d = ae(o, t), !d))
+      return r();
+    d && s(d, i);
+  }
+  o.root.addEventListener("mouseup", r), o.root.addEventListener("dragstart", r), o.root.addEventListener("mousemove", a);
+}
+function Wn(o, e) {
+  const t = o.state.doc, n = U(t.resolve(e));
+  return n ? (o.dispatch(o.state.tr.setSelection(new m(n))), !0) : !1;
+}
+function Y(o, e, t) {
+  return t.eq(o.selection) ? !1 : (e && e(o.tr.setSelection(t).scrollIntoView()), !0);
+}
+function lt(o, e, t) {
+  if (!(o.state.selection instanceof D))
     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))
+  const { $head: n } = o.state.selection;
+  for (let l = n.depth - 1; l >= 0; l--) {
+    const s = n.node(l);
+    if ((t < 0 ? n.index(l) : n.indexAfter(l)) != (t < 0 ? 0 : s.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;
+    if (s.type.spec.tableRole == "cell" || s.type.spec.tableRole == "header_cell") {
+      const a = n.before(l), i = e == "vert" ? t > 0 ? "down" : "up" : t > 0 ? "right" : "left";
+      return o.endOfTextblock(i) ? a : 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 Z(o, e) {
+  return (t, n, l) => {
+    const s = t.selection;
+    if (s instanceof m)
+      return Y(t, n, S.near(s.$headCell, e));
+    if (o != "horiz" && !s.empty)
+      return !1;
+    const r = lt(l, o, e);
+    if (r == null)
+      return !1;
+    if (o == "horiz")
+      return Y(t, n, S.near(t.doc.resolve(s.head + e), e));
+    {
+      const a = t.doc.resolve(r), i = et(a, o, e);
+      let c;
+      return i ? c = S.near(i, 1) : e < 0 ? c = S.near(t.doc.resolve(a.before(-1)), -1) : c = S.near(t.doc.resolve(a.after(-1)), 1), Y(t, n, c);
     }
   };
 }
-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 G(o, e) {
+  return (t, n, l) => {
+    let s = t.selection;
+    if (!(s instanceof m)) {
+      const a = lt(l, o, e);
+      if (a == null)
+        return !1;
+      s = new m(t.doc.resolve(a));
+    }
+    const r = et(s.$headCell, o, e);
+    return r ? Y(t, n, new m(s.$anchorCell, r)) : !1;
   };
 }
-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 J(o, e) {
+  const t = o.selection;
+  if (!(t instanceof m))
+    return !1;
+  if (e) {
+    const n = o.tr, l = A(o.schema).cell.createAndFill().content;
+    t.forEachCell((s, r) => {
+      s.content.eq(l) || n.replace(n.mapping.map(r + 1), n.mapping.map(r + s.nodeSize - 1), new O(l, 0, 0));
+    }), n.docChanged && e(n);
+  }
+  return !0;
+}
+const Hn = St({
+  ArrowLeft: Z("horiz", -1),
+  ArrowRight: Z("horiz", 1),
+  ArrowUp: Z("vert", -1),
+  ArrowDown: Z("vert", 1),
+  "Shift-ArrowLeft": G("horiz", -1),
+  "Shift-ArrowRight": G("horiz", 1),
+  "Shift-ArrowUp": G("vert", -1),
+  "Shift-ArrowDown": G("vert", 1),
+  Backspace: J,
+  "Mod-Backspace": J,
+  Delete: J,
+  "Mod-Delete": J
 });
-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,
+function jn(o, e, t) {
+  if (!M(o.state))
+    return !1;
+  let n = $n(t);
+  const l = o.state.selection;
+  if (l instanceof m) {
+    n || (n = {
+      width: 1,
+      height: 1,
+      rows: [E.from(fe(A(o.state.schema).cell, t))]
+    });
+    const s = l.$anchorCell.node(-1), r = l.$anchorCell.start(-1), a = g.get(s).rectBetween(l.$anchorCell.pos - r, l.$headCell.pos - r);
+    return n = On(n, a.right - a.left, a.bottom - a.top), He(o.state, o.dispatch, r, a, n), !0;
+  } else if (n) {
+    const s = ne(o.state), r = s.start(-1);
+    return He(o.state, o.dispatch, r, g.get(s.node(-1)).findCell(s.pos - r), n), !0;
+  } else
+    return !1;
+}
+function Kn({ allowTableNodeSelection: o = !1 } = {}) {
+  return new W({
+    key: I,
     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;
+      apply(e, t) {
+        const n = e.getMeta(I);
+        if (n != null)
+          return n == -1 ? null : n;
+        if (t == null || !e.docChanged)
+          return t;
+        const { deleted: l, pos: s } = e.mapping.mapResult(t);
+        return l ? null : s;
       }
     },
     props: {
-      decorations: drawCellSelection,
+      decorations: Ht,
       handleDOMEvents: {
-        mousedown: handleMouseDown
+        mousedown: Pn
       },
-      createSelectionBetween(view) {
-        if (tableEditingKey.getState(view.state) != null)
-          return view.state.selection;
-        return null;
+      createSelectionBetween(e) {
+        return I.getState(e.state) != null ? e.state.selection : null;
       },
-      handleTripleClick,
-      handleKeyDown,
-      handlePaste
+      handleTripleClick: Wn,
+      handleKeyDown: Hn,
+      handlePaste: jn
     },
-    appendTransaction(_, oldState, state) {
-      return normalizeSelection(state, fixTables(state, oldState), allowTableNodeSelection);
+    appendTransaction(e, t, n) {
+      return qt(n, Fn(n, t), o);
     }
   });
 }
-const SupportedKeys$1 = {
+const Q = {
   NextCell: "NextCell",
   PrevCell: "PrevCell",
   ExitTable: "ExitTable"
-};
-const PrevCell = createCmdKey("PrevCell");
-const NextCell = createCmdKey("NextCell");
-const BreakTable = createCmdKey("BreakTable");
-const InsertTable = createCmdKey("InsertTable");
-const TableContentFilterPluginKey = new PluginKey("MILKDOWN_TABLE_CONTENT_FILTER");
-const table = createPlugin((utils) => {
-  return {
-    schema: () => ({
-      node: {
-        table: __spreadProps(__spreadValues({}, schema.table), {
-          parseMarkdown: {
-            match: (node) => node.type === "table",
-            runner: (state, node, type) => {
-              const align = node["align"];
-              const children = node.children.map((x, i) => __spreadProps(__spreadValues({}, x), {
-                align,
-                isHeader: i === 0
-              }));
-              state.openNode(type);
-              state.next(children);
-              state.closeNode();
-            }
-          },
-          toMarkdown: {
-            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();
-            }
+}, Ke = R("PrevCell"), qe = R("NextCell"), Ue = R("BreakTable"), qn = R("InsertTable"), Un = at((o) => ({
+  schema: () => ({
+    node: {
+      table: {
+        ...V.table,
+        parseMarkdown: {
+          match: (e) => e.type === "table",
+          runner: (e, t, n) => {
+            const l = t.align, s = t.children.map((r, a) => ({
+              ...r,
+              align: l,
+              isHeader: a === 0
+            }));
+            e.openNode(n), e.next(s), e.closeNode();
           }
-        }),
-        table_row: __spreadProps(__spreadValues({}, schema.table_row), {
-          parseMarkdown: {
-            match: (node) => node.type === "tableRow",
-            runner: (state, node, type) => {
-              const align = node["align"];
-              const children = node.children.map((x, i) => __spreadProps(__spreadValues({}, x), {
-                align: align[i],
-                isHeader: node["isHeader"]
-              }));
-              state.openNode(type);
-              state.next(children);
-              state.closeNode();
-            }
-          },
-          toMarkdown: {
-            match: (node) => node.type.name === "table_row",
-            runner: (state, node) => {
-              state.openNode("tableRow");
-              state.next(node.content);
-              state.closeNode();
-            }
+        },
+        toMarkdown: {
+          match: (e) => e.type.name === "table",
+          runner: (e, t) => {
+            var s;
+            const n = (s = t.content.firstChild) == null ? void 0 : s.content;
+            if (!n)
+              return;
+            const l = [];
+            n.forEach((r) => {
+              l.push(r.attrs.alignment);
+            }), e.openNode("table", void 0, { align: l }), e.next(t.content), e.closeNode();
           }
-        }),
-        table_cell: __spreadProps(__spreadValues({}, schema.table_cell), {
-          parseMarkdown: {
-            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: (node) => node.type.name === "table_cell",
-            runner: (state, node) => {
-              state.openNode("tableCell").next(node.content).closeNode();
-            }
+        }
+      },
+      table_row: {
+        ...V.table_row,
+        parseMarkdown: {
+          match: (e) => e.type === "tableRow",
+          runner: (e, t, n) => {
+            const l = t.align, s = t.children.map((r, a) => ({
+              ...r,
+              align: l[a],
+              isHeader: t.isHeader
+            }));
+            e.openNode(n), e.next(s), e.closeNode();
           }
-        }),
-        table_header: __spreadProps(__spreadValues({}, schema.table_header), {
-          parseMarkdown: {
-            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: (node) => node.type.name === "table_header",
-            runner: (state, node) => {
-              state.openNode("tableCell");
-              state.next(node.content);
-              state.closeNode();
-            }
+        },
+        toMarkdown: {
+          match: (e) => e.type.name === "table_row",
+          runner: (e, t) => {
+            e.openNode("tableRow"), e.next(t.content), e.closeNode();
           }
-        })
-      }
-    }),
-    inputRules: (nodeType, ctx) => [
-      new InputRule(/^\|\|\s$/, (state, _match, start, end) => {
-        const $start = state.doc.resolve(start);
-        if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType.table))
-          return null;
-        const tableNode = createTable(ctx.get(schemaCtx));
-        const tr = state.tr.replaceRangeWith(start, end, tableNode).scrollIntoView();
-        return tr.setSelection(TextSelection.create(tr.doc, start + 3));
-      })
-    ],
-    commands: (_, ctx) => [
-      createCmd(PrevCell, () => goToNextCell(-1)),
-      createCmd(NextCell, () => goToNextCell(1)),
-      createCmd(BreakTable, () => exitTable(ctx.get(schemaCtx).nodes["paragraph"])),
-      createCmd(InsertTable, () => (state, dispatch) => {
-        const { selection, tr } = state;
-        const { from } = selection;
-        const table2 = createTable(ctx.get(schemaCtx));
-        const _tr = tr.replaceSelectionWith(table2);
-        const sel = Selection.findFrom(_tr.doc.resolve(from), 1, true);
-        if (sel) {
-          dispatch == null ? void 0 : dispatch(_tr.setSelection(sel));
         }
-        return true;
-      })
-    ],
-    shortcuts: {
-      [SupportedKeys$1.NextCell]: createShortcut(NextCell, "Mod-]"),
-      [SupportedKeys$1.PrevCell]: createShortcut(PrevCell, "Mod-["),
-      [SupportedKeys$1.ExitTable]: createShortcut(BreakTable, "Mod-Enter")
-    },
-    prosePlugins: (_, ctx) => {
-      return [
-        operatorPlugin(ctx, utils),
-        columnResizing({}),
-        tableEditing(),
-        new Plugin({
-          key: TableContentFilterPluginKey,
-          filterTransaction: (tr, state) => {
-            const isInsertHr = tr.getMeta("hardbreak");
-            const [step] = tr.steps;
-            if (isInsertHr && step) {
-              const { from } = step;
-              const $from = state.doc.resolve(from);
-              let curDepth = $from.depth;
-              let canApply = true;
-              while (curDepth > 0) {
-                if ($from.node(curDepth).type.name === "table") {
-                  canApply = false;
-                }
-                curDepth--;
-              }
-              return canApply;
-            }
-            return true;
+      },
+      table_cell: {
+        ...V.table_cell,
+        parseMarkdown: {
+          match: (e) => e.type === "tableCell" && !e.isHeader,
+          runner: (e, t, n) => {
+            const l = t.align;
+            e.openNode(n, { alignment: l }).openNode(e.schema.nodes.paragraph).next(t.children).closeNode().closeNode();
+          }
+        },
+        toMarkdown: {
+          match: (e) => e.type.name === "table_cell",
+          runner: (e, t) => {
+            e.openNode("tableCell").next(t.content).closeNode();
           }
-        })
-      ];
-    }
-  };
-});
-const SupportedKeys = __spreadProps(__spreadValues(__spreadValues({}, SupportedKeys$2), SupportedKeys$1), {
-  StrikeThrough: "StrikeThrough",
-  TaskList: "TaskList"
-});
-const ToggleStrikeThrough = createCmdKey("ToggleStrikeThrough");
-const id = "strike_through";
-const strikeThrough = createMark((utils) => {
-  return {
-    id,
-    schema: () => ({
-      parseDOM: [
-        { tag: "del" },
-        { style: "text-decoration", getAttrs: (value) => value === "line-through" }
-      ],
-      toDOM: (mark) => ["del", { class: utils.getClassName(mark.attrs, "strike-through") }],
-      parseMarkdown: {
-        match: (node) => node.type === "delete",
-        runner: (state, node, markType) => {
-          state.openMark(markType);
-          state.next(node.children);
-          state.closeMark(markType);
         }
       },
-      toMarkdown: {
-        match: (mark) => mark.type.name === id,
-        runner: (state, mark) => {
-          state.withMark(mark, "delete");
+      table_header: {
+        ...V.table_header,
+        parseMarkdown: {
+          match: (e) => e.type === "tableCell" && !!e.isHeader,
+          runner: (e, t, n) => {
+            const l = t.align;
+            e.openNode(n, { alignment: l }), e.openNode(e.schema.nodes.paragraph), e.next(t.children), e.closeNode(), e.closeNode();
+          }
+        },
+        toMarkdown: {
+          match: (e) => e.type.name === "table_header",
+          runner: (e, t) => {
+            e.openNode("tableCell"), e.next(t.content), e.closeNode();
+          }
         }
       }
-    }),
-    inputRules: (markType) => [
-      markRule(/(?:~~)([^~]+)(?:~~)$/, markType),
-      markRule(/(?:^|[^~])(~([^~]+)~)$/, markType)
+    }
+  }),
+  inputRules: (e, t) => [
+    new Ce(/^\|\|\s$/, (n, l, s, r) => {
+      const a = n.doc.resolve(s);
+      if (!a.node(-1).canReplaceWith(a.index(-1), a.indexAfter(-1), e.table))
+        return null;
+      const i = Oe(t.get(re)), c = n.tr.replaceRangeWith(s, r, i).scrollIntoView();
+      return c.setSelection(D.create(c.doc, s + 3));
+    })
+  ],
+  commands: (e, t) => [
+    N(Ke, () => De(-1)),
+    N(qe, () => De(1)),
+    N(Ue, () => Jt(t.get(re).nodes.paragraph)),
+    N(qn, () => (n, l) => {
+      const { selection: s, tr: r } = n, { from: a } = s, i = Oe(t.get(re)), c = r.replaceSelectionWith(i), d = S.findFrom(c.doc.resolve(a), 1, !0);
+      return d && (l == null || l(c.setSelection(d))), !0;
+    })
+  ],
+  shortcuts: {
+    [Q.NextCell]: $(qe, "Mod-]"),
+    [Q.PrevCell]: $(Ke, "Mod-["),
+    [Q.ExitTable]: $(Ue, "Mod-Enter")
+  },
+  prosePlugins: (e, t) => [wn(t, o), kn(), Mn(), Kn()]
+})), K = {
+  ...st,
+  ...Q,
+  StrikeThrough: "StrikeThrough",
+  TaskList: "TaskList"
+}, pe = R("ToggleStrikeThrough"), Xe = "strike_through", Xn = dt((o) => ({
+  id: Xe,
+  schema: () => ({
+    parseDOM: [
+      { tag: "del" },
+      { style: "text-decoration", getAttrs: (e) => e === "line-through" }
     ],
-    commands: (markType) => [createCmd(ToggleStrikeThrough, () => toggleMark(markType))],
-    shortcuts: {
-      [SupportedKeys.StrikeThrough]: createShortcut(ToggleStrikeThrough, "Mod-Alt-x")
+    toDOM: (e) => ["del", { class: o.getClassName(e.attrs, "strike-through") }],
+    parseMarkdown: {
+      match: (e) => e.type === "delete",
+      runner: (e, t, n) => {
+        e.openMark(n), e.next(t.children), e.closeMark(n);
+      }
+    },
+    toMarkdown: {
+      match: (e) => e.type.name === Xe,
+      runner: (e, t) => {
+        e.withMark(t, "delete");
+      }
     }
-  };
-});
-const SplitTaskListItem = createCmdKey("SplitTaskListItem");
-const SinkTaskListItem = createCmdKey("SinkTaskListItem");
-const LiftTaskListItem = createCmdKey("LiftTaskListItem");
-const TurnIntoTaskList = createCmdKey("TurnIntoTaskList");
-const taskListItem = createNode((utils) => {
-  const id2 = "task_list_item";
+  }),
+  inputRules: (e) => [
+    Te(/(?:~~)([^~]+)(?:~~)$/, e),
+    Te(/(?:^|[^~])(~([^~]+)~)$/, e)
+  ],
+  commands: (e) => [N(pe, () => At(e))],
+  shortcuts: {
+    [K.StrikeThrough]: $(pe, "Mod-Alt-x")
+  }
+})), he = R("SplitTaskListItem"), me = R("SinkTaskListItem"), ge = R("LiftTaskListItem"), we = R("TurnIntoTaskList"), Vn = be((o) => {
+  const e = "task_list_item";
   return {
-    id: id2,
-    schema: (ctx) => ({
+    id: e,
+    schema: (t) => ({
       group: "listItem",
       content: "paragraph block*",
-      defining: true,
+      defining: !0,
       priority: 60,
       attrs: {
         checked: {
-          default: false
+          default: !1
         }
       },
       parseDOM: [
         {
           tag: 'li[data-type="task-item"]',
-          getAttrs: (dom) => {
-            if (!(dom instanceof HTMLElement)) {
-              throw new Error();
-            }
-            return { checked: dom.dataset["checked"] === "true" };
+          getAttrs: (n) => {
+            if (!(n instanceof HTMLElement))
+              throw ye(n);
+            return { checked: n.dataset.checked === "true" };
           }
         }
       ],
-      toDOM: (node) => {
-        const checkbox = document.createElement("input");
-        checkbox.type = "checkbox";
-        checkbox.checked = node.attrs["checked"];
-        checkbox.className = utils.getClassName(node.attrs, "task-list-item_checkbox");
-        checkbox.onchange = (event) => {
-          const target = event.target;
-          if (!(target instanceof HTMLInputElement))
+      toDOM: (n) => {
+        const l = document.createElement("input");
+        return l.type = "checkbox", l.checked = n.attrs.checked, l.className = o.getClassName(n.attrs, "task-list-item_checkbox"), l.onchange = (s) => {
+          const r = s.target;
+          if (!(r instanceof HTMLInputElement))
             return;
-          const view = ctx.get(editorViewCtx);
-          if (!view.editable) {
-            checkbox.checked = !checkbox.checked;
+          const a = t.get(ee);
+          if (!a.editable) {
+            l.checked = !l.checked;
             return;
           }
-          const { top, left } = target.getBoundingClientRect();
-          const result = view.posAtCoords({ top, left });
-          if (!result)
+          const { top: i, left: c } = r.getBoundingClientRect(), d = a.posAtCoords({ top: i, left: c });
+          if (!d)
             return;
-          const { tr } = view.state;
-          view.dispatch(tr.setNodeMarkup(result.inside, void 0, {
-            checked: target.checked
+          const { tr: u } = a.state;
+          a.dispatch(u.setNodeMarkup(d.inside, void 0, {
+            checked: r.checked
           }));
-        };
-        return [
+        }, [
           "li",
           {
             "data-type": "task-item",
-            "data-checked": node.attrs["checked"] ? "true" : "false",
-            class: utils.getClassName(node.attrs, "task-list-item")
+            "data-checked": n.attrs.checked ? "true" : "false",
+            class: o.getClassName(n.attrs, "task-list-item")
           },
-          checkbox,
-          ["span", { class: utils.getClassName(node.attrs, "task-list-item_body") }, 0]
+          l,
+          ["span", { class: o.getClassName(n.attrs, "task-list-item_body") }, 0]
         ];
       },
       parseMarkdown: {
-        match: ({ type, checked }) => {
-          return type === "listItem" && checked !== null;
-        },
-        runner: (state, node, type) => {
-          state.openNode(type, { checked: node["checked"] });
-          state.next(node.children);
-          state.closeNode();
+        match: ({ type: n, checked: l }) => n === "listItem" && l !== null,
+        runner: (n, l, s) => {
+          n.openNode(s, { checked: l.checked }), n.next(l.children), n.closeNode();
         }
       },
       toMarkdown: {
-        match: (node) => node.type.name === id2,
-        runner: (state, node) => {
-          state.openNode("listItem", void 0, { checked: node.attrs["checked"] });
-          state.next(node.content);
-          state.closeNode();
+        match: (n) => n.type.name === e,
+        runner: (n, l) => {
+          n.openNode("listItem", void 0, { checked: l.attrs.checked }), n.next(l.content), n.closeNode();
         }
       }
     }),
-    inputRules: (nodeType) => [
-      wrappingInputRule(/^\s*(\[([ |x])\])\s$/, nodeType, (match) => ({
-        checked: match[match.length - 1] === "x"
+    inputRules: (t) => [
+      Ve(/^\s*(\[([ |x])\])\s$/, t, (n) => ({
+        checked: n[n.length - 1] === "x"
       }))
     ],
-    commands: (nodeType) => [
-      createCmd(SplitTaskListItem, () => splitListItem(nodeType)),
-      createCmd(SinkTaskListItem, () => sinkListItem(nodeType)),
-      createCmd(LiftTaskListItem, () => liftListItem(nodeType)),
-      createCmd(TurnIntoTaskList, () => wrapIn(nodeType))
+    commands: (t) => [
+      N(he, () => xt(t)),
+      N(me, () => Rt(t)),
+      N(ge, () => Tt(t)),
+      N(we, () => Mt(t))
     ],
     shortcuts: {
-      [SupportedKeys.NextListItem]: createShortcut(SplitTaskListItem, "Enter"),
-      [SupportedKeys.SinkListItem]: createShortcut(SinkTaskListItem, "Mod-]"),
-      [SupportedKeys.LiftListItem]: createShortcut(LiftTaskListItem, "Mod-["),
-      [SupportedKeys.TaskList]: createShortcut(TurnIntoTaskList, "Mod-Alt-9")
+      [K.NextListItem]: $(he, "Enter"),
+      [K.SinkListItem]: $(me, "Mod-]"),
+      [K.LiftListItem]: $(ge, "Mod-["),
+      [K.TaskList]: $(we, "Mod-Alt-9")
     },
-    view: () => (node, view, getPos) => {
-      let currNode = node;
-      const renderer = utils.themeManager.get("task-list-item", {
-        editable: () => view.editable,
-        onChange: (selected) => {
-          const { tr } = view.state;
-          view.dispatch(tr.setNodeMarkup(getPos(), void 0, {
-            checked: selected
+    view: () => (t, n, l) => {
+      let s = t;
+      const r = o.themeManager.get("task-list-item", {
+        editable: () => n.editable,
+        onChange: (d) => {
+          const { tr: u } = n.state;
+          n.dispatch(u.setNodeMarkup(l(), void 0, {
+            checked: d
           }));
         }
       });
-      if (!renderer)
+      if (!r)
         return {};
-      const { dom, contentDOM, onUpdate } = renderer;
-      onUpdate(currNode);
-      return {
-        dom,
-        contentDOM,
-        update: (updatedNode) => {
-          if (updatedNode.type.name !== id2)
-            return false;
-          currNode = updatedNode;
-          onUpdate(currNode);
-          return true;
-        }
+      const { dom: a, contentDOM: i, onUpdate: c } = r;
+      return c(s), {
+        dom: a,
+        contentDOM: i,
+        update: (d) => d.type.name !== e ? !1 : (s = d, c(s), !0)
       };
     }
   };
-});
-const gfm = AtomList.create([
-  ...commonmark,
-  $remark(() => remarkGFM),
-  table(),
-  urlPlugin,
-  strikeThrough(),
-  taskListItem(),
-  footnoteReference(),
-  footnoteDefinition()
-]);
-const commands = __spreadProps(__spreadValues({}, commands$1), {
-  ToggleStrikeThrough,
-  TurnIntoTaskList,
-  SinkTaskListItem,
-  LiftTaskListItem,
-  SplitTaskListItem
-});
-export { BreakTable, InsertTable, LiftTaskListItem, ModifyFootnoteDef, ModifyFootnoteRef, NextCell, PrevCell, SinkTaskListItem, SplitTaskListItem, SupportedKeys, ToggleStrikeThrough, TurnIntoTaskList, commands, createTable, footnoteDefinition, footnoteReference, gfm, strikeThrough, table, taskListItem };
+}), ao = ut.create([
+  ...rt,
+  ft(() => pt),
+  Un(),
+  Et,
+  Xn(),
+  Vn(),
+  Ot(),
+  $t()
+]), uo = {
+  ...it,
+  ToggleStrikeThrough: pe,
+  TurnIntoTaskList: we,
+  SinkTaskListItem: me,
+  LiftTaskListItem: ge,
+  SplitTaskListItem: he
+};
+export {
+  Ue as BreakTable,
+  ho as InsertHardbreak,
+  mo as InsertHr,
+  go as InsertImage,
+  qn as InsertTable,
+  wo as LiftListItem,
+  ge as LiftTaskListItem,
+  Le as ModifyFootnoteDef,
+  ve as ModifyFootnoteRef,
+  bo as ModifyImage,
+  Co as ModifyLink,
+  qe as NextCell,
+  Ke as PrevCell,
+  yo as SinkListItem,
+  me as SinkTaskListItem,
+  ko as SplitListItem,
+  he as SplitTaskListItem,
+  K as SupportedKeys,
+  Ao as ToggleBold,
+  Mo as ToggleInlineCode,
+  So as ToggleItalic,
+  No as ToggleLink,
+  pe as ToggleStrikeThrough,
+  xo as TurnIntoCodeFence,
+  Ro as TurnIntoHeading,
+  we as TurnIntoTaskList,
+  To as TurnIntoText,
+  Lo as WrapInBlockquote,
+  vo as WrapInBulletList,
+  Eo as WrapInOrderedList,
+  Io as blockquote,
+  $o as bulletList,
+  Do as codeFence,
+  Oo as codeInline,
+  uo as commands,
+  _o as commonmark,
+  zo as commonmarkNodes,
+  Fo as commonmarkPlugins,
+  Oe as createTable,
+  Bo as doc,
+  Po as em,
+  $t as footnoteDefinition,
+  Ot as footnoteReference,
+  ao as gfm,
+  Wo as hardbreak,
+  Ho as heading,
+  jo as hr,
+  Ko as image,
+  qo as link,
+  Uo as listItem,
+  Xo as orderedList,
+  Vo as paragraph,
+  Xn as strikeThrough,
+  Zo as strong,
+  Un as table,
+  Vn as taskListItem,
+  Go as text
+};
 //# sourceMappingURL=index.es.js.map