@blocknote/core 0.41.1 → 0.42.0

package/dist/blockToNode-DIfPWLH8.js

@@ -0,0 +1,1140 @@
+import { Extension as ot, combineTransactionSteps as rt, getChangedRanges as st, findChildrenInRange as it } from "@tiptap/core";
+import { Slice as lt, Fragment as at } from "prosemirror-model";
+import { Plugin as ct, PluginKey as ft } from "prosemirror-state";
+import { v4 as ut } from "uuid";
+function pt(t, o = JSON.stringify) {
+  const r = {};
+  return t.filter((n) => {
+    const e = o(n);
+    return Object.prototype.hasOwnProperty.call(r, e) ? !1 : r[e] = !0;
+  });
+}
+function dt(t) {
+  const o = t.filter(
+    (n, e) => t.indexOf(n) !== e
+  );
+  return pt(o);
+}
+const Q = ot.create({
+  name: "uniqueID",
+  // we’ll set a very high priority to make sure this runs first
+  // and is compatible with `appendTransaction` hooks of other extensions
+  priority: 1e4,
+  addOptions() {
+    return {
+      attributeName: "id",
+      types: [],
+      setIdAttribute: !1,
+      generateID: () => {
+        if (typeof window < "u" && window.__TEST_OPTIONS) {
+          const t = window.__TEST_OPTIONS;
+          return t.mockID === void 0 ? t.mockID = 0 : t.mockID++, t.mockID.toString();
+        }
+        return ut();
+      },
+      filterTransaction: null
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          [this.options.attributeName]: {
+            default: null,
+            parseHTML: (t) => t.getAttribute(`data-${this.options.attributeName}`),
+            renderHTML: (t) => {
+              const o = {
+                [`data-${this.options.attributeName}`]: t[this.options.attributeName]
+              };
+              return this.options.setIdAttribute ? {
+                ...o,
+                id: t[this.options.attributeName]
+              } : o;
+            }
+          }
+        }
+      }
+    ];
+  },
+  // check initial content for missing ids
+  // onCreate() {
+  //   // Don’t do this when the collaboration extension is active
+  //   // because this may update the content, so Y.js tries to merge these changes.
+  //   // This leads to empty block nodes.
+  //   // See: https://github.com/ueberdosis/tiptap/issues/2400
+  //   if (
+  //     this.editor.extensionManager.extensions.find(
+  //       (extension) => extension.name === "collaboration"
+  //     )
+  //   ) {
+  //     return;
+  //   }
+  //   const { view, state } = this.editor;
+  //   const { tr, doc } = state;
+  //   const { types, attributeName, generateID } = this.options;
+  //   const nodesWithoutId = findChildren(doc, (node) => {
+  //     return (
+  //       types.includes(node.type.name) && node.attrs[attributeName] === null
+  //     );
+  //   });
+  //   nodesWithoutId.forEach(({ node, pos }) => {
+  //     tr.setNodeMarkup(pos, undefined, {
+  //       ...node.attrs,
+  //       [attributeName]: generateID(),
+  //     });
+  //   });
+  //   tr.setMeta("addToHistory", false);
+  //   view.dispatch(tr);
+  // },
+  addProseMirrorPlugins() {
+    let t = null, o = !1;
+    return [
+      new ct({
+        key: new ft("uniqueID"),
+        appendTransaction: (r, n, e) => {
+          const s = r.some((g) => g.docChanged) && !n.doc.eq(e.doc), i = this.options.filterTransaction && r.some((g) => {
+            var C, d;
+            return !((d = (C = this.options).filterTransaction) != null && d.call(C, g));
+          });
+          if (!s || i)
+            return;
+          const { tr: l } = e, { types: a, attributeName: c, generateID: h } = this.options, f = rt(
+            n.doc,
+            r
+          ), { mapping: p } = f;
+          if (st(f).forEach(({ newRange: g }) => {
+            const C = it(
+              e.doc,
+              g,
+              (y) => a.includes(y.type.name)
+            ), d = C.map(({ node: y }) => y.attrs[c]).filter((y) => y !== null), w = dt(d);
+            C.forEach(({ node: y, pos: m }) => {
+              var z;
+              const b = (z = l.doc.nodeAt(m)) == null ? void 0 : z.attrs[c];
+              if (b === null) {
+                const U = n.doc.type.createAndFill().content;
+                if (n.doc.content.findDiffStart(U) === null) {
+                  const q = JSON.parse(
+                    JSON.stringify(e.doc.toJSON())
+                  );
+                  if (q.content[0].content[0].attrs.id = "initialBlockId", JSON.stringify(q.content) === JSON.stringify(U.toJSON())) {
+                    l.setNodeMarkup(m, void 0, {
+                      ...y.attrs,
+                      [c]: "initialBlockId"
+                    });
+                    return;
+                  }
+                }
+                l.setNodeMarkup(m, void 0, {
+                  ...y.attrs,
+                  [c]: h()
+                });
+                return;
+              }
+              const { deleted: k } = p.invert().mapResult(m);
+              k && w.includes(b) && l.setNodeMarkup(m, void 0, {
+                ...y.attrs,
+                [c]: h()
+              });
+            });
+          }), !!l.steps.length)
+            return l.setMeta("uniqueID", !0), l;
+        },
+        // we register a global drag handler to track the current drag source element
+        view(r) {
+          const n = (e) => {
+            let s;
+            t = !((s = r.dom.parentElement) === null || s === void 0) && s.contains(e.target) ? r.dom.parentElement : null;
+          };
+          return window.addEventListener("dragstart", n), {
+            destroy() {
+              window.removeEventListener("dragstart", n);
+            }
+          };
+        },
+        props: {
+          // `handleDOMEvents` is called before `transformPasted` so we can do
+          // some checks before. However, `transformPasted` only runs when
+          // editor content is pasted - not external content.
+          handleDOMEvents: {
+            // only create new ids for dropped content while holding `alt`
+            // or content is dragged from another editor
+            drop: (r, n) => {
+              let e;
+              return t !== r.dom.parentElement || ((e = n.dataTransfer) === null || e === void 0 ? void 0 : e.effectAllowed) === "copy" ? o = !0 : o = !1, t = null, !1;
+            },
+            // always create new ids on pasted content
+            paste: () => (o = !0, !1)
+          },
+          // we’ll remove ids for every pasted node
+          // so we can create a new one within `appendTransaction`
+          transformPasted: (r) => {
+            if (!o)
+              return r;
+            const { types: n, attributeName: e } = this.options, s = (i) => {
+              const l = [];
+              return i.forEach((a) => {
+                if (a.isText) {
+                  l.push(a);
+                  return;
+                }
+                if (!n.includes(a.type.name)) {
+                  l.push(a.copy(s(a.content)));
+                  return;
+                }
+                const c = a.type.create(
+                  {
+                    ...a.attrs,
+                    [e]: null
+                  },
+                  s(a.content),
+                  a.marks
+                );
+                l.push(c);
+              }), at.from(l);
+            };
+            return o = !1, new lt(
+              s(r.content),
+              r.openStart,
+              r.openEnd
+            );
+          }
+        }
+      })
+    ];
+  }
+});
+function K(t) {
+  return t.type === "link";
+}
+function X(t) {
+  return typeof t != "string" && t.type === "link";
+}
+function B(t) {
+  return typeof t != "string" && t.type === "text";
+}
+function S(t) {
+  var o, r, n, e, s;
+  return R(t) ? { ...t } : v(t) ? {
+    type: "tableCell",
+    content: [].concat(t.content),
+    props: {
+      backgroundColor: ((o = t.props) == null ? void 0 : o.backgroundColor) ?? "default",
+      textColor: ((r = t.props) == null ? void 0 : r.textColor) ?? "default",
+      textAlignment: ((n = t.props) == null ? void 0 : n.textAlignment) ?? "left",
+      colspan: ((e = t.props) == null ? void 0 : e.colspan) ?? 1,
+      rowspan: ((s = t.props) == null ? void 0 : s.rowspan) ?? 1
+    }
+  } : {
+    type: "tableCell",
+    content: [].concat(t),
+    props: {
+      backgroundColor: "default",
+      textColor: "default",
+      textAlignment: "left",
+      colspan: 1,
+      rowspan: 1
+    }
+  };
+}
+function v(t) {
+  return t != null && typeof t != "string" && !Array.isArray(t) && t.type === "tableCell";
+}
+function R(t) {
+  return v(t) && t.props !== void 0 && t.content !== void 0;
+}
+function A(t) {
+  return R(t) ? t.props.colspan ?? 1 : 1;
+}
+function D(t) {
+  return R(t) ? t.props.rowspan ?? 1 : 1;
+}
+class O extends Error {
+  constructor(o) {
+    super(`Unreachable case: ${o}`);
+  }
+}
+function At(t, o = !0) {
+  const { "data-test": r, ...n } = t;
+  if (Object.keys(n).length > 0 && o)
+    throw new Error("Object must be empty " + JSON.stringify(t));
+}
+function Y(t, o) {
+  const r = t.resolve(o);
+  if (r.nodeAfter && r.nodeAfter.type.isInGroup("bnBlock"))
+    return {
+      posBeforeNode: r.pos,
+      node: r.nodeAfter
+    };
+  let n = r.depth, e = r.node(n);
+  for (; n > 0; ) {
+    if (e.type.isInGroup("bnBlock"))
+      return {
+        posBeforeNode: r.before(n),
+        node: e
+      };
+    n--, e = r.node(n);
+  }
+  const s = [];
+  t.descendants((l, a) => {
+    l.type.isInGroup("bnBlock") && s.push(a);
+  }), console.warn(`Position ${o} is not within a blockContainer node.`);
+  const i = t.resolve(
+    s.find((l) => l >= o) || s[s.length - 1]
+  );
+  return {
+    posBeforeNode: i.pos,
+    node: i.nodeAfter
+  };
+}
+function $(t, o) {
+  if (!t.type.isInGroup("bnBlock"))
+    throw new Error(
+      `Attempted to get bnBlock node at position but found node of different type ${t.type.name}`
+    );
+  const r = t, n = o, e = n + r.nodeSize, s = {
+    node: r,
+    beforePos: n,
+    afterPos: e
+  };
+  if (r.type.name === "blockContainer") {
+    let i, l;
+    if (r.forEach((a, c) => {
+      if (a.type.spec.group === "blockContent") {
+        const h = a, f = n + c + 1, p = f + a.nodeSize;
+        i = {
+          node: h,
+          beforePos: f,
+          afterPos: p
+        };
+      } else if (a.type.name === "blockGroup") {
+        const h = a, f = n + c + 1, p = f + a.nodeSize;
+        l = {
+          node: h,
+          beforePos: f,
+          afterPos: p
+        };
+      }
+    }), !i)
+      throw new Error(
+        `blockContainer node does not contain a blockContent node in its children: ${r}`
+      );
+    return {
+      isBlockContainer: !0,
+      bnBlock: s,
+      blockContent: i,
+      childContainer: l,
+      blockNoteType: i.node.type.name
+    };
+  } else {
+    if (!s.node.type.isInGroup("childContainer"))
+      throw new Error(
+        `bnBlock node is not in the childContainer group: ${s.node}`
+      );
+    return {
+      isBlockContainer: !1,
+      bnBlock: s,
+      childContainer: s,
+      blockNoteType: s.node.type.name
+    };
+  }
+}
+function Z(t) {
+  return $(t.node, t.posBeforeNode);
+}
+function It(t) {
+  if (!t.nodeAfter)
+    throw new Error(
+      `Attempted to get blockContainer node at position ${t.pos} but a node at this position does not exist`
+    );
+  return $(t.nodeAfter, t.pos);
+}
+function Tt(t) {
+  const o = Y(t.doc, t.selection.anchor);
+  return Z(o);
+}
+function Ot(t) {
+  const o = Y(t.doc, t.selection.anchor);
+  return Z(o);
+}
+function ht(t) {
+  return "doc" in t ? t.doc.type.schema : t.type.schema;
+}
+function G(t) {
+  return t.cached.blockNoteEditor;
+}
+function J(t) {
+  return G(t).schema;
+}
+function _(t) {
+  return J(t).blockSchema;
+}
+function H(t) {
+  return J(t).inlineContentSchema;
+}
+function N(t) {
+  return J(t).styleSchema;
+}
+function j(t) {
+  return G(t).blockCache;
+}
+function gt(t, o, r) {
+  var s, i;
+  const n = {
+    type: "tableContent",
+    columnWidths: [],
+    headerRows: void 0,
+    headerCols: void 0,
+    rows: []
+  }, e = [];
+  t.content.forEach((l, a, c) => {
+    const h = {
+      cells: []
+    };
+    c === 0 && l.content.forEach((f) => {
+      let p = f.attrs.colwidth;
+      p == null && (p = new Array(f.attrs.colspan ?? 1).fill(void 0)), n.columnWidths.push(...p);
+    }), h.cells = l.content.content.map((f, p) => (e[c] || (e[c] = []), e[c][p] = f.type.name === "tableHeader", {
+      type: "tableCell",
+      content: f.content.content.map(
+        (g) => F(g, o, r)
+      ).reduce(
+        (g, C) => {
+          if (!g.length)
+            return C;
+          const d = g[g.length - 1], w = C[0];
+          return w && B(d) && B(w) && JSON.stringify(d.styles) === JSON.stringify(w.styles) ? (d.text += `
+` + w.text, g.push(...C.slice(1)), g) : (g.push(...C), g);
+        },
+        []
+      ),
+      props: {
+        colspan: f.attrs.colspan,
+        rowspan: f.attrs.rowspan,
+        backgroundColor: f.attrs.backgroundColor,
+        textColor: f.attrs.textColor,
+        textAlignment: f.attrs.textAlignment
+      }
+    })), n.rows.push(h);
+  });
+  for (let l = 0; l < e.length; l++)
+    (s = e[l]) != null && s.every((a) => a) && (n.headerRows = (n.headerRows ?? 0) + 1);
+  for (let l = 0; l < ((i = e[0]) == null ? void 0 : i.length); l++)
+    e != null && e.every((a) => a[l]) && (n.headerCols = (n.headerCols ?? 0) + 1);
+  return n;
+}
+function F(t, o, r) {
+  const n = [];
+  let e;
+  return t.content.forEach((s) => {
+    if (s.type.name === "hardBreak") {
+      if (e)
+        if (B(e))
+          e.text += `
+`;
+        else if (K(e))
+          e.content[e.content.length - 1].text += `
+`;
+        else
+          throw new Error("unexpected");
+      else
+        e = {
+          type: "text",
+          text: `
+`,
+          styles: {}
+        };
+      return;
+    }
+    if (s.type.name !== "link" && s.type.name !== "text") {
+      if (!o[s.type.name]) {
+        console.warn("unrecognized inline content type", s.type.name);
+        return;
+      }
+      e && (n.push(e), e = void 0), n.push(
+        wt(s, o, r)
+      );
+      return;
+    }
+    const i = {};
+    let l;
+    for (const a of s.marks)
+      if (a.type.name === "link")
+        l = a;
+      else {
+        const c = r[a.type.name];
+        if (!c) {
+          if (a.type.spec.blocknoteIgnore)
+            continue;
+          throw new Error(`style ${a.type.name} not found in styleSchema`);
+        }
+        if (c.propSchema === "boolean")
+          i[c.type] = !0;
+        else if (c.propSchema === "string")
+          i[c.type] = a.attrs.stringValue;
+        else
+          throw new O(c.propSchema);
+      }
+    e ? B(e) ? l ? (n.push(e), e = {
+      type: "link",
+      href: l.attrs.href,
+      content: [
+        {
+          type: "text",
+          text: s.textContent,
+          styles: i
+        }
+      ]
+    }) : JSON.stringify(e.styles) === JSON.stringify(i) ? e.text += s.textContent : (n.push(e), e = {
+      type: "text",
+      text: s.textContent,
+      styles: i
+    }) : K(e) && (l ? e.href === l.attrs.href ? JSON.stringify(
+      e.content[e.content.length - 1].styles
+    ) === JSON.stringify(i) ? e.content[e.content.length - 1].text += s.textContent : e.content.push({
+      type: "text",
+      text: s.textContent,
+      styles: i
+    }) : (n.push(e), e = {
+      type: "link",
+      href: l.attrs.href,
+      content: [
+        {
+          type: "text",
+          text: s.textContent,
+          styles: i
+        }
+      ]
+    }) : (n.push(e), e = {
+      type: "text",
+      text: s.textContent,
+      styles: i
+    })) : l ? e = {
+      type: "link",
+      href: l.attrs.href,
+      content: [
+        {
+          type: "text",
+          text: s.textContent,
+          styles: i
+        }
+      ]
+    } : e = {
+      type: "text",
+      text: s.textContent,
+      styles: i
+    };
+  }), e && n.push(e), n;
+}
+function wt(t, o, r) {
+  if (t.type.name === "text" || t.type.name === "link")
+    throw new Error("unexpected");
+  const n = {}, e = o[t.type.name];
+  for (const [l, a] of Object.entries(t.attrs)) {
+    if (!e)
+      throw Error("ic node is of an unrecognized type: " + t.type.name);
+    const c = e.propSchema;
+    l in c && (n[l] = a);
+  }
+  let s;
+  return e.content === "styled" ? s = F(
+    t,
+    o,
+    r
+  ) : s = void 0, {
+    type: t.type.name,
+    props: n,
+    content: s
+  };
+}
+function L(t, o, r = _(o), n = H(o), e = N(o), s = j(o)) {
+  var C;
+  if (!t.type.isInGroup("bnBlock"))
+    throw Error("Node should be a bnBlock, but is instead: " + t.type.name);
+  const i = s == null ? void 0 : s.get(t);
+  if (i)
+    return i;
+  const l = $(t, 0);
+  let a = l.bnBlock.node.attrs.id;
+  a === null && (a = Q.options.generateID());
+  const c = r[l.blockNoteType];
+  if (!c)
+    throw Error("Block is of an unrecognized type: " + l.blockNoteType);
+  const h = {};
+  for (const [d, w] of Object.entries({
+    ...t.attrs,
+    ...l.isBlockContainer ? l.blockContent.node.attrs : {}
+  })) {
+    const y = c.propSchema;
+    d in y && !(y[d].default === void 0 && w === void 0) && (h[d] = w);
+  }
+  const f = r[l.blockNoteType], p = [];
+  (C = l.childContainer) == null || C.node.forEach((d) => {
+    p.push(
+      L(
+        d,
+        o,
+        r,
+        n,
+        e,
+        s
+      )
+    );
+  });
+  let u;
+  if (f.content === "inline") {
+    if (!l.isBlockContainer)
+      throw new Error("impossible");
+    u = F(
+      l.blockContent.node,
+      n,
+      e
+    );
+  } else if (f.content === "table") {
+    if (!l.isBlockContainer)
+      throw new Error("impossible");
+    u = gt(
+      l.blockContent.node,
+      n,
+      e
+    );
+  } else if (f.content === "none")
+    u = void 0;
+  else
+    throw new O(f.content);
+  const g = {
+    id: a,
+    type: f.type,
+    props: h,
+    content: u,
+    children: p
+  };
+  return s == null || s.set(t, g), g;
+}
+function St(t, o = ht(t), r = _(o), n = H(o), e = N(o), s = j(o)) {
+  const i = [];
+  return t.firstChild && t.firstChild.descendants((l) => (i.push(
+    L(
+      l,
+      o,
+      r,
+      n,
+      e,
+      s
+    )
+  ), !1)), i;
+}
+function Dt(t, o, r = _(o), n = H(o), e = N(o), s = j(o)) {
+  function i(l, a, c) {
+    if (l.type.name !== "blockGroup")
+      throw new Error("unexpected");
+    const h = [];
+    let f, p;
+    return l.forEach((u, g, C) => {
+      if (u.type.name !== "blockContainer")
+        throw new Error("unexpected");
+      if (u.childCount === 0)
+        return;
+      if (u.childCount === 0 || u.childCount > 2)
+        throw new Error(
+          "unexpected, blockContainer.childCount: " + u.childCount
+        );
+      const d = C === 0, w = C === l.childCount - 1;
+      if (u.firstChild.type.name === "blockGroup") {
+        if (!d)
+          throw new Error("unexpected");
+        const k = i(
+          u.firstChild,
+          Math.max(0, a - 1),
+          w ? Math.max(0, c - 1) : 0
+        );
+        f = k.blockCutAtStart, w && (p = k.blockCutAtEnd), h.push(...k.blocks);
+        return;
+      }
+      const y = L(
+        u,
+        o,
+        r,
+        n,
+        e,
+        s
+      ), m = u.childCount > 1 ? u.child(1) : void 0;
+      let b = [];
+      if (m) {
+        const k = i(
+          m,
+          0,
+          // TODO: can this be anything other than 0?
+          w ? Math.max(0, c - 1) : 0
+        );
+        b = k.blocks, w && (p = k.blockCutAtEnd);
+      }
+      w && !m && c > 1 && (p = y.id), d && a > 1 && (f = y.id), h.push({
+        ...y,
+        children: b
+      });
+    }), { blocks: h, blockCutAtStart: f, blockCutAtEnd: p };
+  }
+  if (t.content.childCount === 0)
+    return {
+      blocks: [],
+      blockCutAtStart: void 0,
+      blockCutAtEnd: void 0
+    };
+  if (t.content.childCount !== 1)
+    throw new Error(
+      "slice must be a single block, did you forget includeParents=true?"
+    );
+  return i(
+    t.content.firstChild,
+    Math.max(t.openStart - 1, 0),
+    Math.max(t.openEnd - 1, 0)
+  );
+}
+function x(t) {
+  const { height: o, width: r } = tt(t), n = new Array(o).fill(!1).map(() => new Array(r).fill(null)), e = (s, i) => {
+    for (let l = s; l < o; l++)
+      for (let a = i; a < r; a++)
+        if (!n[l][a])
+          return { row: l, col: a };
+    throw new Error(
+      "Unable to create occupancy grid for table, no more available cells"
+    );
+  };
+  for (let s = 0; s < t.content.rows.length; s++)
+    for (let i = 0; i < t.content.rows[s].cells.length; i++) {
+      const l = S(t.content.rows[s].cells[i]), a = D(l), c = A(l), { row: h, col: f } = e(s, i);
+      for (let p = h; p < h + a; p++)
+        for (let u = f; u < f + c; u++) {
+          if (n[p][u])
+            throw new Error(
+              `Unable to create occupancy grid for table, cell at ${p},${u} is already occupied`
+            );
+          n[p][u] = {
+            row: s,
+            col: i,
+            rowspan: a,
+            colspan: c,
+            cell: l
+          };
+        }
+    }
+  return n;
+}
+function I(t) {
+  const o = /* @__PURE__ */ new Set();
+  return t.map((r) => ({
+    cells: r.map((n) => o.has(n.row + ":" + n.col) ? !1 : (o.add(n.row + ":" + n.col), n.cell)).filter((n) => n !== !1)
+  }));
+}
+function E(t, o, r = x(o)) {
+  for (let n = 0; n < r.length; n++)
+    for (let e = 0; e < r[n].length; e++) {
+      const s = r[n][e];
+      if (s.row === t.row && s.col === t.col)
+        return { row: n, col: e, cell: s.cell };
+    }
+  throw new Error(
+    `Unable to resolve relative table cell indices for table, cell at ${t.row},${t.col} is not occupied`
+  );
+}
+function tt(t) {
+  const o = t.content.rows.length;
+  let r = 0;
+  return t.content.rows.forEach((n) => {
+    let e = 0;
+    n.cells.forEach((s) => {
+      e += A(s);
+    }), r = Math.max(r, e);
+  }), { height: o, width: r };
+}
+function et(t, o, r = x(o)) {
+  var e;
+  const n = (e = r[t.row]) == null ? void 0 : e[t.col];
+  if (n)
+    return {
+      row: n.row,
+      col: n.col,
+      cell: n.cell
+    };
+}
+function yt(t, o) {
+  var s;
+  const r = x(t);
+  if (o < 0 || o >= r.length)
+    return [];
+  let n = 0;
+  for (let i = 0; i < o; i++) {
+    const l = (s = r[n]) == null ? void 0 : s[0];
+    if (!l)
+      return [];
+    n += l.rowspan;
+  }
+  const e = new Array(r[0].length).fill(!1).map((i, l) => et(
+    { row: n, col: l },
+    t,
+    r
+  )).filter(
+    (i) => i !== void 0
+  );
+  return e.filter((i, l) => e.findIndex((a) => a.row === i.row && a.col === i.col) === l);
+}
+function Ct(t, o) {
+  var s;
+  const r = x(t);
+  if (o < 0 || o >= r[0].length)
+    return [];
+  let n = 0;
+  for (let i = 0; i < o; i++) {
+    const l = (s = r[0]) == null ? void 0 : s[n];
+    if (!l)
+      return [];
+    n += l.colspan;
+  }
+  const e = new Array(r.length).fill(!1).map((i, l) => et(
+    { row: l, col: n },
+    t,
+    r
+  )).filter(
+    (i) => i !== void 0
+  );
+  return e.filter((i, l) => e.findIndex((a) => a.row === i.row && a.col === i.col) === l);
+}
+function Mt(t, o, r, n = x(t)) {
+  const { col: e } = E(
+    {
+      row: 0,
+      col: o
+    },
+    t,
+    n
+  ), { col: s } = E(
+    {
+      row: 0,
+      col: r
+    },
+    t,
+    n
+  );
+  return n.forEach((i) => {
+    const [l] = i.splice(e, 1);
+    i.splice(s, 0, l);
+  }), I(n);
+}
+function Pt(t, o, r, n = x(t)) {
+  const { row: e } = E(
+    {
+      row: o,
+      col: 0
+    },
+    t,
+    n
+  ), { row: s } = E(
+    {
+      row: r,
+      col: 0
+    },
+    t,
+    n
+  ), [i] = n.splice(e, 1);
+  return n.splice(s, 0, i), I(n);
+}
+function M(t) {
+  return t ? v(t) ? M(t.content) : typeof t == "string" ? t.length === 0 : Array.isArray(t) ? t.every(
+    (o) => typeof o == "string" ? o.length === 0 : B(o) ? o.text.length === 0 : X(o) ? typeof o.content == "string" ? o.content.length === 0 : o.content.every((r) => r.text.length === 0) : !1
+  ) : !1 : !0;
+}
+function Rt(t, o, r = x(t)) {
+  if (o === "columns") {
+    let s = 0;
+    for (let i = r[0].length - 1; i >= 0 && r.every(
+      (a) => M(a[i].cell) && a[i].colspan === 1
+    ); i--)
+      s++;
+    for (let i = r.length - 1; i >= 0; i--) {
+      const l = Math.max(
+        r[i].length - s,
+        1
+      );
+      r[i] = r[i].slice(0, l);
+    }
+    return I(r);
+  }
+  let n = 0;
+  for (let s = r.length - 1; s >= 0 && r[s].every(
+    (l) => M(l.cell) && l.rowspan === 1
+  ); s--)
+    n++;
+  const e = Math.min(n, r.length - 1);
+  return r.splice(r.length - e, e), I(r);
+}
+function $t(t, o, r, n = x(t)) {
+  const { width: e, height: s } = tt(t);
+  if (o === "columns")
+    n.forEach((i, l) => {
+      if (r >= 0)
+        for (let a = 0; a < r; a++)
+          i.push({
+            row: l,
+            col: Math.max(...i.map((c) => c.col)) + 1,
+            rowspan: 1,
+            colspan: 1,
+            cell: S("")
+          });
+      else
+        i.splice(e + r, -1 * r);
+    });
+  else if (r > 0)
+    for (let i = 0; i < r; i++) {
+      const l = new Array(e).fill(null).map((a, c) => ({
+        row: s + i,
+        col: c,
+        rowspan: 1,
+        colspan: 1,
+        cell: S("")
+      }));
+      n.push(l);
+    }
+  else r < 0 && n.splice(s + r, -1 * r);
+  return I(n);
+}
+function Jt(t, o, r) {
+  const n = yt(t, r);
+  if (!n.some((a) => D(a.cell) > 1))
+    return !0;
+  let s = r, i = r;
+  return n.forEach((a) => {
+    const c = D(a.cell);
+    s = Math.max(s, a.row + c - 1), i = Math.min(i, a.row);
+  }), o < r ? r === s : r === i;
+}
+function _t(t, o, r) {
+  const n = Ct(t, r);
+  if (!n.some((a) => A(a.cell) > 1))
+    return !0;
+  let s = r, i = r;
+  return n.forEach((a) => {
+    const c = A(a.cell);
+    s = Math.max(s, a.col + c - 1), i = Math.min(i, a.col);
+  }), o < r ? r === s : r === i;
+}
+function Ht(t, o, r) {
+  const n = E(t, r), e = E(o, r);
+  return n.col === e.col;
+}
+function V(t, o, r, n) {
+  const e = [];
+  for (const [i, l] of Object.entries(t.styles || {})) {
+    const a = r[i];
+    if (!a)
+      throw new Error(`style ${i} not found in styleSchema`);
+    if (a.propSchema === "boolean")
+      l && e.push(o.mark(i));
+    else if (a.propSchema === "string")
+      l && e.push(o.mark(i, { stringValue: l }));
+    else
+      throw new O(a.propSchema);
+  }
+  return !n || !o.nodes[n].spec.code ? t.text.split(/(\n)/g).filter((i) => i.length > 0).map((i) => i === `
+` ? o.nodes.hardBreak.createChecked() : o.text(i, e)) : t.text.length > 0 ? [o.text(t.text, e)] : [];
+}
+function mt(t, o, r) {
+  const n = o.marks.link.create({
+    href: t.href
+  });
+  return P(t.content, o, r).map(
+    (e) => {
+      if (e.type.name === "text")
+        return e.mark([...e.marks, n]);
+      if (e.type.name === "hardBreak")
+        return e;
+      throw new Error("unexpected node type");
+    }
+  );
+}
+function P(t, o, r, n) {
+  const e = [];
+  if (typeof t == "string")
+    return e.push(
+      ...V(
+        { text: t, styles: {} },
+        o,
+        r,
+        n
+      )
+    ), e;
+  for (const s of t)
+    e.push(
+      ...V(s, o, r, n)
+    );
+  return e;
+}
+function T(t, o, r, n = N(o)) {
+  const e = [];
+  for (const s of t)
+    typeof s == "string" ? e.push(
+      ...P(s, o, n, r)
+    ) : X(s) ? e.push(...mt(s, o, n)) : B(s) ? e.push(
+      ...P([s], o, n, r)
+    ) : e.push(
+      nt(s, o, n)
+    );
+  return e;
+}
+function kt(t, o, r = N(o)) {
+  const n = [], e = new Array(t.headerRows ?? 0).fill(!0), s = new Array(t.headerCols ?? 0).fill(!0), i = t.columnWidths ?? [];
+  for (let l = 0; l < t.rows.length; l++) {
+    const a = t.rows[l], c = [], h = e[l];
+    for (let p = 0; p < a.cells.length; p++) {
+      const u = a.cells[p], g = s[p], C = void 0;
+      let d = null;
+      const w = E(
+        {
+          row: l,
+          col: p
+        },
+        { content: t }
+      );
+      let y = i[w.col] ? [i[w.col]] : null;
+      if (u) if (typeof u == "string")
+        d = o.text(u);
+      else if (v(u)) {
+        u.content && (d = T(
+          u.content,
+          o,
+          "tableParagraph",
+          r
+        ));
+        const b = A(u);
+        b > 1 && (y = new Array(b).fill(!1).map((k, W) => i[w.col + W] ?? void 0));
+      } else
+        d = T(
+          u,
+          o,
+          "tableParagraph",
+          r
+        );
+      const m = o.nodes[g || h ? "tableHeader" : "tableCell"].createChecked(
+        {
+          ...v(u) ? u.props : {},
+          colwidth: y
+        },
+        o.nodes.tableParagraph.createChecked(C, d)
+      );
+      c.push(m);
+    }
+    const f = o.nodes.tableRow.createChecked({}, c);
+    n.push(f);
+  }
+  return n;
+}
+function nt(t, o, r) {
+  let n, e = t.type;
+  if (e === void 0 && (e = "paragraph"), !o.nodes[e])
+    throw new Error(`node type ${e} not found in schema`);
+  if (!t.content)
+    n = o.nodes[e].createChecked(t.props);
+  else if (typeof t.content == "string") {
+    const s = T(
+      [t.content],
+      o,
+      e,
+      r
+    );
+    n = o.nodes[e].createChecked(t.props, s);
+  } else if (Array.isArray(t.content)) {
+    const s = T(
+      t.content,
+      o,
+      e,
+      r
+    );
+    n = o.nodes[e].createChecked(t.props, s);
+  } else if (t.content.type === "tableContent") {
+    const s = kt(t.content, o, r);
+    n = o.nodes[e].createChecked(t.props, s);
+  } else
+    throw new O(t.content.type);
+  return n;
+}
+function bt(t, o, r = N(o)) {
+  let n = t.id;
+  n === void 0 && (n = Q.options.generateID());
+  const e = [];
+  if (t.children)
+    for (const i of t.children)
+      e.push(bt(i, o, r));
+  if (!t.type || // can happen if block.type is not defined (this should create the default node)
+  o.nodes[t.type].isInGroup("blockContent")) {
+    const i = nt(
+      t,
+      o,
+      r
+    ), l = e.length > 0 ? o.nodes.blockGroup.createChecked({}, e) : void 0;
+    return o.nodes.blockContainer.createChecked(
+      {
+        id: n,
+        ...t.props
+      },
+      l ? [i, l] : i
+    );
+  } else {
+    if (o.nodes[t.type].isInGroup("bnBlock"))
+      return o.nodes[t.type].createChecked(
+        {
+          id: n,
+          ...t.props
+        },
+        e
+      );
+    throw new Error(
+      `block type ${t.type} doesn't match blockContent or bnBlock group`
+    );
+  }
+}
+export {
+  Dt as A,
+  J as B,
+  At as C,
+  $ as D,
+  _ as E,
+  H as F,
+  N as G,
+  j as H,
+  K as I,
+  X as J,
+  S as K,
+  v as L,
+  R as M,
+  A as N,
+  D as O,
+  O as U,
+  ht as a,
+  bt as b,
+  Y as c,
+  St as d,
+  Z as e,
+  Ot as f,
+  It as g,
+  Tt as h,
+  T as i,
+  B as j,
+  wt as k,
+  gt as l,
+  F as m,
+  L as n,
+  Jt as o,
+  Pt as p,
+  _t as q,
+  Mt as r,
+  tt as s,
+  kt as t,
+  yt as u,
+  Ct as v,
+  Ht as w,
+  Rt as x,
+  $t as y,
+  Q as z
+};
+//# sourceMappingURL=blockToNode-DIfPWLH8.js.map