@blocknote/core 0.42.3 → 0.43.0

package/dist/TrailingNode-BUhuMJrB.js

@@ -0,0 +1,2096 @@
+var xe = Object.defineProperty;
+var Ee = (n, e, o) => e in n ? xe(n, e, { enumerable: !0, configurable: !0, writable: !0, value: o }) : n[e] = o;
+var b = (n, e, o) => Ee(n, typeof e != "symbol" ? e + "" : e, o);
+import { Plugin as B, PluginKey as T, NodeSelection as le, TextSelection as _, Selection as L } from "prosemirror-state";
+import { combineTransactionSteps as Ie, getMarkRange as Be, posToDOMRect as Te, findChildren as j } from "@tiptap/core";
+import Pe from "fast-deep-equal";
+import { i as q, t as Oe, U as De, n as Ae, g as N, a as R, c as ce, m as Me, e as de, f as Le, h as Ne, j as Re, k as Ve, l as He, o as W, p as G } from "./blockToNode-DBNbhwwC.js";
+import { ai as ue, a2 as J, aj as he, $ as Fe, a1 as Q } from "./defaultBlocks-BJtxTOM2.js";
+import { c as k, a as H } from "./BlockNoteExtension-C2X7LW-V.js";
+import { yCursorPlugin as Ue, defaultSelectionBuilder as $e, ySyncPlugin as _e, redoCommand as ze, undoCommand as Ye, yUndoPlugin as Ke, yUndoPluginKey as Z } from "y-prosemirror";
+import * as I from "yjs";
+import { dropCursor as Xe } from "prosemirror-dropcursor";
+import { redo as je, undo as qe, history as We } from "prosemirror-history";
+import { Decoration as A, DecorationSet as V } from "prosemirror-view";
+import { v4 as Ge } from "uuid";
+import { DOMSerializer as me, Fragment as pe, Slice as fe, DOMParser as Je } from "prosemirror-model";
+import Qe from "rehype-parse";
+import Ze from "rehype-remark";
+import et from "remark-gfm";
+import tt from "remark-stringify";
+import { unified as ot } from "unified";
+import { fromDom as nt } from "hast-util-from-dom";
+import { visit as rt } from "unist-util-visit";
+import { splitCell as st, mergeCells as it, deleteRow as at, deleteColumn as lt, addRowBefore as ct, addRowAfter as dt, addColumnBefore as ut, addColumnAfter as ht, CellSelection as mt } from "prosemirror-tables";
+function ge(n) {
+  const e = Array.from(n.classList).filter(
+    (o) => !o.startsWith("bn-")
+  ) || [];
+  e.length > 0 ? n.className = e.join(" ") : n.removeAttribute("class");
+}
+function we(n, e, o, t) {
+  var a;
+  let r;
+  if (e)
+    if (typeof e == "string")
+      r = q([e], n.pmSchema);
+    else if (Array.isArray(e))
+      r = q(e, n.pmSchema);
+    else if (e.type === "tableContent")
+      r = Oe(e, n.pmSchema);
+    else
+      throw new De(e.type);
+  else throw new Error("blockContent is required");
+  const i = ((t == null ? void 0 : t.document) ?? document).createDocumentFragment();
+  for (const c of r)
+    if (c.type.name !== "text" && n.schema.inlineContentSchema[c.type.name]) {
+      const l = n.schema.inlineContentSpecs[c.type.name].implementation;
+      if (l) {
+        const m = Ae(
+          c,
+          n.schema.inlineContentSchema,
+          n.schema.styleSchema
+        ), h = l.toExternalHTML ? l.toExternalHTML(
+          m,
+          n
+        ) : l.render.call(
+          {
+            renderType: "dom",
+            props: void 0
+          },
+          m,
+          () => {
+          },
+          n
+        );
+        if (h) {
+          if (i.appendChild(h.dom), h.contentDOM) {
+            const f = o.serializeFragment(
+              c.content,
+              t
+            );
+            h.contentDOM.dataset.editable = "", h.contentDOM.appendChild(f);
+          }
+          continue;
+        }
+      }
+    } else if (c.type.name === "text") {
+      let l = document.createTextNode(
+        c.textContent
+      );
+      for (const m of c.marks.toReversed())
+        if (m.type.name in n.schema.styleSpecs) {
+          const h = (n.schema.styleSpecs[m.type.name].implementation.toExternalHTML ?? n.schema.styleSpecs[m.type.name].implementation.render)(m.attrs.stringValue, n);
+          h.contentDOM.appendChild(l), l = h.dom;
+        } else {
+          const h = m.type.spec.toDOM(m, !0), f = me.renderSpec(document, h);
+          f.contentDOM.appendChild(l), l = f.dom;
+        }
+      i.appendChild(l);
+    } else {
+      const l = o.serializeFragment(
+        pe.from([c]),
+        t
+      );
+      i.appendChild(l);
+    }
+  return i.childNodes.length === 1 && ((a = i.firstChild) == null ? void 0 : a.nodeType) === 1 && ge(i.firstChild), i;
+}
+function pt(n, e, o, t, r, s, i) {
+  var p, w, y, E, O, z, Y, K, X;
+  const a = (i == null ? void 0 : i.document) ?? document, c = e.pmSchema.nodes.blockContainer, l = o.props || {};
+  for (const [v, S] of Object.entries(
+    e.schema.blockSchema[o.type].propSchema
+  ))
+    !(v in l) && S.default !== void 0 && (l[v] = S.default);
+  const m = (w = (p = c.spec) == null ? void 0 : p.toDOM) == null ? void 0 : w.call(
+    p,
+    c.create({
+      id: o.id,
+      ...l
+    })
+  ), h = Array.from(m.dom.attributes), f = e.blockImplementations[o.type].implementation, u = ((y = f.toExternalHTML) == null ? void 0 : y.call(
+    {},
+    { ...o, props: l },
+    e
+  )) || f.render.call(
+    {},
+    { ...o, props: l },
+    e
+  ), g = a.createDocumentFragment();
+  if (u.dom.classList.contains("bn-block-content")) {
+    const v = [
+      ...h,
+      ...Array.from(u.dom.attributes)
+    ].filter(
+      (S) => S.name.startsWith("data") && S.name !== "data-content-type" && S.name !== "data-file-block" && S.name !== "data-node-view-wrapper" && S.name !== "data-node-type" && S.name !== "data-id" && S.name !== "data-editable"
+    );
+    for (const S of v)
+      u.dom.firstChild.setAttribute(S.name, S.value);
+    ge(u.dom.firstChild), g.append(...Array.from(u.dom.childNodes));
+  } else
+    g.append(u.dom);
+  if (u.contentDOM && o.content) {
+    const v = we(
+      e,
+      o.content,
+      // TODO
+      t,
+      i
+    );
+    u.contentDOM.appendChild(v);
+  }
+  let d;
+  if (r.has(o.type) ? d = "OL" : s.has(o.type) && (d = "UL"), d) {
+    if (((E = n.lastChild) == null ? void 0 : E.nodeName) !== d) {
+      const v = a.createElement(d);
+      d === "OL" && "start" in l && l.start && (l == null ? void 0 : l.start) !== 1 && v.setAttribute("start", l.start + ""), n.append(v);
+    }
+    n.lastChild.appendChild(g);
+  } else
+    n.append(g);
+  if (o.children && o.children.length > 0) {
+    const v = a.createDocumentFragment();
+    if (ye(
+      v,
+      e,
+      o.children,
+      t,
+      r,
+      s,
+      i
+    ), ((O = n.lastChild) == null ? void 0 : O.nodeName) === "UL" || ((z = n.lastChild) == null ? void 0 : z.nodeName) === "OL")
+      for (; ((Y = v.firstChild) == null ? void 0 : Y.nodeName) === "UL" || ((K = v.firstChild) == null ? void 0 : K.nodeName) === "OL"; )
+        n.lastChild.lastChild.appendChild(v.firstChild);
+    e.pmSchema.nodes[o.type].isInGroup("blockContent") ? n.append(v) : (X = u.contentDOM) == null || X.append(v);
+  }
+}
+const ye = (n, e, o, t, r, s, i) => {
+  for (const a of o)
+    pt(
+      n,
+      e,
+      a,
+      t,
+      r,
+      s,
+      i
+    );
+}, ft = (n, e, o, t, r, s) => {
+  const a = ((s == null ? void 0 : s.document) ?? document).createDocumentFragment();
+  return ye(
+    a,
+    n,
+    e,
+    o,
+    t,
+    r,
+    s
+  ), a;
+}, be = (n, e) => {
+  const o = me.fromSchema(n);
+  return {
+    exportBlocks: (t, r) => {
+      const s = ft(
+        e,
+        t,
+        o,
+        /* @__PURE__ */ new Set(["numberedListItem"]),
+        /* @__PURE__ */ new Set(["bulletListItem", "checkListItem", "toggleListItem"]),
+        r
+      ), i = document.createElement("div");
+      return i.append(s), i.innerHTML;
+    },
+    exportInlineContent: (t, r) => {
+      const s = we(
+        e,
+        t,
+        o,
+        r
+      ), i = document.createElement("div");
+      return i.append(s.cloneNode(!0)), i.innerHTML;
+    }
+  };
+};
+function gt(n, e) {
+  if (e === 0)
+    return;
+  const o = n.resolve(e);
+  for (let t = o.depth; t > 0; t--) {
+    const r = o.node(t);
+    if (ue(r))
+      return r.attrs.id;
+  }
+}
+function wt(n) {
+  return n.getMeta("paste") ? { type: "paste" } : n.getMeta("uiEvent") === "drop" ? { type: "drop" } : n.getMeta("history$") ? {
+    type: n.getMeta("history$").redo ? "redo" : "undo"
+  } : n.getMeta("y-sync$") ? n.getMeta("y-sync$").isUndoRedoOperation ? { type: "undo-redo" } : { type: "yjs-remote" } : { type: "local" };
+}
+function ee(n) {
+  const e = "__root__", o = {}, t = {}, r = N(n);
+  return n.descendants((s, i) => {
+    if (!ue(s))
+      return !0;
+    const a = gt(n, i), c = a ?? e;
+    t[c] || (t[c] = []);
+    const l = R(s, r);
+    return o[s.attrs.id] = { block: l, parentId: a }, t[c].push(s.attrs.id), !0;
+  }), { byId: o, childrenByParent: t };
+}
+function yt(n, e) {
+  const o = /* @__PURE__ */ new Set();
+  if (!n || !e)
+    return o;
+  const t = new Set(n), r = e.filter((d) => t.has(d)), s = n.filter(
+    (d) => r.includes(d)
+  );
+  if (s.length <= 1 || r.length <= 1)
+    return o;
+  const i = {};
+  for (let d = 0; d < s.length; d++)
+    i[s[d]] = d;
+  const a = r.map((d) => i[d]), c = a.length, l = [], m = [], h = new Array(c).fill(-1), f = (d, p) => {
+    let w = 0, y = d.length;
+    for (; w < y; ) {
+      const E = w + y >>> 1;
+      d[E] < p ? w = E + 1 : y = E;
+    }
+    return w;
+  };
+  for (let d = 0; d < c; d++) {
+    const p = a[d], w = f(l, p);
+    w > 0 && (h[d] = m[w - 1]), w === l.length ? (l.push(p), m.push(d)) : (l[w] = p, m[w] = d);
+  }
+  const u = /* @__PURE__ */ new Set();
+  let g = m[m.length - 1] ?? -1;
+  for (; g !== -1; )
+    u.add(g), g = h[g];
+  for (let d = 0; d < r.length; d++)
+    u.has(d) || o.add(r[d]);
+  return o;
+}
+function bt(n, e = []) {
+  const o = wt(n), t = Ie(n.before, [
+    n,
+    ...e
+  ]), r = ee(
+    t.before
+  ), s = ee(
+    t.doc
+  ), i = [], a = /* @__PURE__ */ new Set();
+  Object.keys(s.byId).filter((u) => !(u in r.byId)).forEach((u) => {
+    i.push({
+      type: "insert",
+      block: s.byId[u].block,
+      source: o,
+      prevBlock: void 0
+    }), a.add(u);
+  }), Object.keys(r.byId).filter((u) => !(u in s.byId)).forEach((u) => {
+    i.push({
+      type: "delete",
+      block: r.byId[u].block,
+      source: o,
+      prevBlock: void 0
+    }), a.add(u);
+  }), Object.keys(s.byId).filter((u) => u in r.byId).forEach((u) => {
+    var w, y;
+    const g = r.byId[u], d = s.byId[u];
+    g.parentId !== d.parentId ? (i.push({
+      type: "move",
+      block: d.block,
+      prevBlock: g.block,
+      source: o,
+      prevParent: g.parentId ? (w = r.byId[g.parentId]) == null ? void 0 : w.block : void 0,
+      currentParent: d.parentId ? (y = s.byId[d.parentId]) == null ? void 0 : y.block : void 0
+    }), a.add(u)) : Pe(
+      { ...g.block, children: void 0 },
+      { ...d.block, children: void 0 }
+    ) || (i.push({
+      type: "update",
+      block: d.block,
+      prevBlock: g.block,
+      source: o
+    }), a.add(u));
+  });
+  const c = r.childrenByParent, l = s.childrenByParent, m = "__root__", h = /* @__PURE__ */ new Set([
+    ...Object.keys(c),
+    ...Object.keys(l)
+  ]), f = /* @__PURE__ */ new Set();
+  return h.forEach((u) => {
+    const g = yt(
+      c[u],
+      l[u]
+    );
+    g.size !== 0 && g.forEach((d) => {
+      var E, O;
+      const p = r.byId[d], w = s.byId[d];
+      !p || !w || p.parentId !== w.parentId || a.has(d) || (p.parentId ?? m) !== u || f.has(d) || (f.add(d), i.push({
+        type: "move",
+        block: w.block,
+        prevBlock: p.block,
+        source: o,
+        prevParent: p.parentId ? (E = r.byId[p.parentId]) == null ? void 0 : E.block : void 0,
+        currentParent: w.parentId ? (O = s.byId[w.parentId]) == null ? void 0 : O.block : void 0
+      }), a.add(d));
+    });
+  }), i;
+}
+function vt() {
+  const n = (e) => {
+    let o = e.children.length;
+    for (let t = 0; t < o; t++) {
+      const r = e.children[t];
+      if (r.type === "element" && (n(r), r.tagName === "u"))
+        if (r.children.length > 0) {
+          e.children.splice(t, 1, ...r.children);
+          const s = r.children.length - 1;
+          o += s, t += s;
+        } else
+          e.children.splice(t, 1), o--, t--;
+    }
+  };
+  return n;
+}
+function kt() {
+  const n = (e) => {
+    var o;
+    if (e.children && "length" in e.children && e.children.length)
+      for (let t = e.children.length - 1; t >= 0; t--) {
+        const r = e.children[t], s = t + 1 < e.children.length ? e.children[t + 1] : void 0;
+        r.type === "element" && r.tagName === "input" && ((o = r.properties) == null ? void 0 : o.type) === "checkbox" && (s == null ? void 0 : s.type) === "element" && s.tagName === "p" ? (s.tagName = "span", s.children.splice(
+          0,
+          0,
+          nt(document.createTextNode(" "))
+        )) : n(r);
+      }
+  };
+  return n;
+}
+function Ct() {
+  return (n) => {
+    rt(n, "element", (e, o, t) => {
+      var r, s, i, a;
+      if (t && e.tagName === "video") {
+        const c = ((r = e.properties) == null ? void 0 : r.src) || ((s = e.properties) == null ? void 0 : s["data-url"]) || "", l = ((i = e.properties) == null ? void 0 : i.title) || ((a = e.properties) == null ? void 0 : a["data-name"]) || "";
+        t.children[o] = {
+          type: "text",
+          value: `![${l}](${c})`
+        };
+      }
+    });
+  };
+}
+function ve(n) {
+  return ot().use(Qe, { fragment: !0 }).use(Ct).use(vt).use(kt).use(Ze).use(et).use(tt, {
+    handlers: { text: (o) => o.value }
+  }).processSync(n).value;
+}
+function ao(n, e, o, t) {
+  const s = be(e, o).exportBlocks(n, t);
+  return ve(s);
+}
+function St(n) {
+  const e = [];
+  return n.descendants((o) => {
+    var r, s;
+    const t = N(o);
+    return o.type.name === "blockContainer" && ((r = o.firstChild) == null ? void 0 : r.type.name) === "blockGroup" ? !0 : o.type.name === "columnList" && o.childCount === 1 ? ((s = o.firstChild) == null || s.forEach((i) => {
+      e.push(R(i, t));
+    }), !1) : o.type.isInGroup("bnBlock") ? (e.push(R(o, t)), !1) : !0;
+  }), e;
+}
+const lo = k(() => {
+  const n = [];
+  return {
+    key: "blockChange",
+    prosemirrorPlugins: [
+      new B({
+        key: new T("blockChange"),
+        filterTransaction: (e) => {
+          let o;
+          return n.reduce((t, r) => t === !1 ? t : r({
+            getChanges() {
+              return o || (o = bt(e), o);
+            },
+            tr: e
+          }) !== !1, !0);
+        }
+      })
+    ],
+    /**
+     * Subscribe to the block change events.
+     */
+    subscribe(e) {
+      return n.push(e), () => {
+        n.splice(
+          n.indexOf(e),
+          1
+        );
+      };
+    }
+  };
+});
+function te(n) {
+  const e = n.charAt(0) === "#" ? n.substring(1, 7) : n, o = parseInt(e.substring(0, 2), 16), t = parseInt(e.substring(2, 4), 16), r = parseInt(e.substring(4, 6), 16), i = [o / 255, t / 255, r / 255].map((c) => c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4));
+  return 0.2126 * i[0] + 0.7152 * i[1] + 0.0722 * i[2] <= 0.179;
+}
+function xt(n) {
+  const e = document.createElement("span");
+  e.classList.add("bn-collaboration-cursor__base");
+  const o = document.createElement("span");
+  o.setAttribute("contentedEditable", "false"), o.classList.add("bn-collaboration-cursor__caret"), o.setAttribute(
+    "style",
+    `background-color: ${n.color}; color: ${te(n.color) ? "white" : "black"}`
+  );
+  const t = document.createElement("span");
+  return t.classList.add("bn-collaboration-cursor__label"), t.setAttribute(
+    "style",
+    `background-color: ${n.color}; color: ${te(n.color) ? "white" : "black"}`
+  ), t.insertBefore(document.createTextNode(n.name), null), o.insertBefore(t, null), e.insertBefore(document.createTextNode("⁠"), null), e.insertBefore(o, null), e.insertBefore(document.createTextNode("⁠"), null), e;
+}
+const oe = k(
+  ({
+    options: n
+  }) => {
+    const e = /* @__PURE__ */ new Map();
+    return n.provider && "awareness" in n.provider && typeof n.provider.awareness == "object" && ("setLocalStateField" in n.provider.awareness && typeof n.provider.awareness.setLocalStateField == "function" && n.provider.awareness.setLocalStateField("user", n.user), "on" in n.provider.awareness && typeof n.provider.awareness.on == "function" && n.showCursorLabels !== "always" && n.provider.awareness.on(
+      "change",
+      ({
+        updated: o
+      }) => {
+        for (const t of o) {
+          const r = e.get(t);
+          r && (r.element.setAttribute("data-active", ""), r.hideTimeout && clearTimeout(r.hideTimeout), e.set(t, {
+            element: r.element,
+            hideTimeout: setTimeout(() => {
+              r.element.removeAttribute("data-active");
+            }, 2e3)
+          }));
+        }
+      }
+    )), {
+      key: "yCursor",
+      prosemirrorPlugins: [
+        Ue(n.provider.awareness, {
+          selectionBuilder: $e,
+          cursorBuilder(o, t) {
+            let r = e.get(t);
+            if (!r) {
+              const s = (n.renderCursor ?? xt)(o);
+              n.showCursorLabels !== "always" && (s.addEventListener("mouseenter", () => {
+                const i = e.get(t);
+                i.element.setAttribute("data-active", ""), i.hideTimeout && (clearTimeout(i.hideTimeout), e.set(t, {
+                  element: i.element,
+                  hideTimeout: void 0
+                }));
+              }), s.addEventListener("mouseleave", () => {
+                const i = e.get(t);
+                e.set(t, {
+                  element: i.element,
+                  hideTimeout: setTimeout(() => {
+                    i.element.removeAttribute("data-active");
+                  }, 2e3)
+                });
+              })), r = {
+                element: s,
+                hideTimeout: void 0
+              }, e.set(t, r);
+            }
+            return r.element;
+          }
+        })
+      ],
+      dependsOn: ["ySync"],
+      updateUser(o) {
+        n.provider.awareness.setLocalStateField("user", o);
+      }
+    };
+  }
+), F = k(
+  ({ options: n }) => ({
+    key: "ySync",
+    prosemirrorPlugins: [_e(n.fragment)],
+    runsBefore: ["default"]
+  })
+), U = k(({ editor: n }) => ({
+  key: "yUndo",
+  prosemirrorPlugins: [Ke({ trackedOrigins: [n] })],
+  dependsOn: ["yCursor", "ySync"],
+  undoCommand: Ye,
+  redoCommand: ze
+}));
+function Et(n, e) {
+  const o = n.doc;
+  if (n._item === null) {
+    const t = Array.from(o.share.keys()).find(
+      (r) => o.share.get(r) === n
+    );
+    if (t == null)
+      throw new Error("type does not exist in other ydoc");
+    return e.get(t, n.constructor);
+  } else {
+    const t = n._item, r = e.store.clients.get(t.id.client) ?? [], s = I.findIndexSS(r, t.id.clock);
+    return r[s].content.type;
+  }
+}
+const co = k(
+  ({
+    editor: n,
+    options: e
+  }) => {
+    let o;
+    const t = H({ isForked: !1 });
+    return {
+      key: "yForkDoc",
+      store: t,
+      /**
+       * Fork the Y.js document from syncing to the remote,
+       * allowing modifications to the document without affecting the remote.
+       * These changes can later be rolled back or applied to the remote.
+       */
+      fork() {
+        if (o)
+          return;
+        const r = e.fragment;
+        if (!r)
+          throw new Error("No fragment to fork from");
+        const s = new I.Doc();
+        I.applyUpdate(s, I.encodeStateAsUpdate(r.doc));
+        const i = Et(r, s);
+        o = {
+          undoStack: Z.getState(n.prosemirrorState).undoManager.undoStack,
+          originalFragment: r,
+          forkedFragment: i
+        }, n.unregisterExtension([
+          U,
+          oe,
+          F
+        ]);
+        const a = {
+          ...e,
+          fragment: i
+        };
+        n.registerExtension([
+          F(a),
+          // No need to register the cursor plugin again, it's a local fork
+          U({})
+        ]), t.setState({ isForked: !0 });
+      },
+      /**
+       * Resume syncing the Y.js document to the remote
+       * If `keepChanges` is true, any changes that have been made to the forked document will be applied to the original document.
+       * Otherwise, the original document will be restored and the changes will be discarded.
+       */
+      merge({ keepChanges: r }) {
+        if (!o)
+          return;
+        n.unregisterExtension(["ySync", "yCursor", "yUndo"]);
+        const { originalFragment: s, forkedFragment: i, undoStack: a } = o;
+        if (n.registerExtension([
+          F(e),
+          oe(e),
+          U({})
+        ]), Z.getState(
+          n.prosemirrorState
+        ).undoManager.undoStack = a, r) {
+          const c = I.encodeStateAsUpdate(
+            i.doc,
+            I.encodeStateVector(s.doc)
+          );
+          I.applyUpdate(s.doc, c, n);
+        }
+        o = void 0, t.setState({ isForked: !1 });
+      }
+    };
+  }
+), ke = (n, e) => {
+  e(n), n.forEach((o) => {
+    o instanceof I.XmlElement && ke(o, e);
+  });
+}, It = (n, e) => {
+  const o = /* @__PURE__ */ new Map();
+  return n.forEach((t) => {
+    t instanceof I.XmlElement && ke(t, (r) => {
+      if (r.nodeName === "blockContainer" && r.hasAttribute("id")) {
+        const s = r.getAttribute("textColor"), i = r.getAttribute("backgroundColor"), a = {
+          textColor: s === J.textColor.default ? void 0 : s,
+          backgroundColor: i === J.backgroundColor.default ? void 0 : i
+        };
+        (a.textColor || a.backgroundColor) && o.set(r.getAttribute("id"), a);
+      }
+    });
+  }), o.size === 0 ? !1 : (e.doc.descendants((t, r) => {
+    if (t.type.name === "blockContainer" && o.has(t.attrs.id)) {
+      const s = e.doc.nodeAt(r + 1);
+      if (!s)
+        throw new Error("No element found");
+      e.setNodeMarkup(r + 1, void 0, {
+        // preserve existing attributes
+        ...s.attrs,
+        // add the textColor and backgroundColor attributes
+        ...o.get(t.attrs.id)
+      });
+    }
+  }), !0);
+}, Bt = [It], uo = k(
+  ({ options: n }) => {
+    let e = !1;
+    const o = new T("schemaMigration");
+    return {
+      key: "schemaMigration",
+      prosemirrorPlugins: [
+        new B({
+          key: o,
+          appendTransaction: (t, r, s) => {
+            if (e || // If any of the transactions are not due to a yjs sync, we don't need to run the migration
+            !t.some((a) => a.getMeta("y-sync$")) || // If none of the transactions result in a document change, we don't need to run the migration
+            t.every((a) => !a.docChanged) || // If the fragment is still empty, we can't run the migration (since it has not yet been applied to the Y.Doc)
+            !n.fragment.firstChild)
+              return;
+            const i = s.tr;
+            for (const a of Bt)
+              a(n.fragment, i);
+            if (e = !0, !!i.docChanged)
+              return i;
+          }
+        })
+      ]
+    };
+  }
+), ho = k(
+  ({
+    editor: n,
+    options: e
+  }) => ({
+    key: "dropCursor",
+    prosemirrorPlugins: [
+      (e.dropCursor ?? Xe)({
+        width: 5,
+        color: "#ddeeff",
+        editor: n
+      })
+    ]
+  })
+), mo = k(({ editor: n }) => {
+  const e = H(!1), o = () => n.transact((t) => {
+    var s;
+    if (t.selection.empty || t.selection instanceof le && (t.selection.node.type.spec.content === "inline*" || ((s = t.selection.node.firstChild) == null ? void 0 : s.type.spec.content) === "inline*") || t.selection instanceof _ && t.doc.textBetween(t.selection.from, t.selection.to).length === 0)
+      return !1;
+    let r = !1;
+    return t.selection.content().content.descendants((i) => (i.type.spec.code && (r = !0), !r)), !r;
+  });
+  return {
+    key: "formattingToolbar",
+    store: e,
+    mount({ dom: t, signal: r }) {
+      let s = !1;
+      const i = n.onChange(() => {
+        s || e.setState(o());
+      }), a = n.onSelectionChange(() => {
+        s || e.setState(o());
+      });
+      t.addEventListener(
+        "pointerdown",
+        () => {
+          s = !0, e.setState(!1);
+        },
+        { signal: r }
+      ), n.prosemirrorView.root.addEventListener(
+        "pointerup",
+        () => {
+          s = !1, n.isFocused() && e.setState(o());
+        },
+        { signal: r, capture: !0 }
+      ), t.addEventListener(
+        "pointercancel",
+        () => {
+          s = !1;
+        },
+        {
+          signal: r,
+          capture: !0
+        }
+      ), r.addEventListener("abort", () => {
+        i(), a();
+      });
+    }
+  };
+}), po = k(() => ({
+  key: "history",
+  prosemirrorPlugins: [We()],
+  undoCommand: qe,
+  redoCommand: je
+})), fo = k(({ editor: n }) => {
+  function e(r) {
+    let s = n.prosemirrorView.nodeDOM(r);
+    for (; s && s.parentElement; ) {
+      if (s.nodeName === "A")
+        return s;
+      s = s.parentElement;
+    }
+    return null;
+  }
+  function o(r, s) {
+    return n.transact((i) => {
+      const a = i.doc.resolve(r), c = a.marks().find((m) => m.type.name === s);
+      if (!c)
+        return;
+      const l = Be(a, c.type);
+      if (l)
+        return {
+          range: l,
+          mark: c,
+          get text() {
+            return i.doc.textBetween(l.from, l.to);
+          },
+          get position() {
+            return Te(
+              n.prosemirrorView,
+              l.from,
+              l.to
+            ).toJSON();
+          }
+        };
+    });
+  }
+  function t() {
+    return n.transact((r) => {
+      const s = r.selection;
+      if (s.empty)
+        return o(s.anchor, "link");
+    });
+  }
+  return {
+    key: "linkToolbar",
+    getLinkAtSelection: t,
+    getLinkElementAtPos: e,
+    getMarkAtPos: o,
+    getLinkAtElement(r) {
+      return n.transact(() => {
+        const s = n.prosemirrorView.posAtDOM(r, 0) + 1;
+        return o(s, "link");
+      });
+    },
+    editLink(r, s, i = n.transact((a) => a.selection.anchor)) {
+      n.transact((a) => {
+        const c = N(a), { range: l } = o(i + 1, "link") || {
+          range: {
+            from: a.selection.from,
+            to: a.selection.to
+          }
+        };
+        l && (a.insertText(s, l.from, l.to), a.addMark(
+          l.from,
+          l.from + s.length,
+          c.mark("link", { href: r })
+        ));
+      }), n.prosemirrorView.focus();
+    },
+    deleteLink(r = n.transact((s) => s.selection.anchor)) {
+      n.transact((s) => {
+        const i = N(s), { range: a } = o(r + 1, "link") || {
+          range: {
+            from: s.selection.from,
+            to: s.selection.to
+          }
+        };
+        a && s.removeMark(a.from, a.to, i.marks.link).setMeta(
+          "preventAutolink",
+          !0
+        );
+      }), n.prosemirrorView.focus();
+    }
+  };
+}), go = [
+  "http",
+  "https",
+  "ftp",
+  "ftps",
+  "mailto",
+  "tel",
+  "callto",
+  "sms",
+  "cid",
+  "xmpp"
+], wo = "https", Tt = new T("node-selection-keyboard"), yo = k(
+  () => ({
+    key: "nodeSelectionKeyboard",
+    prosemirrorPlugins: [
+      new B({
+        key: Tt,
+        props: {
+          handleKeyDown: (n, e) => {
+            if ("node" in n.state.selection) {
+              if (e.ctrlKey || e.metaKey)
+                return !1;
+              if (e.key.length === 1)
+                return e.preventDefault(), !0;
+              if (e.key === "Enter" && !e.shiftKey && !e.altKey && !e.ctrlKey && !e.metaKey) {
+                const o = n.state.tr;
+                return n.dispatch(
+                  o.insert(
+                    n.state.tr.selection.$to.after(),
+                    n.state.schema.nodes.paragraph.createChecked()
+                  ).setSelection(
+                    new _(
+                      o.doc.resolve(
+                        n.state.tr.selection.$to.after() + 1
+                      )
+                    )
+                  )
+                ), !0;
+              }
+            }
+            return !1;
+          }
+        }
+      })
+    ]
+  })
+), Pt = new T("blocknote-placeholder"), bo = k(
+  ({
+    editor: n,
+    options: e
+  }) => {
+    const o = e.placeholders;
+    return {
+      key: "placeholder",
+      prosemirrorPlugins: [
+        new B({
+          key: Pt,
+          view: (t) => {
+            const r = `placeholder-selector-${Ge()}`;
+            t.dom.classList.add(r);
+            const s = document.createElement("style"), i = n._tiptapEditor.options.injectNonce;
+            i && s.setAttribute("nonce", i), t.root instanceof window.ShadowRoot ? t.root.append(s) : t.root.head.appendChild(s);
+            const a = s.sheet, c = (l = "") => `.${r} .bn-block-content${l} .bn-inline-content:has(> .ProseMirror-trailingBreak:only-child):before`;
+            try {
+              const {
+                default: l,
+                emptyDocument: m,
+                ...h
+              } = o || {};
+              for (const [g, d] of Object.entries(h)) {
+                const p = `[data-content-type="${g}"]`;
+                a.insertRule(
+                  `${c(p)} { content: ${JSON.stringify(
+                    d
+                  )}; }`
+                );
+              }
+              const f = "[data-is-only-empty-block]", u = "[data-is-empty-and-focused]";
+              a.insertRule(
+                `${c(f)} { content: ${JSON.stringify(
+                  m
+                )}; }`
+              ), a.insertRule(
+                `${c(u)} { content: ${JSON.stringify(
+                  l
+                )}; }`
+              );
+            } catch (l) {
+              console.warn(
+                "Failed to insert placeholder CSS rule - this is likely due to the browser not supporting certain CSS pseudo-element selectors (:has, :only-child:, or :before)",
+                l
+              );
+            }
+            return {
+              destroy: () => {
+                t.root instanceof window.ShadowRoot ? t.root.removeChild(s) : t.root.head.removeChild(s);
+              }
+            };
+          },
+          props: {
+            decorations: (t) => {
+              const { doc: r, selection: s } = t;
+              if (!n.isEditable || !s.empty || s.$from.parent.type.spec.code)
+                return;
+              const i = [];
+              t.doc.content.size === 6 && i.push(
+                A.node(2, 4, {
+                  "data-is-only-empty-block": "true"
+                })
+              );
+              const a = s.$anchor, c = a.parent;
+              if (c.content.size === 0) {
+                const l = a.before();
+                i.push(
+                  A.node(l, l + c.nodeSize, {
+                    "data-is-empty-and-focused": "true"
+                  })
+                );
+              }
+              return V.create(r, i);
+            }
+          }
+        })
+      ]
+    };
+  }
+), ne = new T("previous-blocks"), Ot = {
+  // Numbered List Items
+  index: "index",
+  // Headings
+  level: "level",
+  // All Blocks
+  type: "type",
+  depth: "depth",
+  "depth-change": "depth-change"
+}, vo = k(() => {
+  let n;
+  return {
+    key: "previousBlockType",
+    prosemirrorPlugins: [
+      new B({
+        key: ne,
+        view(e) {
+          return {
+            update: async (o, t) => {
+              var r;
+              ((r = this.key) == null ? void 0 : r.getState(o.state).updatedBlocks.size) > 0 && (n = setTimeout(() => {
+                o.dispatch(
+                  o.state.tr.setMeta(ne, { clearUpdate: !0 })
+                );
+              }, 0));
+            },
+            destroy: () => {
+              n && clearTimeout(n);
+            }
+          };
+        },
+        state: {
+          init() {
+            return {
+              // Block attributes, by block ID, from just before the previous transaction.
+              prevTransactionOldBlockAttrs: {},
+              // Block attributes, by block ID, from just before the current transaction.
+              currentTransactionOldBlockAttrs: {},
+              // Set of IDs of blocks whose attributes changed from the current transaction.
+              updatedBlocks: /* @__PURE__ */ new Set()
+            };
+          },
+          apply(e, o, t, r) {
+            if (o.currentTransactionOldBlockAttrs = {}, o.updatedBlocks.clear(), !e.docChanged || t.doc.eq(r.doc))
+              return o;
+            const s = {}, i = j(
+              t.doc,
+              (l) => l.attrs.id
+            ), a = new Map(
+              i.map((l) => [l.node.attrs.id, l])
+            ), c = j(
+              r.doc,
+              (l) => l.attrs.id
+            );
+            for (const l of c) {
+              const m = a.get(l.node.attrs.id), h = m == null ? void 0 : m.node.firstChild, f = l.node.firstChild;
+              if (m && h && f) {
+                const u = {
+                  index: f.attrs.index,
+                  level: f.attrs.level,
+                  type: f.type.name,
+                  depth: r.doc.resolve(l.pos).depth
+                }, g = {
+                  index: h.attrs.index,
+                  level: h.attrs.level,
+                  type: h.type.name,
+                  depth: t.doc.resolve(m.pos).depth
+                };
+                s[l.node.attrs.id] = g, o.currentTransactionOldBlockAttrs[l.node.attrs.id] = g, JSON.stringify(g) !== JSON.stringify(u) && (g["depth-change"] = g.depth - u.depth, o.updatedBlocks.add(l.node.attrs.id));
+              }
+            }
+            return o.prevTransactionOldBlockAttrs = s, o;
+          }
+        },
+        props: {
+          decorations(e) {
+            const o = this.getState(e);
+            if (o.updatedBlocks.size === 0)
+              return;
+            const t = [];
+            return e.doc.descendants((r, s) => {
+              if (!r.attrs.id || !o.updatedBlocks.has(r.attrs.id))
+                return;
+              const i = o.currentTransactionOldBlockAttrs[r.attrs.id], a = {};
+              for (const [l, m] of Object.entries(i))
+                a["data-prev-" + Ot[l]] = m || "none";
+              const c = A.node(s, s + r.nodeSize, {
+                ...a
+              });
+              t.push(c);
+            }), V.create(e.doc, t);
+          }
+        }
+      })
+    ]
+  };
+});
+function Ce(n, e) {
+  var o, t;
+  for (; n && n.parentElement && n.parentElement !== e.dom && ((o = n.getAttribute) == null ? void 0 : o.call(n, "data-node-type")) !== "blockContainer"; )
+    n = n.parentElement;
+  if (((t = n.getAttribute) == null ? void 0 : t.call(n, "data-node-type")) === "blockContainer")
+    return { node: n, id: n.getAttribute("data-id") };
+}
+class P extends L {
+  constructor(o, t) {
+    super(o, t);
+    b(this, "nodes");
+    const r = o.node();
+    this.nodes = [], o.doc.nodesBetween(o.pos, t.pos, (s, i, a) => {
+      if (a !== null && a.eq(r))
+        return this.nodes.push(s), !1;
+    });
+  }
+  static create(o, t, r = t) {
+    return new P(o.resolve(t), o.resolve(r));
+  }
+  content() {
+    return new fe(pe.from(this.nodes), 0, 0);
+  }
+  eq(o) {
+    if (!(o instanceof P) || this.nodes.length !== o.nodes.length || this.from !== o.from || this.to !== o.to)
+      return !1;
+    for (let t = 0; t < this.nodes.length; t++)
+      if (!this.nodes[t].eq(o.nodes[t]))
+        return !1;
+    return !0;
+  }
+  map(o, t) {
+    const r = t.mapResult(this.from), s = t.mapResult(this.to);
+    return s.deleted ? L.near(o.resolve(r.pos)) : r.deleted ? L.near(o.resolve(s.pos)) : new P(
+      o.resolve(r.pos),
+      o.resolve(s.pos)
+    );
+  }
+  toJSON() {
+    return { type: "multiple-node", anchor: this.anchor, head: this.head };
+  }
+}
+L.jsonID("multiple-node", P);
+let x;
+function Dt(n, e) {
+  let o, t;
+  const r = e.resolve(n.from).node().type.spec.group === "blockContent", s = e.resolve(n.to).node().type.spec.group === "blockContent", i = Math.min(n.$anchor.depth, n.$head.depth);
+  if (r && s) {
+    const a = n.$from.start(i - 1), c = n.$to.end(i - 1);
+    o = e.resolve(a - 1).pos, t = e.resolve(c + 1).pos;
+  } else
+    o = n.from, t = n.to;
+  return { from: o, to: t };
+}
+function re(n, e, o = e) {
+  e === o && (o += n.state.doc.resolve(e + 1).node().nodeSize);
+  const t = n.domAtPos(e).node.cloneNode(!0), r = n.domAtPos(e).node, s = (h, f) => Array.prototype.indexOf.call(h.children, f), i = s(
+    r,
+    // Expects from position to be just before the first selected block.
+    n.domAtPos(e + 1).node.parentElement
+  ), a = s(
+    r,
+    // Expects to position to be just after the last selected block.
+    n.domAtPos(o - 1).node.parentElement
+  );
+  for (let h = r.childElementCount - 1; h >= 0; h--)
+    (h > a || h < i) && t.removeChild(t.children[h]);
+  Se(n.root), x = t;
+  const c = x.getElementsByTagName("iframe");
+  for (let h = 0; h < c.length; h++) {
+    const f = c[h], u = f.parentElement;
+    u && u.removeChild(f);
+  }
+  const m = n.dom.className.split(" ").filter(
+    (h) => h !== "ProseMirror" && h !== "bn-root" && h !== "bn-editor"
+  ).join(" ");
+  x.className = x.className + " bn-drag-preview " + m, n.root instanceof ShadowRoot ? n.root.appendChild(x) : n.root.body.appendChild(x);
+}
+function Se(n) {
+  x !== void 0 && (n instanceof ShadowRoot ? n.removeChild(x) : n.body.removeChild(x), x = void 0);
+}
+function At(n, e, o) {
+  if (!n.dataTransfer || o.headless)
+    return;
+  const t = o.prosemirrorView, r = he(e.id, t.state.doc);
+  if (!r)
+    throw new Error(`Block with ID ${e.id} not found`);
+  const s = r.posBeforeNode;
+  if (s != null) {
+    const i = t.state.selection, a = t.state.doc, { from: c, to: l } = Dt(i, a), m = c <= s && s < l, h = i.$anchor.node() !== i.$head.node() || i instanceof P;
+    m && h ? (t.dispatch(
+      t.state.tr.setSelection(P.create(a, c, l))
+    ), re(t, c, l)) : (t.dispatch(
+      t.state.tr.setSelection(le.create(t.state.doc, s))
+    ), re(t, s));
+    const f = t.state.selection.content(), u = o.pmSchema, g = t.serializeForClipboard(f).dom.innerHTML, d = be(u, o), p = St(f.content), w = d.exportBlocks(p, {}), y = ve(w);
+    n.dataTransfer.clearData(), n.dataTransfer.setData("blocknote/html", g), n.dataTransfer.setData("text/html", w), n.dataTransfer.setData("text/plain", y), n.dataTransfer.effectAllowed = "move", n.dataTransfer.setDragImage(x, 0, 0);
+  }
+}
+const se = 250;
+function $(n, e, o = !0) {
+  const t = n.root.elementsFromPoint(e.left, e.top);
+  for (const r of t)
+    if (n.dom.contains(r))
+      return o && r.closest("[data-node-type=columnList]") ? $(
+        n,
+        {
+          // TODO can we do better than this?
+          left: e.left + 50,
+          // bit hacky, but if we're inside a column, offset x position to right to account for the width of sidemenu itself
+          top: e.top
+        },
+        !1
+      ) : Ce(r, n);
+}
+function Mt(n, e) {
+  if (!e.dom.firstChild)
+    return;
+  const o = e.dom.firstChild.getBoundingClientRect(), t = {
+    // Clamps the x position to the editor's bounding box.
+    left: Math.min(
+      Math.max(o.left + 10, n.x),
+      o.right - 10
+    ),
+    top: n.y
+  }, r = $(e, t);
+  if (!r)
+    return;
+  const s = r.node.getBoundingClientRect();
+  return $(
+    e,
+    {
+      left: s.right - 10,
+      top: n.y
+    },
+    !1
+  );
+}
+class Lt {
+  constructor(e, o, t) {
+    b(this, "state");
+    b(this, "emitUpdate");
+    b(this, "mousePos");
+    b(this, "hoveredBlock");
+    b(this, "menuFrozen", !1);
+    b(this, "isDragOrigin", !1);
+    b(this, "updateState", (e) => {
+      this.state = e, this.emitUpdate(this.state);
+    });
+    b(this, "updateStateFromMousePos", () => {
+      var t, r, s, i, a;
+      if (this.menuFrozen || !this.mousePos)
+        return;
+      const e = this.findClosestEditorElement({
+        clientX: this.mousePos.x,
+        clientY: this.mousePos.y
+      });
+      if ((e == null ? void 0 : e.element) !== this.pmView.dom || e.distance > se) {
+        (t = this.state) != null && t.show && (this.state.show = !1, this.updateState(this.state));
+        return;
+      }
+      const o = Mt(this.mousePos, this.pmView);
+      if (!o || !this.editor.isEditable) {
+        (r = this.state) != null && r.show && (this.state.show = !1, this.updateState(this.state));
+        return;
+      }
+      if (!((s = this.state) != null && s.show && ((i = this.hoveredBlock) != null && i.hasAttribute("data-id")) && ((a = this.hoveredBlock) == null ? void 0 : a.getAttribute("data-id")) === o.id) && (this.hoveredBlock = o.node, this.editor.isEditable)) {
+        const c = o.node.getBoundingClientRect(), l = o.node.closest("[data-node-type=column]");
+        this.state = {
+          show: !0,
+          referencePos: new DOMRect(
+            l ? (
+              // We take the first child as column elements have some default
+              // padding. This is a little weird since this child element will
+              // be the first block, but since it's always non-nested and we
+              // only take the x coordinate, it's ok.
+              l.firstElementChild.getBoundingClientRect().x
+            ) : this.pmView.dom.firstChild.getBoundingClientRect().x,
+            c.y,
+            c.width,
+            c.height
+          ),
+          block: this.editor.getBlock(
+            this.hoveredBlock.getAttribute("data-id")
+          )
+        }, this.updateState(this.state);
+      }
+    });
+    /**
+     * If a block is being dragged, ProseMirror usually gets the context of what's
+     * being dragged from `view.dragging`, which is automatically set when a
+     * `dragstart` event fires in the editor. However, if the user tries to drag
+     * and drop blocks between multiple editors, only the one in which the drag
+     * began has that context, so we need to set it on the others manually. This
+     * ensures that PM always drops the blocks in between other blocks, and not
+     * inside them.
+     *
+     * After the `dragstart` event fires on the drag handle, it sets
+     * `blocknote/html` data on the clipboard. This handler fires right after,
+     * parsing the `blocknote/html` data into nodes and setting them on
+     * `view.dragging`.
+     *
+     * Note: Setting `view.dragging` on `dragover` would be better as the user
+     * could then drag between editors in different windows, but you can only
+     * access `dataTransfer` contents on `dragstart` and `drop` events.
+     */
+    b(this, "onDragStart", (e) => {
+      var i;
+      const o = (i = e.dataTransfer) == null ? void 0 : i.getData("blocknote/html");
+      if (!o || this.pmView.dragging)
+        return;
+      const t = document.createElement("div");
+      t.innerHTML = o;
+      const s = Je.fromSchema(this.pmView.state.schema).parse(t, {
+        topNode: this.pmView.state.schema.nodes.blockGroup.create()
+      });
+      this.pmView.dragging = {
+        slice: new fe(s.content, 0, 0),
+        move: !0
+      };
+    });
+    /**
+     * Finds the closest editor visually to the given coordinates
+     */
+    b(this, "findClosestEditorElement", (e) => {
+      const o = Array.from(this.pmView.root.querySelectorAll(".bn-editor"));
+      if (o.length === 0)
+        return null;
+      let t = o[0], r = Number.MAX_VALUE;
+      return o.forEach((s) => {
+        const i = s.querySelector(".bn-block-group").getBoundingClientRect(), a = e.clientX < i.left ? i.left - e.clientX : e.clientX > i.right ? e.clientX - i.right : 0, c = e.clientY < i.top ? i.top - e.clientY : e.clientY > i.bottom ? e.clientY - i.bottom : 0, l = Math.sqrt(
+          Math.pow(a, 2) + Math.pow(c, 2)
+        );
+        l < r && (r = l, t = s);
+      }), {
+        element: t,
+        distance: r
+      };
+    });
+    /**
+     * This dragover event handler listens at the document level,
+     * and is trying to handle dragover events for all editors.
+     *
+     * It specifically is trying to handle the following cases:
+     *  - If the dragover event is within the bounds of any editor, then it does nothing
+     *  - If the dragover event is outside the bounds of any editor, but close enough (within DISTANCE_TO_CONSIDER_EDITOR_BOUNDS) to the closest editor,
+     *    then it dispatches a synthetic dragover event to the closest editor (which will trigger the drop-cursor to be shown on that editor)
+     *  - If the dragover event is outside the bounds of the current editor, then it will dispatch a synthetic dragleave event to the current editor
+     *    (which will trigger the drop-cursor to be removed from the current editor)
+     *
+     * The synthetic event is a necessary evil because we do not control prosemirror-dropcursor to be able to show the drop-cursor within the range we want
+     */
+    b(this, "onDragOver", (e) => {
+      if (e.synthetic)
+        return;
+      const o = this.getDragEventContext(e);
+      if (!o || !o.isDropPoint) {
+        this.closeDropCursor();
+        return;
+      }
+      o.isDropPoint && !o.isDropWithinEditorBounds && this.dispatchSyntheticEvent(e);
+    });
+    /**
+     * Closes the drop-cursor for the current editor
+     */
+    b(this, "closeDropCursor", () => {
+      const e = new Event("dragleave", { bubbles: !1 });
+      e.synthetic = !0, this.pmView.dom.dispatchEvent(e);
+    });
+    /**
+     * It is surprisingly difficult to determine the information we need to know about a drag event
+     *
+     * This function is trying to determine the following:
+     *  - Whether the current editor instance is the drop point
+     *  - Whether the current editor instance is the drag origin
+     *  - Whether the drop event is within the bounds of the current editor instance
+     */
+    b(this, "getDragEventContext", (e) => {
+      var c;
+      const o = !((c = e.dataTransfer) != null && c.types.includes("blocknote/html")) && !!this.pmView.dragging, t = !!this.isDragOrigin, r = o || t, s = this.findClosestEditorElement(e);
+      if (!s || s.distance > se)
+        return;
+      const i = s.element === this.pmView.dom, a = i && s.distance === 0;
+      if (!(!i && !r))
+        return {
+          isDropPoint: i,
+          isDropWithinEditorBounds: a,
+          isDragOrigin: r
+        };
+    });
+    /**
+     * The drop event handler listens at the document level,
+     * and handles drop events for all editors.
+     *
+     * It specifically handles the following cases:
+     *  - If we are both the drag origin and drop point:
+     *    - Let normal drop handling take over
+     *  - If we are the drop point but not the drag origin:
+     *    - Collapse selection to prevent PM from deleting unrelated content
+     *    - If drop event is outside our editor bounds, dispatch synthetic drop event to our editor
+     *  - If we are the drag origin but not the drop point:
+     *    - Delete the dragged content from our editor after a delay
+     */
+    b(this, "onDrop", (e) => {
+      if (e.synthetic)
+        return;
+      const o = this.getDragEventContext(e);
+      if (!o) {
+        this.closeDropCursor();
+        return;
+      }
+      const { isDropPoint: t, isDropWithinEditorBounds: r, isDragOrigin: s } = o;
+      if (!r && t && this.dispatchSyntheticEvent(e), t) {
+        if (this.pmView.dragging)
+          return;
+        this.pmView.dispatch(
+          this.pmView.state.tr.setSelection(
+            _.create(
+              this.pmView.state.tr.doc,
+              this.pmView.state.tr.selection.anchor
+            )
+          )
+        );
+        return;
+      } else if (s) {
+        setTimeout(
+          () => this.pmView.dispatch(this.pmView.state.tr.deleteSelection()),
+          0
+        );
+        return;
+      }
+    });
+    b(this, "onDragEnd", (e) => {
+      e.synthetic || (this.pmView.dragging = null);
+    });
+    b(this, "onKeyDown", (e) => {
+      var o;
+      (o = this.state) != null && o.show && this.editor.isFocused() && (this.state.show = !1, this.emitUpdate(this.state));
+    });
+    b(this, "onMouseMove", (e) => {
+      var s;
+      if (this.menuFrozen)
+        return;
+      this.mousePos = { x: e.clientX, y: e.clientY };
+      const o = this.pmView.dom.getBoundingClientRect(), t = this.mousePos.x > o.left && this.mousePos.x < o.right && this.mousePos.y > o.top && this.mousePos.y < o.bottom, r = this.pmView.dom.parentElement;
+      if (
+        // Cursor is within the editor area
+        t && // An element is hovered
+        e && e.target && // Element is outside the editor
+        !(r === e.target || r.contains(e.target))
+      ) {
+        (s = this.state) != null && s.show && (this.state.show = !1, this.emitUpdate(this.state));
+        return;
+      }
+      this.updateStateFromMousePos();
+    });
+    this.editor = e, this.pmView = o, this.emitUpdate = () => {
+      if (!this.state)
+        throw new Error("Attempting to update uninitialized side menu");
+      t(this.state);
+    }, this.pmView.root.addEventListener(
+      "dragstart",
+      this.onDragStart
+    ), this.pmView.root.addEventListener(
+      "dragover",
+      this.onDragOver
+    ), this.pmView.root.addEventListener(
+      "drop",
+      this.onDrop,
+      !0
+    ), this.pmView.root.addEventListener(
+      "dragend",
+      this.onDragEnd,
+      !0
+    ), this.pmView.root.addEventListener(
+      "mousemove",
+      this.onMouseMove,
+      !0
+    ), this.pmView.root.addEventListener(
+      "keydown",
+      this.onKeyDown,
+      !0
+    );
+  }
+  dispatchSyntheticEvent(e) {
+    const o = new Event(e.type, e), t = this.pmView.dom.firstChild.getBoundingClientRect();
+    o.clientX = e.clientX, o.clientY = e.clientY, o.clientX = Math.min(
+      Math.max(e.clientX, t.left),
+      t.left + t.width
+    ), o.clientY = Math.min(
+      Math.max(e.clientY, t.top),
+      t.top + t.height
+    ), o.dataTransfer = e.dataTransfer, o.preventDefault = () => e.preventDefault(), o.synthetic = !0, this.pmView.dom.dispatchEvent(o);
+  }
+  // Needed in cases where the editor state updates without the mouse cursor
+  // moving, as some state updates can require a side menu update. For example,
+  // adding a button to the side menu which removes the block can cause the
+  // block below to jump up into the place of the removed block when clicked,
+  // allowing the user to click the button again without moving the cursor. This
+  // would otherwise not update the side menu, and so clicking the button again
+  // would attempt to remove the same block again, causing an error.
+  update(e, o) {
+    var r;
+    !o.doc.eq(this.pmView.state.doc) && ((r = this.state) != null && r.show) && this.updateStateFromMousePos();
+  }
+  destroy() {
+    var e;
+    (e = this.state) != null && e.show && (this.state.show = !1, this.emitUpdate(this.state)), this.pmView.root.removeEventListener(
+      "mousemove",
+      this.onMouseMove,
+      !0
+    ), this.pmView.root.removeEventListener(
+      "dragstart",
+      this.onDragStart
+    ), this.pmView.root.removeEventListener(
+      "dragover",
+      this.onDragOver
+    ), this.pmView.root.removeEventListener(
+      "drop",
+      this.onDrop,
+      !0
+    ), this.pmView.root.removeEventListener(
+      "dragend",
+      this.onDragEnd,
+      !0
+    ), this.pmView.root.removeEventListener(
+      "keydown",
+      this.onKeyDown,
+      !0
+    );
+  }
+}
+const Nt = new T("SideMenuPlugin"), ko = k(({ editor: n }) => {
+  let e;
+  const o = H(
+    void 0
+  );
+  return {
+    key: "sideMenu",
+    store: o,
+    prosemirrorPlugins: [
+      new B({
+        key: Nt,
+        view: (t) => (e = new Lt(n, t, (r) => {
+          o.setState({ ...r });
+        }), e)
+      })
+    ],
+    /**
+     * Handles drag & drop events for blocks.
+     */
+    blockDragStart(t, r) {
+      e && (e.isDragOrigin = !0), At(t, r, n);
+    },
+    /**
+     * Handles drag & drop events for blocks.
+     */
+    blockDragEnd() {
+      Se(n.prosemirrorView.root), e && (e.isDragOrigin = !1), n.blur();
+    },
+    /**
+     * Freezes the side menu. When frozen, the side menu will stay
+     * attached to the same block regardless of which block is hovered by the
+     * mouse cursor.
+     */
+    freezeMenu() {
+      e.menuFrozen = !0, e.state.show = !0, e.emitUpdate(e.state);
+    },
+    /**
+     * Unfreezes the side menu. When frozen, the side menu will stay
+     * attached to the same block regardless of which block is hovered by the
+     * mouse cursor.
+     */
+    unfreezeMenu() {
+      e.menuFrozen = !1, e.state.show = !1, e.emitUpdate(e.state);
+    }
+  };
+});
+let C;
+function ie(n) {
+  C || (C = document.createElement("div"), C.innerHTML = "_", C.style.opacity = "0", C.style.height = "1px", C.style.width = "1px", n instanceof Document ? n.body.appendChild(C) : n.appendChild(C));
+}
+function Rt(n) {
+  C && (n instanceof Document ? n.body.removeChild(C) : n.removeChild(C), C = void 0);
+}
+function M(n) {
+  return Array.prototype.indexOf.call(n.parentElement.childNodes, n);
+}
+function Vt(n) {
+  let e = n;
+  for (; e && e.nodeName !== "TD" && e.nodeName !== "TH" && !e.classList.contains("tableWrapper"); ) {
+    if (e.classList.contains("ProseMirror"))
+      return;
+    const o = e.parentNode;
+    if (!o || !(o instanceof Element))
+      return;
+    e = o;
+  }
+  return e.nodeName === "TD" || e.nodeName === "TH" ? {
+    type: "cell",
+    domNode: e,
+    tbodyNode: e.closest("tbody")
+  } : {
+    type: "wrapper",
+    domNode: e,
+    tbodyNode: e.querySelector("tbody")
+  };
+}
+function Ht(n, e) {
+  const o = e.querySelectorAll(n);
+  for (let t = 0; t < o.length; t++)
+    o[t].style.visibility = "hidden";
+}
+class Ft {
+  constructor(e, o, t) {
+    b(this, "state");
+    b(this, "emitUpdate");
+    b(this, "tableId");
+    b(this, "tablePos");
+    b(this, "tableElement");
+    b(this, "menuFrozen", !1);
+    b(this, "mouseState", "up");
+    b(this, "prevWasEditable", null);
+    b(this, "viewMousedownHandler", () => {
+      this.mouseState = "down";
+    });
+    b(this, "mouseUpHandler", (e) => {
+      this.mouseState = "up", this.mouseMoveHandler(e);
+    });
+    b(this, "mouseMoveHandler", (e) => {
+      var l, m, h, f, u, g, d;
+      if (this.menuFrozen || this.mouseState === "selecting" || !(e.target instanceof Element) || !this.pmView.dom.contains(e.target))
+        return;
+      const o = Vt(e.target);
+      if ((o == null ? void 0 : o.type) === "cell" && this.mouseState === "down" && !((l = this.state) != null && l.draggingState)) {
+        this.mouseState = "selecting", (m = this.state) != null && m.show && (this.state.show = !1, this.state.showAddOrRemoveRowsButton = !1, this.state.showAddOrRemoveColumnsButton = !1, this.emitUpdate());
+        return;
+      }
+      if (!o || !this.editor.isEditable) {
+        (h = this.state) != null && h.show && (this.state.show = !1, this.state.showAddOrRemoveRowsButton = !1, this.state.showAddOrRemoveColumnsButton = !1, this.emitUpdate());
+        return;
+      }
+      if (!o.tbodyNode)
+        return;
+      const t = o.tbodyNode.getBoundingClientRect(), r = Ce(o.domNode, this.pmView);
+      if (!r)
+        return;
+      this.tableElement = r.node;
+      let s;
+      const i = this.editor.transact(
+        (p) => he(r.id, p.doc)
+      );
+      if (!i)
+        throw new Error(`Block with ID ${r.id} not found`);
+      const a = R(
+        i.node,
+        this.editor.pmSchema,
+        this.editor.schema.blockSchema,
+        this.editor.schema.inlineContentSchema,
+        this.editor.schema.styleSchema
+      );
+      if (Fe(this.editor, "table") && (this.tablePos = i.posBeforeNode + 1, s = a), !s)
+        return;
+      this.tableId = r.id;
+      const c = (f = o.domNode.closest(".tableWrapper")) == null ? void 0 : f.querySelector(".table-widgets-container");
+      if ((o == null ? void 0 : o.type) === "wrapper") {
+        const p = e.clientY >= t.bottom - 1 && // -1 to account for fractions of pixels in "bottom"
+        e.clientY < t.bottom + 20, w = e.clientX >= t.right - 1 && e.clientX < t.right + 20, y = e.clientX > t.right || e.clientY > t.bottom;
+        this.state = {
+          ...this.state,
+          show: !0,
+          showAddOrRemoveRowsButton: p,
+          showAddOrRemoveColumnsButton: w,
+          referencePosTable: t,
+          block: s,
+          widgetContainer: c,
+          colIndex: y || (u = this.state) == null ? void 0 : u.colIndex,
+          rowIndex: y || (g = this.state) == null ? void 0 : g.rowIndex,
+          referencePosCell: y || (d = this.state) == null ? void 0 : d.referencePosCell
+        };
+      } else {
+        const p = M(o.domNode), w = M(o.domNode.parentElement), y = o.domNode.getBoundingClientRect();
+        if (this.state !== void 0 && this.state.show && this.tableId === r.id && this.state.rowIndex === w && this.state.colIndex === p)
+          return;
+        this.state = {
+          show: !0,
+          showAddOrRemoveColumnsButton: p === s.content.rows[0].cells.length - 1,
+          showAddOrRemoveRowsButton: w === s.content.rows.length - 1,
+          referencePosTable: t,
+          block: s,
+          draggingState: void 0,
+          referencePosCell: y,
+          colIndex: p,
+          rowIndex: w,
+          widgetContainer: c
+        };
+      }
+      return this.emitUpdate(), !1;
+    });
+    b(this, "dragOverHandler", (e) => {
+      var f;
+      if (((f = this.state) == null ? void 0 : f.draggingState) === void 0)
+        return;
+      e.preventDefault(), e.dataTransfer.dropEffect = "move", Ht(
+        ".prosemirror-dropcursor-block, .prosemirror-dropcursor-inline",
+        this.pmView.root
+      );
+      const o = {
+        left: Math.min(
+          Math.max(e.clientX, this.state.referencePosTable.left + 1),
+          this.state.referencePosTable.right - 1
+        ),
+        top: Math.min(
+          Math.max(e.clientY, this.state.referencePosTable.top + 1),
+          this.state.referencePosTable.bottom - 1
+        )
+      }, t = this.pmView.root.elementsFromPoint(o.left, o.top).filter(
+        (u) => u.tagName === "TD" || u.tagName === "TH"
+      );
+      if (t.length === 0)
+        return;
+      const r = t[0];
+      let s = !1;
+      const i = M(r.parentElement), a = M(r), c = this.state.draggingState.draggedCellOrientation === "row" ? this.state.rowIndex : this.state.colIndex, m = (this.state.draggingState.draggedCellOrientation === "row" ? i : a) !== c;
+      (this.state.rowIndex !== i || this.state.colIndex !== a) && (this.state.rowIndex = i, this.state.colIndex = a, this.state.referencePosCell = r.getBoundingClientRect(), s = !0);
+      const h = this.state.draggingState.draggedCellOrientation === "row" ? o.top : o.left;
+      this.state.draggingState.mousePos !== h && (this.state.draggingState.mousePos = h, s = !0), s && this.emitUpdate(), m && this.editor.transact((u) => u.setMeta(D, !0));
+    });
+    b(this, "dropHandler", (e) => {
+      if (this.mouseState = "up", this.state === void 0 || this.state.draggingState === void 0)
+        return !1;
+      if (this.state.rowIndex === void 0 || this.state.colIndex === void 0)
+        throw new Error(
+          "Attempted to drop table row or column, but no table block was hovered prior."
+        );
+      e.preventDefault();
+      const { draggingState: o, colIndex: t, rowIndex: r } = this.state, s = this.state.block.content.columnWidths;
+      if (o.draggedCellOrientation === "row") {
+        if (!ce(
+          this.state.block,
+          o.originalIndex,
+          r
+        ))
+          return !1;
+        const i = Me(
+          this.state.block,
+          o.originalIndex,
+          r
+        );
+        this.editor.updateBlock(this.state.block, {
+          type: "table",
+          content: {
+            ...this.state.block.content,
+            rows: i
+          }
+        });
+      } else {
+        if (!de(
+          this.state.block,
+          o.originalIndex,
+          t
+        ))
+          return !1;
+        const i = Le(
+          this.state.block,
+          o.originalIndex,
+          t
+        ), [a] = s.splice(o.originalIndex, 1);
+        s.splice(t, 0, a), this.editor.updateBlock(this.state.block, {
+          type: "table",
+          content: {
+            ...this.state.block.content,
+            columnWidths: s,
+            rows: i
+          }
+        });
+      }
+      return this.editor.setTextCursorPosition(this.state.block.id), !0;
+    });
+    this.editor = e, this.pmView = o, this.emitUpdate = () => {
+      if (!this.state)
+        throw new Error("Attempting to update uninitialized image toolbar");
+      t(this.state);
+    }, o.dom.addEventListener("mousemove", this.mouseMoveHandler), o.dom.addEventListener("mousedown", this.viewMousedownHandler), window.addEventListener("mouseup", this.mouseUpHandler), o.root.addEventListener(
+      "dragover",
+      this.dragOverHandler
+    ), o.root.addEventListener(
+      "drop",
+      this.dropHandler
+    );
+  }
+  // Updates drag handles when the table is modified or removed.
+  update() {
+    var r;
+    if (!this.state || !this.state.show)
+      return;
+    if (this.state.block = this.editor.getBlock(this.state.block.id), !this.state.block || this.state.block.type !== "table" || // when collaborating, the table element might be replaced and out of date
+    // because yjs replaces the element when for example you change the color via the side menu
+    !((r = this.tableElement) != null && r.isConnected)) {
+      this.state.show = !1, this.state.showAddOrRemoveRowsButton = !1, this.state.showAddOrRemoveColumnsButton = !1, this.emitUpdate();
+      return;
+    }
+    const { height: e, width: o } = Ne(
+      this.state.block
+    );
+    this.state.rowIndex !== void 0 && this.state.colIndex !== void 0 && (this.state.rowIndex >= e && (this.state.rowIndex = e - 1), this.state.colIndex >= o && (this.state.colIndex = o - 1));
+    const t = this.tableElement.querySelector("tbody");
+    if (!t)
+      throw new Error(
+        "Table block does not contain a 'tbody' HTML element. This should never happen."
+      );
+    if (this.state.rowIndex !== void 0 && this.state.colIndex !== void 0) {
+      const i = t.children[this.state.rowIndex].children[this.state.colIndex];
+      i ? this.state.referencePosCell = i.getBoundingClientRect() : (this.state.rowIndex = void 0, this.state.colIndex = void 0);
+    }
+    this.state.referencePosTable = t.getBoundingClientRect(), this.emitUpdate();
+  }
+  destroy() {
+    this.pmView.dom.removeEventListener("mousemove", this.mouseMoveHandler), window.removeEventListener("mouseup", this.mouseUpHandler), this.pmView.dom.removeEventListener("mousedown", this.viewMousedownHandler), this.pmView.root.removeEventListener(
+      "dragover",
+      this.dragOverHandler
+    ), this.pmView.root.removeEventListener(
+      "drop",
+      this.dropHandler
+    );
+  }
+}
+const D = new T("TableHandlesPlugin"), Co = k(({ editor: n }) => {
+  let e;
+  const o = H(void 0);
+  return {
+    key: "tableHandles",
+    store: o,
+    prosemirrorPlugins: [
+      new B({
+        key: D,
+        view: (t) => (e = new Ft(n, t, (r) => {
+          o.setState({
+            ...r,
+            draggingState: r.draggingState ? { ...r.draggingState } : void 0
+          });
+        }), e),
+        // We use decorations to render the drop cursor when dragging a table row
+        // or column. The decorations are updated in the `dragOverHandler` method.
+        props: {
+          decorations: (t) => {
+            if (e === void 0 || e.state === void 0 || e.state.draggingState === void 0 || e.tablePos === void 0)
+              return;
+            const r = e.state.draggingState.draggedCellOrientation === "row" ? e.state.rowIndex : e.state.colIndex;
+            if (r === void 0)
+              return;
+            const s = [], { block: i, draggingState: a } = e.state, { originalIndex: c, draggedCellOrientation: l } = a;
+            if (r === c || !i || l === "row" && !ce(i, c, r) || l === "col" && !de(i, c, r))
+              return V.create(t.doc, s);
+            const m = t.doc.resolve(e.tablePos + 1);
+            return e.state.draggingState.draggedCellOrientation === "row" ? G(
+              e.state.block,
+              r
+            ).forEach(({ row: f, col: u }) => {
+              const g = t.doc.resolve(
+                m.posAtIndex(f) + 1
+              ), d = t.doc.resolve(
+                g.posAtIndex(u) + 1
+              ), p = d.node(), w = d.pos + (r > c ? p.nodeSize - 2 : 0);
+              s.push(
+                // The widget is a small bar which spans the width of the cell.
+                A.widget(w, () => {
+                  const y = document.createElement("div");
+                  return y.className = "bn-table-drop-cursor", y.style.left = "0", y.style.right = "0", r > c ? y.style.bottom = "-2px" : y.style.top = "-3px", y.style.height = "4px", y;
+                })
+              );
+            }) : W(
+              e.state.block,
+              r
+            ).forEach(({ row: f, col: u }) => {
+              const g = t.doc.resolve(
+                m.posAtIndex(f) + 1
+              ), d = t.doc.resolve(
+                g.posAtIndex(u) + 1
+              ), p = d.node(), w = d.pos + (r > c ? p.nodeSize - 2 : 0);
+              s.push(
+                // The widget is a small bar which spans the height of the cell.
+                A.widget(w, () => {
+                  const y = document.createElement("div");
+                  return y.className = "bn-table-drop-cursor", y.style.top = "0", y.style.bottom = "0", r > c ? y.style.right = "-2px" : y.style.left = "-3px", y.style.width = "4px", y;
+                })
+              );
+            }), V.create(t.doc, s);
+          }
+        }
+      })
+    ],
+    /**
+     * Callback that should be set on the `dragStart` event for whichever element
+     * is used as the column drag handle.
+     */
+    colDragStart(t) {
+      if (e === void 0 || e.state === void 0 || e.state.colIndex === void 0)
+        throw new Error(
+          "Attempted to drag table column, but no table block was hovered prior."
+        );
+      e.state.draggingState = {
+        draggedCellOrientation: "col",
+        originalIndex: e.state.colIndex,
+        mousePos: t.clientX
+      }, e.emitUpdate(), n.transact(
+        (r) => r.setMeta(D, {
+          draggedCellOrientation: e.state.draggingState.draggedCellOrientation,
+          originalIndex: e.state.colIndex,
+          newIndex: e.state.colIndex,
+          tablePos: e.tablePos
+        })
+      ), !n.headless && (ie(n.prosemirrorView.root), t.dataTransfer.setDragImage(C, 0, 0), t.dataTransfer.effectAllowed = "move");
+    },
+    /**
+     * Callback that should be set on the `dragStart` event for whichever element
+     * is used as the row drag handle.
+     */
+    rowDragStart(t) {
+      if (e.state === void 0 || e.state.rowIndex === void 0)
+        throw new Error(
+          "Attempted to drag table row, but no table block was hovered prior."
+        );
+      e.state.draggingState = {
+        draggedCellOrientation: "row",
+        originalIndex: e.state.rowIndex,
+        mousePos: t.clientY
+      }, e.emitUpdate(), n.transact(
+        (r) => r.setMeta(D, {
+          draggedCellOrientation: e.state.draggingState.draggedCellOrientation,
+          originalIndex: e.state.rowIndex,
+          newIndex: e.state.rowIndex,
+          tablePos: e.tablePos
+        })
+      ), !n.headless && (ie(n.prosemirrorView.root), t.dataTransfer.setDragImage(C, 0, 0), t.dataTransfer.effectAllowed = "copyMove");
+    },
+    /**
+     * Callback that should be set on the `dragEnd` event for both the element
+     * used as the row drag handle, and the one used as the column drag handle.
+     */
+    dragEnd() {
+      if (e.state === void 0)
+        throw new Error(
+          "Attempted to drag table row, but no table block was hovered prior."
+        );
+      e.state.draggingState = void 0, e.emitUpdate(), n.transact((t) => t.setMeta(D, null)), !n.headless && Rt(n.prosemirrorView.root);
+    },
+    /**
+     * Freezes the drag handles. When frozen, they will stay attached to the same
+     * cell regardless of which cell is hovered by the mouse cursor.
+     */
+    freezeHandles() {
+      e.menuFrozen = !0;
+    },
+    /**
+     * Unfreezes the drag handles. When frozen, they will stay attached to the
+     * same cell regardless of which cell is hovered by the mouse cursor.
+     */
+    unfreezeHandles() {
+      e.menuFrozen = !1;
+    },
+    getCellsAtRowHandle(t, r) {
+      return G(t, r);
+    },
+    /**
+     * Get all the cells in a column of the table block.
+     */
+    getCellsAtColumnHandle(t, r) {
+      return W(t, r);
+    },
+    /**
+     * Sets the selection to the given cell or a range of cells.
+     * @returns The new state after the selection has been set.
+     */
+    setCellSelection(t, r, s = r) {
+      if (!e)
+        throw new Error("Table handles view not initialized");
+      const i = t.doc.resolve(e.tablePos + 1), a = t.doc.resolve(
+        i.posAtIndex(r.row) + 1
+      ), c = t.doc.resolve(
+        // No need for +1, since CellSelection expects the position before the cell
+        a.posAtIndex(r.col)
+      ), l = t.doc.resolve(
+        i.posAtIndex(s.row) + 1
+      ), m = t.doc.resolve(
+        // No need for +1, since CellSelection expects the position before the cell
+        l.posAtIndex(s.col)
+      ), h = t.tr;
+      return h.setSelection(
+        new mt(c, m)
+      ), t.apply(h);
+    },
+    /**
+     * Adds a row or column to the table using prosemirror-table commands
+     */
+    addRowOrColumn(t, r) {
+      n.exec((s, i) => {
+        const a = this.setCellSelection(
+          s,
+          r.orientation === "row" ? { row: t, col: 0 } : { row: 0, col: t }
+        );
+        return r.orientation === "row" ? r.side === "above" ? ct(a, i) : dt(a, i) : r.side === "left" ? ut(a, i) : ht(a, i);
+      });
+    },
+    /**
+     * Removes a row or column from the table using prosemirror-table commands
+     */
+    removeRowOrColumn(t, r) {
+      return r === "row" ? n.exec((s, i) => {
+        const a = this.setCellSelection(s, {
+          row: t,
+          col: 0
+        });
+        return at(a, i);
+      }) : n.exec((s, i) => {
+        const a = this.setCellSelection(s, {
+          row: 0,
+          col: t
+        });
+        return lt(a, i);
+      });
+    },
+    /**
+     * Merges the cells in the table block.
+     */
+    mergeCells(t) {
+      return n.exec((r, s) => {
+        const i = t ? this.setCellSelection(
+          r,
+          t.relativeStartCell,
+          t.relativeEndCell
+        ) : r;
+        return it(i, s);
+      });
+    },
+    /**
+     * Splits the cell in the table block.
+     * If no cell is provided, the current cell selected will be split.
+     */
+    splitCell(t) {
+      return n.exec((r, s) => {
+        const i = t ? this.setCellSelection(r, t) : r;
+        return st(i, s);
+      });
+    },
+    /**
+     * Gets the start and end cells of the current cell selection.
+     * @returns The start and end cells of the current cell selection.
+     */
+    getCellSelection() {
+      return n.transact((t) => {
+        const r = t.selection;
+        let s = r.$from, i = r.$to;
+        if (Q(r)) {
+          const { ranges: d } = r;
+          d.forEach((p) => {
+            s = p.$from.min(s ?? p.$from), i = p.$to.max(i ?? p.$to);
+          });
+        } else if (s = t.doc.resolve(
+          r.$from.pos - r.$from.parentOffset - 1
+        ), i = t.doc.resolve(
+          r.$to.pos - r.$to.parentOffset - 1
+        ), s.pos === 0 || i.pos === 0)
+          return;
+        const a = t.doc.resolve(
+          s.pos - s.parentOffset - 1
+        ), c = t.doc.resolve(i.pos - i.parentOffset - 1), l = t.doc.resolve(a.pos - a.parentOffset - 1), m = s.index(a.depth), h = a.index(l.depth), f = i.index(c.depth), u = c.index(l.depth), g = [];
+        for (let d = h; d <= u; d++)
+          for (let p = m; p <= f; p++)
+            g.push({ row: d, col: p });
+        return {
+          from: {
+            row: h,
+            col: m
+          },
+          to: {
+            row: u,
+            col: f
+          },
+          cells: g
+        };
+      });
+    },
+    /**
+     * Gets the direction of the merge based on the current cell selection.
+     *
+     * Returns undefined when there is no cell selection, or the selection is not within a table.
+     */
+    getMergeDirection(t) {
+      return n.transact((r) => {
+        const s = Q(r.selection) ? r.selection : void 0;
+        if (!s || !t || // Only offer the merge button if there is more than one cell selected.
+        s.ranges.length <= 1)
+          return;
+        const i = this.getCellSelection();
+        if (i)
+          return He(i.from, i.to, t) ? "vertical" : "horizontal";
+      });
+    },
+    cropEmptyRowsOrColumns(t, r) {
+      return Ve(t, r);
+    },
+    addRowsOrColumns(t, r, s) {
+      return Re(t, r, s);
+    }
+  };
+}), ae = new T("trailingNode"), So = k(() => ({
+  key: "trailingNode",
+  prosemirrorPlugins: [
+    new B({
+      key: ae,
+      appendTransaction: (n, e, o) => {
+        const { doc: t, tr: r, schema: s } = o, i = ae.getState(o), a = t.content.size - 2, c = s.nodes.blockContainer, l = s.nodes.paragraph;
+        if (i)
+          return r.insert(
+            a,
+            c.create(void 0, l.create())
+          );
+      },
+      state: {
+        init: (n, e) => {
+        },
+        apply: (n, e) => {
+          if (!n.docChanged)
+            return e;
+          let o = n.doc.lastChild;
+          if (!o || o.type.name !== "blockGroup")
+            throw new Error("Expected blockGroup");
+          if (o = o.lastChild, !o || o.type.name !== "blockContainer")
+            return !0;
+          const t = o.firstChild;
+          if (!t)
+            throw new Error("Expected blockContent");
+          return o.nodeSize > 4 || t.type.spec.content !== "inline*";
+        }
+      }
+    })
+  ]
+}));
+export {
+  lo as B,
+  ho as D,
+  co as F,
+  po as H,
+  fo as L,
+  yo as N,
+  bo as P,
+  uo as S,
+  Ft as T,
+  go as V,
+  oe as Y,
+  F as a,
+  U as b,
+  mo as c,
+  wo as d,
+  vo as e,
+  Lt as f,
+  ko as g,
+  Co as h,
+  So as i,
+  bt as j,
+  be as k,
+  ao as l,
+  ve as m,
+  St as n,
+  Nt as s,
+  D as t
+};
+//# sourceMappingURL=TrailingNode-BUhuMJrB.js.map