@caspeco/casper-ui-library 9.9.0 → 9.11.0

package/dist/node_modules/@tiptap/core/dist/index.js

@@ -0,0 +1,3953 @@
+import { findWrapping as ye, canJoin as bt, Transform as ke, RemoveMarkStep as we, liftTarget as xe, joinPoint as Lt, canSplit as X, ReplaceStep as Me, ReplaceAroundStep as Se } from "../../../prosemirror-transform/dist/index.js";
+import { createParagraphNear as Ee, exitCode as Te, joinUp as Ae, joinDown as Ce, joinBackward as Pe, joinForward as $e, joinTextblockBackward as Ne, joinTextblockForward as Ie, lift as Oe, liftEmptyBlock as Re, newlineInCode as Be, selectNodeBackward as De, selectNodeForward as je, selectParentNode as _e, selectTextblockEnd as Le, selectTextblockStart as ze, setBlockType as Ct, wrapIn as Fe } from "../../../prosemirror-commands/dist/index.js";
+import { NodeSelection as st, EditorState as Ve, Selection as F, TextSelection as O, Plugin as R, PluginKey as _, AllSelection as He } from "../../../prosemirror-state/dist/index.js";
+import { Node as zt, DOMParser as tt, DOMSerializer as We, Schema as Ft, Fragment as j, Slice as Ue } from "../../../prosemirror-model/dist/index.js";
+import { liftListItem as qe, sinkListItem as Je, wrapInList as Ke } from "../../../prosemirror-schema-list/dist/index.js";
+import { EditorView as Qe } from "../../../prosemirror-view/dist/index.js";
+import { keymap as Ze } from "../../../prosemirror-keymap/dist/index.js";
+var Ge = Object.defineProperty, yt = (t, e) => {
+  for (var n in e)
+    Ge(t, n, { get: e[n], enumerable: !0 });
+};
+function it(t) {
+  const { state: e, transaction: n } = t;
+  let { selection: r } = n, { doc: o } = n, { storedMarks: s } = n;
+  return {
+    ...e,
+    apply: e.apply.bind(e),
+    applyTransaction: e.applyTransaction.bind(e),
+    plugins: e.plugins,
+    schema: e.schema,
+    reconfigure: e.reconfigure.bind(e),
+    toJSON: e.toJSON.bind(e),
+    get storedMarks() {
+      return s;
+    },
+    get selection() {
+      return r;
+    },
+    get doc() {
+      return o;
+    },
+    get tr() {
+      return r = n.selection, o = n.doc, s = n.storedMarks, n;
+    }
+  };
+}
+var at = class {
+  constructor(t) {
+    this.editor = t.editor, this.rawCommands = this.editor.extensionManager.commands, this.customState = t.state;
+  }
+  get hasCustomState() {
+    return !!this.customState;
+  }
+  get state() {
+    return this.customState || this.editor.state;
+  }
+  get commands() {
+    const { rawCommands: t, editor: e, state: n } = this, { view: r } = e, { tr: o } = n, s = this.buildProps(o);
+    return Object.fromEntries(
+      Object.entries(t).map(([i, c]) => [i, (...l) => {
+        const f = c(...l)(s);
+        return !o.getMeta("preventDispatch") && !this.hasCustomState && r.dispatch(o), f;
+      }])
+    );
+  }
+  get chain() {
+    return () => this.createChain();
+  }
+  get can() {
+    return () => this.createCan();
+  }
+  createChain(t, e = !0) {
+    const { rawCommands: n, editor: r, state: o } = this, { view: s } = r, i = [], c = !!t, a = t || o.tr, l = () => (!c && e && !a.getMeta("preventDispatch") && !this.hasCustomState && s.dispatch(a), i.every((u) => u === !0)), f = {
+      ...Object.fromEntries(
+        Object.entries(n).map(([u, p]) => [u, (...h) => {
+          const m = this.buildProps(a, e), g = p(...h)(m);
+          return i.push(g), f;
+        }])
+      ),
+      run: l
+    };
+    return f;
+  }
+  createCan(t) {
+    const { rawCommands: e, state: n } = this, r = !1, o = t || n.tr, s = this.buildProps(o, r);
+    return {
+      ...Object.fromEntries(
+        Object.entries(e).map(([c, a]) => [c, (...l) => a(...l)({ ...s, dispatch: void 0 })])
+      ),
+      chain: () => this.createChain(o, r)
+    };
+  }
+  buildProps(t, e = !0) {
+    const { rawCommands: n, editor: r, state: o } = this, { view: s } = r, i = {
+      tr: t,
+      editor: r,
+      view: s,
+      state: it({
+        state: o,
+        transaction: t
+      }),
+      dispatch: e ? () => {
+      } : void 0,
+      chain: () => this.createChain(t, e),
+      can: () => this.createCan(t),
+      get commands() {
+        return Object.fromEntries(
+          Object.entries(n).map(([c, a]) => [c, (...l) => a(...l)(i)])
+        );
+      }
+    };
+    return i;
+  }
+}, Vt = {};
+yt(Vt, {
+  blur: () => Ye,
+  clearContent: () => Xe,
+  clearNodes: () => tn,
+  command: () => en,
+  createParagraphNear: () => nn,
+  cut: () => rn,
+  deleteCurrentNode: () => on,
+  deleteNode: () => sn,
+  deleteRange: () => an,
+  deleteSelection: () => un,
+  enter: () => dn,
+  exitCode: () => fn,
+  extendMarkRange: () => pn,
+  first: () => mn,
+  focus: () => gn,
+  forEach: () => vn,
+  insertContent: () => bn,
+  insertContentAt: () => wn,
+  joinBackward: () => Sn,
+  joinDown: () => Mn,
+  joinForward: () => En,
+  joinItemBackward: () => Tn,
+  joinItemForward: () => An,
+  joinTextblockBackward: () => Cn,
+  joinTextblockForward: () => Pn,
+  joinUp: () => xn,
+  keyboardShortcut: () => Nn,
+  lift: () => In,
+  liftEmptyBlock: () => On,
+  liftListItem: () => Rn,
+  newlineInCode: () => Bn,
+  resetAttributes: () => Dn,
+  scrollIntoView: () => jn,
+  selectAll: () => _n,
+  selectNodeBackward: () => Ln,
+  selectNodeForward: () => zn,
+  selectParentNode: () => Fn,
+  selectTextblockEnd: () => Vn,
+  selectTextblockStart: () => Hn,
+  setContent: () => Wn,
+  setMark: () => ur,
+  setMeta: () => dr,
+  setNode: () => fr,
+  setNodeSelection: () => pr,
+  setTextDirection: () => mr,
+  setTextSelection: () => hr,
+  sinkListItem: () => gr,
+  splitBlock: () => vr,
+  splitListItem: () => br,
+  toggleList: () => kr,
+  toggleMark: () => wr,
+  toggleNode: () => xr,
+  toggleWrap: () => Mr,
+  undoInputRule: () => Sr,
+  unsetAllMarks: () => Er,
+  unsetMark: () => Tr,
+  unsetTextDirection: () => Ar,
+  updateAttributes: () => Cr,
+  wrapIn: () => Pr,
+  wrapInList: () => $r
+});
+var Ye = () => ({ editor: t, view: e }) => (requestAnimationFrame(() => {
+  var n;
+  t.isDestroyed || (e.dom.blur(), (n = window?.getSelection()) == null || n.removeAllRanges());
+}), !0), Xe = (t = !0) => ({ commands: e }) => e.setContent("", { emitUpdate: t }), tn = () => ({ state: t, tr: e, dispatch: n }) => {
+  const { selection: r } = e, { ranges: o } = r;
+  return n && o.forEach(({ $from: s, $to: i }) => {
+    t.doc.nodesBetween(s.pos, i.pos, (c, a) => {
+      if (c.type.isText)
+        return;
+      const { doc: l, mapping: f } = e, u = l.resolve(f.map(a)), p = l.resolve(f.map(a + c.nodeSize)), d = u.blockRange(p);
+      if (!d)
+        return;
+      const h = xe(d);
+      if (c.type.isTextblock) {
+        const { defaultType: m } = u.parent.contentMatchAt(u.index());
+        e.setNodeMarkup(d.start, m);
+      }
+      (h || h === 0) && e.lift(d, h);
+    });
+  }), !0;
+}, en = (t) => (e) => t(e), nn = () => ({ state: t, dispatch: e }) => Ee(t, e), rn = (t, e) => ({ editor: n, tr: r }) => {
+  const { state: o } = n, s = o.doc.slice(t.from, t.to);
+  r.deleteRange(t.from, t.to);
+  const i = r.mapping.map(e);
+  return r.insert(i, s.content), r.setSelection(new O(r.doc.resolve(Math.max(i - 1, 0)))), !0;
+}, on = () => ({ tr: t, dispatch: e }) => {
+  const { selection: n } = t, r = n.$anchor.node();
+  if (r.content.size > 0)
+    return !1;
+  const o = t.selection.$anchor;
+  for (let s = o.depth; s > 0; s -= 1)
+    if (o.node(s).type === r.type) {
+      if (e) {
+        const c = o.before(s), a = o.after(s);
+        t.delete(c, a).scrollIntoView();
+      }
+      return !0;
+    }
+  return !1;
+};
+function T(t, e) {
+  if (typeof t == "string") {
+    if (!e.nodes[t])
+      throw Error(
+        `There is no node type named '${t}'. Maybe you forgot to add the extension?`
+      );
+    return e.nodes[t];
+  }
+  return t;
+}
+var sn = (t) => ({ tr: e, state: n, dispatch: r }) => {
+  const o = T(t, n.schema), s = e.selection.$anchor;
+  for (let i = s.depth; i > 0; i -= 1)
+    if (s.node(i).type === o) {
+      if (r) {
+        const a = s.before(i), l = s.after(i);
+        e.delete(a, l).scrollIntoView();
+      }
+      return !0;
+    }
+  return !1;
+}, an = (t) => ({ tr: e, dispatch: n }) => {
+  const { from: r, to: o } = t;
+  return n && e.delete(r, o), !0;
+}, cn = (t) => t.content ? /^text(\*|\+)/.test(t.content) : !1, Pt = (t, e, n) => {
+  if (!t.parent.isInline || n === "left" && t.pos > t.start() || n === "right" && t.pos < t.end())
+    return t.pos;
+  const r = e.nodes[t.parent.type.name].spec;
+  return cn(r) ? n === "left" ? t.start() - 1 : t.end() + 1 : t.pos;
+}, ln = (t, e, n) => {
+  const r = Pt(t, n, "left"), o = Pt(e, n, "right");
+  return { from: r, to: o };
+}, un = () => ({ state: t, dispatch: e }) => {
+  const { $from: n, $to: r } = t.selection;
+  if (t.selection.empty)
+    return !1;
+  const { from: o, to: s } = ln(n, r, t.schema);
+  return e && (t.tr.deleteRange(o, s).scrollIntoView(), e(t.tr)), !0;
+}, dn = () => ({ commands: t }) => t.keyboardShortcut("Enter"), fn = () => ({ state: t, dispatch: e }) => Te(t, e);
+function kt(t) {
+  return Object.prototype.toString.call(t) === "[object RegExp]";
+}
+function nt(t, e, n = { strict: !0 }) {
+  const r = Object.keys(e);
+  return r.length ? r.every((o) => n.strict ? e[o] === t[o] : kt(e[o]) ? e[o].test(t[o]) : e[o] === t[o]) : !0;
+}
+function Ht(t, e, n = {}) {
+  return t.find((r) => r.type === e && nt(
+    // Only check equality for the attributes that are provided
+    Object.fromEntries(Object.keys(n).map((o) => [o, r.attrs[o]])),
+    n
+  ));
+}
+function $t(t, e, n = {}) {
+  return !!Ht(t, e, n);
+}
+function wt(t, e, n) {
+  if (!t || !e)
+    return;
+  let r = t.parent.childAfter(t.parentOffset);
+  if ((!r.node || !r.node.marks.some((l) => l.type === e)) && (r = t.parent.childBefore(t.parentOffset)), !r.node || !r.node.marks.some((l) => l.type === e))
+    return;
+  if (!n) {
+    const l = r.node.marks.find((f) => f.type === e);
+    l && (n = l.attrs);
+  }
+  if (!Ht([...r.node.marks], e, n))
+    return;
+  let s = r.index, i = t.start() + r.offset, c = s + 1, a = i + r.node.nodeSize;
+  for (; s > 0 && $t([...t.parent.child(s - 1).marks], e, n); )
+    s -= 1, i -= t.parent.child(s).nodeSize;
+  for (; c < t.parent.childCount && $t([...t.parent.child(c).marks], e, n); )
+    a += t.parent.child(c).nodeSize, c += 1;
+  return {
+    from: i,
+    to: a
+  };
+}
+function D(t, e) {
+  if (typeof t == "string") {
+    if (!e.marks[t])
+      throw Error(
+        `There is no mark type named '${t}'. Maybe you forgot to add the extension?`
+      );
+    return e.marks[t];
+  }
+  return t;
+}
+var pn = (t, e) => ({ tr: n, state: r, dispatch: o }) => {
+  const s = D(t, r.schema), { doc: i, selection: c } = n, { $from: a, from: l, to: f } = c;
+  if (o) {
+    const u = wt(a, s, e);
+    if (u && u.from <= l && u.to >= f) {
+      const p = O.create(i, u.from, u.to);
+      n.setSelection(p);
+    }
+  }
+  return !0;
+}, mn = (t) => (e) => {
+  const n = typeof t == "function" ? t(e) : t;
+  for (let r = 0; r < n.length; r += 1)
+    if (n[r](e))
+      return !0;
+  return !1;
+};
+function Wt(t) {
+  return t instanceof O;
+}
+function z(t = 0, e = 0, n = 0) {
+  return Math.min(Math.max(t, e), n);
+}
+function Ut(t, e = null) {
+  if (!e)
+    return null;
+  const n = F.atStart(t), r = F.atEnd(t);
+  if (e === "start" || e === !0)
+    return n;
+  if (e === "end")
+    return r;
+  const o = n.from, s = r.to;
+  return e === "all" ? O.create(
+    t,
+    z(0, o, s),
+    z(t.content.size, o, s)
+  ) : O.create(
+    t,
+    z(e, o, s),
+    z(e, o, s)
+  );
+}
+function Nt() {
+  return navigator.platform === "Android" || /android/i.test(navigator.userAgent);
+}
+function rt() {
+  return ["iPad Simulator", "iPhone Simulator", "iPod Simulator", "iPad", "iPhone", "iPod"].includes(
+    navigator.platform
+  ) || // iPad on iOS 13 detection
+  navigator.userAgent.includes("Mac") && "ontouchend" in document;
+}
+function hn() {
+  return typeof navigator < "u" ? /^((?!chrome|android).)*safari/i.test(navigator.userAgent) : !1;
+}
+var gn = (t = null, e = {}) => ({ editor: n, view: r, tr: o, dispatch: s }) => {
+  e = {
+    scrollIntoView: !0,
+    ...e
+  };
+  const i = () => {
+    (rt() || Nt()) && r.dom.focus(), hn() && !rt() && !Nt() && r.dom.focus({ preventScroll: !0 }), requestAnimationFrame(() => {
+      n.isDestroyed || (r.focus(), e?.scrollIntoView && n.commands.scrollIntoView());
+    });
+  };
+  try {
+    if (r.hasFocus() && t === null || t === !1)
+      return !0;
+  } catch {
+    return !1;
+  }
+  if (s && t === null && !Wt(n.state.selection))
+    return i(), !0;
+  const c = Ut(o.doc, t) || n.state.selection, a = n.state.selection.eq(c);
+  return s && (a || o.setSelection(c), a && o.storedMarks && o.setStoredMarks(o.storedMarks), i()), !0;
+}, vn = (t, e) => (n) => t.every((r, o) => e(r, { ...n, index: o })), bn = (t, e) => ({ tr: n, commands: r }) => r.insertContentAt(
+  { from: n.selection.from, to: n.selection.to },
+  t,
+  e
+), qt = (t) => {
+  const e = t.childNodes;
+  for (let n = e.length - 1; n >= 0; n -= 1) {
+    const r = e[n];
+    r.nodeType === 3 && r.nodeValue && /^(\n\s\s|\n)$/.test(r.nodeValue) ? t.removeChild(r) : r.nodeType === 1 && qt(r);
+  }
+  return t;
+};
+function U(t) {
+  if (typeof window > "u")
+    throw new Error(
+      "[tiptap error]: there is no window object available, so this function cannot be used"
+    );
+  const e = `<body>${t}</body>`, n = new window.DOMParser().parseFromString(e, "text/html").body;
+  return qt(n);
+}
+function K(t, e, n) {
+  if (t instanceof zt || t instanceof j)
+    return t;
+  n = {
+    slice: !0,
+    parseOptions: {},
+    ...n
+  };
+  const r = typeof t == "object" && t !== null, o = typeof t == "string";
+  if (r)
+    try {
+      if (Array.isArray(t) && t.length > 0)
+        return j.fromArray(t.map((c) => e.nodeFromJSON(c)));
+      const i = e.nodeFromJSON(t);
+      return n.errorOnInvalidContent && i.check(), i;
+    } catch (s) {
+      if (n.errorOnInvalidContent)
+        throw new Error("[tiptap error]: Invalid JSON content", { cause: s });
+      return console.warn("[tiptap warn]: Invalid content.", "Passed value:", t, "Error:", s), K("", e, n);
+    }
+  if (o) {
+    if (n.errorOnInvalidContent) {
+      let i = !1, c = "";
+      const a = new Ft({
+        topNode: e.spec.topNode,
+        marks: e.spec.marks,
+        // Prosemirror's schemas are executed such that: the last to execute, matches last
+        // This means that we can add a catch-all node at the end of the schema to catch any content that we don't know how to handle
+        nodes: e.spec.nodes.append({
+          __tiptap__private__unknown__catch__all__node: {
+            content: "inline*",
+            group: "block",
+            parseDOM: [
+              {
+                tag: "*",
+                getAttrs: (l) => (i = !0, c = typeof l == "string" ? l : l.outerHTML, null)
+              }
+            ]
+          }
+        })
+      });
+      if (n.slice ? tt.fromSchema(a).parseSlice(
+        U(t),
+        n.parseOptions
+      ) : tt.fromSchema(a).parse(
+        U(t),
+        n.parseOptions
+      ), n.errorOnInvalidContent && i)
+        throw new Error("[tiptap error]: Invalid HTML content", {
+          cause: new Error(`Invalid element found: ${c}`)
+        });
+    }
+    const s = tt.fromSchema(e);
+    return n.slice ? s.parseSlice(U(t), n.parseOptions).content : s.parse(U(t), n.parseOptions);
+  }
+  return K("", e, n);
+}
+function yn(t, e, n) {
+  const r = t.steps.length - 1;
+  if (r < e)
+    return;
+  const o = t.steps[r];
+  if (!(o instanceof Me || o instanceof Se))
+    return;
+  const s = t.mapping.maps[r];
+  let i = 0;
+  s.forEach((c, a, l, f) => {
+    i === 0 && (i = f);
+  }), t.setSelection(F.near(t.doc.resolve(i), n));
+}
+var kn = (t) => !("type" in t), wn = (t, e, n) => ({ tr: r, dispatch: o, editor: s }) => {
+  var i;
+  if (o) {
+    n = {
+      parseOptions: s.options.parseOptions,
+      updateSelection: !0,
+      applyInputRules: !1,
+      applyPasteRules: !1,
+      ...n
+    };
+    let c;
+    const a = (g) => {
+      s.emit("contentError", {
+        editor: s,
+        error: g,
+        disableCollaboration: () => {
+          "collaboration" in s.storage && typeof s.storage.collaboration == "object" && s.storage.collaboration && (s.storage.collaboration.isDisabled = !0);
+        }
+      });
+    }, l = {
+      preserveWhitespace: "full",
+      ...n.parseOptions
+    };
+    if (!n.errorOnInvalidContent && !s.options.enableContentCheck && s.options.emitContentError)
+      try {
+        K(e, s.schema, {
+          parseOptions: l,
+          errorOnInvalidContent: !0
+        });
+      } catch (g) {
+        a(g);
+      }
+    try {
+      c = K(e, s.schema, {
+        parseOptions: l,
+        errorOnInvalidContent: (i = n.errorOnInvalidContent) != null ? i : s.options.enableContentCheck
+      });
+    } catch (g) {
+      return a(g), !1;
+    }
+    let { from: f, to: u } = typeof t == "number" ? { from: t, to: t } : { from: t.from, to: t.to }, p = !0, d = !0;
+    if ((kn(c) ? c : [c]).forEach((g) => {
+      g.check(), p = p ? g.isText && g.marks.length === 0 : !1, d = d ? g.isBlock : !1;
+    }), f === u && d) {
+      const { parent: g } = r.doc.resolve(f);
+      g.isTextblock && !g.type.spec.code && !g.childCount && (f -= 1, u += 1);
+    }
+    let m;
+    if (p) {
+      if (Array.isArray(e))
+        m = e.map((g) => g.text || "").join("");
+      else if (e instanceof j) {
+        let g = "";
+        e.forEach((v) => {
+          v.text && (g += v.text);
+        }), m = g;
+      } else typeof e == "object" && e && e.text ? m = e.text : m = e;
+      r.insertText(m, f, u);
+    } else {
+      m = c;
+      const g = r.doc.resolve(f), v = g.node(), y = g.parentOffset === 0, w = v.isText || v.isTextblock, x = v.content.size > 0;
+      y && w && x && d && (f = Math.max(0, f - 1)), r.replaceWith(f, u, m);
+    }
+    n.updateSelection && yn(r, r.steps.length - 1, -1), n.applyInputRules && r.setMeta("applyInputRules", { from: f, text: m }), n.applyPasteRules && r.setMeta("applyPasteRules", { from: f, text: m });
+  }
+  return !0;
+}, xn = () => ({ state: t, dispatch: e }) => Ae(t, e), Mn = () => ({ state: t, dispatch: e }) => Ce(t, e), Sn = () => ({ state: t, dispatch: e }) => Pe(t, e), En = () => ({ state: t, dispatch: e }) => $e(t, e), Tn = () => ({ state: t, dispatch: e, tr: n }) => {
+  try {
+    const r = Lt(t.doc, t.selection.$from.pos, -1);
+    return r == null ? !1 : (n.join(r, 2), e && e(n), !0);
+  } catch {
+    return !1;
+  }
+}, An = () => ({ state: t, dispatch: e, tr: n }) => {
+  try {
+    const r = Lt(t.doc, t.selection.$from.pos, 1);
+    return r == null ? !1 : (n.join(r, 2), e && e(n), !0);
+  } catch {
+    return !1;
+  }
+}, Cn = () => ({ state: t, dispatch: e }) => Ne(t, e), Pn = () => ({ state: t, dispatch: e }) => Ie(t, e);
+function Jt() {
+  return typeof navigator < "u" ? /Mac/.test(navigator.platform) : !1;
+}
+function $n(t) {
+  const e = t.split(/-(?!$)/);
+  let n = e[e.length - 1];
+  n === "Space" && (n = " ");
+  let r, o, s, i;
+  for (let c = 0; c < e.length - 1; c += 1) {
+    const a = e[c];
+    if (/^(cmd|meta|m)$/i.test(a))
+      i = !0;
+    else if (/^a(lt)?$/i.test(a))
+      r = !0;
+    else if (/^(c|ctrl|control)$/i.test(a))
+      o = !0;
+    else if (/^s(hift)?$/i.test(a))
+      s = !0;
+    else if (/^mod$/i.test(a))
+      rt() || Jt() ? i = !0 : o = !0;
+    else
+      throw new Error(`Unrecognized modifier name: ${a}`);
+  }
+  return r && (n = `Alt-${n}`), o && (n = `Ctrl-${n}`), i && (n = `Meta-${n}`), s && (n = `Shift-${n}`), n;
+}
+var Nn = (t) => ({ editor: e, view: n, tr: r, dispatch: o }) => {
+  const s = $n(t).split(/-(?!$)/), i = s.find((l) => !["Alt", "Ctrl", "Meta", "Shift"].includes(l)), c = new KeyboardEvent("keydown", {
+    key: i === "Space" ? " " : i,
+    altKey: s.includes("Alt"),
+    ctrlKey: s.includes("Ctrl"),
+    metaKey: s.includes("Meta"),
+    shiftKey: s.includes("Shift"),
+    bubbles: !0,
+    cancelable: !0
+  }), a = e.captureTransaction(() => {
+    n.someProp("handleKeyDown", (l) => l(n, c));
+  });
+  return a?.steps.forEach((l) => {
+    const f = l.map(r.mapping);
+    f && o && r.maybeStep(f);
+  }), !0;
+};
+function Q(t, e, n = {}) {
+  const { from: r, to: o, empty: s } = t.selection, i = e ? T(e, t.schema) : null, c = [];
+  t.doc.nodesBetween(r, o, (u, p) => {
+    if (u.isText)
+      return;
+    const d = Math.max(r, p), h = Math.min(o, p + u.nodeSize);
+    c.push({
+      node: u,
+      from: d,
+      to: h
+    });
+  });
+  const a = o - r, l = c.filter((u) => i ? i.name === u.node.type.name : !0).filter((u) => nt(u.node.attrs, n, { strict: !1 }));
+  return s ? !!l.length : l.reduce((u, p) => u + p.to - p.from, 0) >= a;
+}
+var In = (t, e = {}) => ({ state: n, dispatch: r }) => {
+  const o = T(t, n.schema);
+  return Q(n, o, e) ? Oe(n, r) : !1;
+}, On = () => ({ state: t, dispatch: e }) => Re(t, e), Rn = (t) => ({ state: e, dispatch: n }) => {
+  const r = T(t, e.schema);
+  return qe(r)(e, n);
+}, Bn = () => ({ state: t, dispatch: e }) => Be(t, e);
+function ct(t, e) {
+  return e.nodes[t] ? "node" : e.marks[t] ? "mark" : null;
+}
+function It(t, e) {
+  const n = typeof e == "string" ? [e] : e;
+  return Object.keys(t).reduce((r, o) => (n.includes(o) || (r[o] = t[o]), r), {});
+}
+var Dn = (t, e) => ({ tr: n, state: r, dispatch: o }) => {
+  let s = null, i = null;
+  const c = ct(
+    typeof t == "string" ? t : t.name,
+    r.schema
+  );
+  if (!c)
+    return !1;
+  c === "node" && (s = T(t, r.schema)), c === "mark" && (i = D(t, r.schema));
+  let a = !1;
+  return n.selection.ranges.forEach((l) => {
+    r.doc.nodesBetween(l.$from.pos, l.$to.pos, (f, u) => {
+      s && s === f.type && (a = !0, o && n.setNodeMarkup(u, void 0, It(f.attrs, e))), i && f.marks.length && f.marks.forEach((p) => {
+        i === p.type && (a = !0, o && n.addMark(
+          u,
+          u + f.nodeSize,
+          i.create(It(p.attrs, e))
+        ));
+      });
+    });
+  }), a;
+}, jn = () => ({ tr: t, dispatch: e }) => (e && t.scrollIntoView(), !0), _n = () => ({ tr: t, dispatch: e }) => {
+  if (e) {
+    const n = new He(t.doc);
+    t.setSelection(n);
+  }
+  return !0;
+}, Ln = () => ({ state: t, dispatch: e }) => De(t, e), zn = () => ({ state: t, dispatch: e }) => je(t, e), Fn = () => ({ state: t, dispatch: e }) => _e(t, e), Vn = () => ({ state: t, dispatch: e }) => Le(t, e), Hn = () => ({ state: t, dispatch: e }) => ze(t, e);
+function gt(t, e, n = {}, r = {}) {
+  return K(t, e, {
+    slice: !1,
+    parseOptions: n,
+    errorOnInvalidContent: r.errorOnInvalidContent
+  });
+}
+var Wn = (t, { errorOnInvalidContent: e, emitUpdate: n = !0, parseOptions: r = {} } = {}) => ({ editor: o, tr: s, dispatch: i, commands: c }) => {
+  const { doc: a } = s;
+  if (r.preserveWhitespace !== "full") {
+    const l = gt(t, o.schema, r, {
+      errorOnInvalidContent: e ?? o.options.enableContentCheck
+    });
+    return i && s.replaceWith(0, a.content.size, l).setMeta("preventUpdate", !n), !0;
+  }
+  return i && s.setMeta("preventUpdate", !n), c.insertContentAt({ from: 0, to: a.content.size }, t, {
+    parseOptions: r,
+    errorOnInvalidContent: e ?? o.options.enableContentCheck
+  });
+};
+function Kt(t, e) {
+  const n = D(e, t.schema), { from: r, to: o, empty: s } = t.selection, i = [];
+  s ? (t.storedMarks && i.push(...t.storedMarks), i.push(...t.selection.$head.marks())) : t.doc.nodesBetween(r, o, (a) => {
+    i.push(...a.marks);
+  });
+  const c = i.find((a) => a.type.name === n.name);
+  return c ? { ...c.attrs } : {};
+}
+function Un(t, e) {
+  const n = new ke(t);
+  return e.forEach((r) => {
+    r.steps.forEach((o) => {
+      n.step(o);
+    });
+  }), n;
+}
+function qn(t) {
+  for (let e = 0; e < t.edgeCount; e += 1) {
+    const { type: n } = t.edge(e);
+    if (n.isTextblock && !n.hasRequiredAttrs())
+      return n;
+  }
+  return null;
+}
+function co(t, e, n) {
+  const r = [];
+  return t.nodesBetween(e.from, e.to, (o, s) => {
+    n(o) && r.push({
+      node: o,
+      pos: s
+    });
+  }), r;
+}
+function Jn(t, e) {
+  for (let n = t.depth; n > 0; n -= 1) {
+    const r = t.node(n);
+    if (e(r))
+      return {
+        pos: n > 0 ? t.before(n) : 0,
+        start: t.start(n),
+        depth: n,
+        node: r
+      };
+  }
+}
+function lt(t) {
+  return (e) => Jn(e.$from, t);
+}
+function b(t, e, n) {
+  return t.config[e] === void 0 && t.parent ? b(t.parent, e, n) : typeof t.config[e] == "function" ? t.config[e].bind({
+    ...n,
+    parent: t.parent ? b(t.parent, e, n) : null
+  }) : t.config[e];
+}
+function xt(t) {
+  return t.map((e) => {
+    const n = {
+      name: e.name,
+      options: e.options,
+      storage: e.storage
+    }, r = b(
+      e,
+      "addExtensions",
+      n
+    );
+    return r ? [e, ...xt(r())] : e;
+  }).flat(10);
+}
+function ut(t, e) {
+  const n = We.fromSchema(e).serializeFragment(t), o = document.implementation.createHTMLDocument().createElement("div");
+  return o.appendChild(n), o.innerHTML;
+}
+function Qt(t) {
+  return typeof t == "function";
+}
+function M(t, e = void 0, ...n) {
+  return Qt(t) ? e ? t.bind(e)(...n) : t(...n) : t;
+}
+function Kn(t = {}) {
+  return Object.keys(t).length === 0 && t.constructor === Object;
+}
+function V(t) {
+  const e = t.filter(
+    (o) => o.type === "extension"
+  ), n = t.filter((o) => o.type === "node"), r = t.filter((o) => o.type === "mark");
+  return {
+    baseExtensions: e,
+    nodeExtensions: n,
+    markExtensions: r
+  };
+}
+function Zt(t) {
+  const e = [], { nodeExtensions: n, markExtensions: r } = V(t), o = [...n, ...r], s = {
+    default: null,
+    validate: void 0,
+    rendered: !0,
+    renderHTML: null,
+    parseHTML: null,
+    keepOnSplit: !0,
+    isRequired: !1
+  }, i = n.filter((l) => l.name !== "text").map((l) => l.name), c = r.map((l) => l.name), a = [...i, ...c];
+  return t.forEach((l) => {
+    const f = {
+      name: l.name,
+      options: l.options,
+      storage: l.storage,
+      extensions: o
+    }, u = b(
+      l,
+      "addGlobalAttributes",
+      f
+    );
+    if (!u)
+      return;
+    u().forEach((d) => {
+      let h;
+      Array.isArray(d.types) ? h = d.types : d.types === "*" ? h = a : d.types === "nodes" ? h = i : d.types === "marks" ? h = c : h = [], h.forEach((m) => {
+        Object.entries(d.attributes).forEach(([g, v]) => {
+          e.push({
+            type: m,
+            name: g,
+            attribute: {
+              ...s,
+              ...v
+            }
+          });
+        });
+      });
+    });
+  }), o.forEach((l) => {
+    const f = {
+      name: l.name,
+      options: l.options,
+      storage: l.storage
+    }, u = b(l, "addAttributes", f);
+    if (!u)
+      return;
+    const p = u();
+    Object.entries(p).forEach(([d, h]) => {
+      const m = {
+        ...s,
+        ...h
+      };
+      typeof m?.default == "function" && (m.default = m.default()), m?.isRequired && m?.default === void 0 && delete m.default, e.push({
+        type: l.name,
+        name: d,
+        attribute: m
+      });
+    });
+  }), e;
+}
+function Qn(t) {
+  const e = [];
+  let n = "", r = !1, o = !1, s = 0;
+  const i = t.length;
+  for (let c = 0; c < i; c += 1) {
+    const a = t[c];
+    if (a === "'" && !o) {
+      r = !r, n += a;
+      continue;
+    }
+    if (a === '"' && !r) {
+      o = !o, n += a;
+      continue;
+    }
+    if (!r && !o) {
+      if (a === "(") {
+        s += 1, n += a;
+        continue;
+      }
+      if (a === ")" && s > 0) {
+        s -= 1, n += a;
+        continue;
+      }
+      if (a === ";" && s === 0) {
+        e.push(n), n = "";
+        continue;
+      }
+    }
+    n += a;
+  }
+  return n && e.push(n), e;
+}
+function Ot(t) {
+  const e = [], n = Qn(t || ""), r = n.length;
+  for (let o = 0; o < r; o += 1) {
+    const s = n[o], i = s.indexOf(":");
+    if (i === -1)
+      continue;
+    const c = s.slice(0, i).trim(), a = s.slice(i + 1).trim();
+    c && a && e.push([c, a]);
+  }
+  return e;
+}
+function Zn(...t) {
+  return t.filter((e) => !!e).reduce((e, n) => {
+    const r = { ...e };
+    return Object.entries(n).forEach(([o, s]) => {
+      if (!r[o]) {
+        r[o] = s;
+        return;
+      }
+      if (o === "class") {
+        const c = s ? String(s).split(" ") : [], a = r[o] ? r[o].split(" ") : [], l = c.filter(
+          (f) => !a.includes(f)
+        );
+        r[o] = [...a, ...l].join(" ");
+      } else if (o === "style") {
+        const c = new Map([
+          ...Ot(r[o]),
+          ...Ot(s)
+        ]);
+        r[o] = Array.from(c.entries()).map(([a, l]) => `${a}: ${l}`).join("; ");
+      } else
+        r[o] = s;
+    }), r;
+  }, {});
+}
+function ot(t, e) {
+  return e.filter((n) => n.type === t.type.name).filter((n) => n.attribute.rendered).map((n) => n.attribute.renderHTML ? n.attribute.renderHTML(t.attrs) || {} : {
+    [n.name]: t.attrs[n.name]
+  }).reduce((n, r) => Zn(n, r), {});
+}
+function Gn(t) {
+  return typeof t != "string" ? t : t.match(/^[+-]?(?:\d*\.)?\d+$/) ? Number(t) : t === "true" ? !0 : t === "false" ? !1 : t;
+}
+function Rt(t, e) {
+  return "style" in t ? t : {
+    ...t,
+    getAttrs: (n) => {
+      const r = t.getAttrs ? t.getAttrs(n) : t.attrs;
+      if (r === !1)
+        return !1;
+      const o = e.reduce((s, i) => {
+        const c = i.attribute.parseHTML ? i.attribute.parseHTML(n) : Gn(n.getAttribute(i.name));
+        return c == null ? s : {
+          ...s,
+          [i.name]: c
+        };
+      }, {});
+      return { ...r, ...o };
+    }
+  };
+}
+function Bt(t) {
+  return Object.fromEntries(
+    // @ts-ignore
+    Object.entries(t).filter(([e, n]) => e === "attrs" && Kn(n) ? !1 : n != null)
+  );
+}
+function Dt(t) {
+  var e, n;
+  const r = {};
+  return !((e = t?.attribute) != null && e.isRequired) && "default" in (t?.attribute || {}) && (r.default = t.attribute.default), ((n = t?.attribute) == null ? void 0 : n.validate) !== void 0 && (r.validate = t.attribute.validate), [t.name, r];
+}
+function Gt(t, e) {
+  var n;
+  const r = Zt(t), { nodeExtensions: o, markExtensions: s } = V(t), i = (n = o.find((l) => b(l, "topNode"))) == null ? void 0 : n.name, c = Object.fromEntries(
+    o.map((l) => {
+      const f = r.filter(
+        (v) => v.type === l.name
+      ), u = {
+        name: l.name,
+        options: l.options,
+        storage: l.storage,
+        editor: e
+      }, p = t.reduce((v, y) => {
+        const w = b(
+          y,
+          "extendNodeSchema",
+          u
+        );
+        return {
+          ...v,
+          ...w ? w(l) : {}
+        };
+      }, {}), d = Bt({
+        ...p,
+        content: M(
+          b(l, "content", u)
+        ),
+        marks: M(b(l, "marks", u)),
+        group: M(b(l, "group", u)),
+        inline: M(b(l, "inline", u)),
+        atom: M(b(l, "atom", u)),
+        selectable: M(
+          b(l, "selectable", u)
+        ),
+        draggable: M(
+          b(l, "draggable", u)
+        ),
+        code: M(b(l, "code", u)),
+        whitespace: M(
+          b(l, "whitespace", u)
+        ),
+        linebreakReplacement: M(
+          b(
+            l,
+            "linebreakReplacement",
+            u
+          )
+        ),
+        defining: M(
+          b(l, "defining", u)
+        ),
+        isolating: M(
+          b(l, "isolating", u)
+        ),
+        attrs: Object.fromEntries(f.map(Dt))
+      }), h = M(
+        b(l, "parseHTML", u)
+      );
+      h && (d.parseDOM = h.map(
+        (v) => Rt(v, f)
+      ));
+      const m = b(
+        l,
+        "renderHTML",
+        u
+      );
+      m && (d.toDOM = (v) => m({
+        node: v,
+        HTMLAttributes: ot(v, f)
+      }));
+      const g = b(
+        l,
+        "renderText",
+        u
+      );
+      return g && (d.toText = g), [l.name, d];
+    })
+  ), a = Object.fromEntries(
+    s.map((l) => {
+      const f = r.filter(
+        (g) => g.type === l.name
+      ), u = {
+        name: l.name,
+        options: l.options,
+        storage: l.storage,
+        editor: e
+      }, p = t.reduce((g, v) => {
+        const y = b(
+          v,
+          "extendMarkSchema",
+          u
+        );
+        return {
+          ...g,
+          ...y ? y(l) : {}
+        };
+      }, {}), d = Bt({
+        ...p,
+        inclusive: M(
+          b(l, "inclusive", u)
+        ),
+        excludes: M(
+          b(l, "excludes", u)
+        ),
+        group: M(b(l, "group", u)),
+        spanning: M(
+          b(l, "spanning", u)
+        ),
+        code: M(b(l, "code", u)),
+        attrs: Object.fromEntries(f.map(Dt))
+      }), h = M(
+        b(l, "parseHTML", u)
+      );
+      h && (d.parseDOM = h.map(
+        (g) => Rt(g, f)
+      ));
+      const m = b(
+        l,
+        "renderHTML",
+        u
+      );
+      return m && (d.toDOM = (g) => m({
+        mark: g,
+        HTMLAttributes: ot(g, f)
+      })), [l.name, d];
+    })
+  );
+  return new Ft({
+    topNode: i,
+    nodes: c,
+    marks: a
+  });
+}
+function Yn(t) {
+  const e = t.filter((n, r) => t.indexOf(n) !== r);
+  return Array.from(new Set(e));
+}
+function J(t) {
+  return t.sort((n, r) => {
+    const o = b(n, "priority") || 100, s = b(r, "priority") || 100;
+    return o > s ? -1 : o < s ? 1 : 0;
+  });
+}
+function Mt(t) {
+  const e = J(xt(t)), n = Yn(e.map((r) => r.name));
+  return n.length && console.warn(
+    `[tiptap warn]: Duplicate extension names found: [${n.map((r) => `'${r}'`).join(", ")}]. This can lead to issues.`
+  ), e;
+}
+function Yt(t, e) {
+  const n = Mt(t);
+  return Gt(n, e);
+}
+function lo(t, e) {
+  const n = Yt(e), r = zt.fromJSON(n, t);
+  return ut(r.content, n);
+}
+function uo(t, e) {
+  const n = Yt(e), r = U(t);
+  return tt.fromSchema(n).parse(r).toJSON();
+}
+function Xt(t, e, n) {
+  const { from: r, to: o } = e, { blockSeparator: s = `
+
+`, textSerializers: i = {} } = n || {};
+  let c = "";
+  return t.nodesBetween(r, o, (a, l, f, u) => {
+    var p;
+    a.isBlock && l > r && (c += s);
+    const d = i?.[a.type.name];
+    if (d)
+      return f && (c += d({
+        node: a,
+        pos: l,
+        parent: f,
+        index: u,
+        range: e
+      })), !1;
+    a.isText && (c += (p = a?.text) == null ? void 0 : p.slice(Math.max(r, l) - l, o - l));
+  }), c;
+}
+function Xn(t, e) {
+  const n = {
+    from: 0,
+    to: t.content.size
+  };
+  return Xt(t, n, e);
+}
+function te(t) {
+  return Object.fromEntries(
+    Object.entries(t.nodes).filter(([, e]) => e.spec.toText).map(([e, n]) => [e, n.spec.toText])
+  );
+}
+function tr(t, e) {
+  const n = T(e, t.schema), { from: r, to: o } = t.selection, s = [];
+  t.doc.nodesBetween(r, o, (c) => {
+    s.push(c);
+  });
+  const i = s.reverse().find((c) => c.type.name === n.name);
+  return i ? { ...i.attrs } : {};
+}
+function er(t, e) {
+  const n = ct(
+    typeof e == "string" ? e : e.name,
+    t.schema
+  );
+  return n === "node" ? tr(t, e) : n === "mark" ? Kt(t, e) : {};
+}
+function nr(t, e = JSON.stringify) {
+  const n = {};
+  return t.filter((r) => {
+    const o = e(r);
+    return Object.prototype.hasOwnProperty.call(n, o) ? !1 : n[o] = !0;
+  });
+}
+function rr(t) {
+  const e = nr(t);
+  return e.length === 1 ? e : e.filter((n, r) => !e.filter((s, i) => i !== r).some((s) => n.oldRange.from >= s.oldRange.from && n.oldRange.to <= s.oldRange.to && n.newRange.from >= s.newRange.from && n.newRange.to <= s.newRange.to));
+}
+function or(t) {
+  const { mapping: e, steps: n } = t, r = [];
+  return e.maps.forEach((o, s) => {
+    const i = [];
+    if (o.ranges.length)
+      o.forEach((c, a) => {
+        i.push({ from: c, to: a });
+      });
+    else {
+      const { from: c, to: a } = n[s];
+      if (c === void 0 || a === void 0)
+        return;
+      i.push({ from: c, to: a });
+    }
+    i.forEach(({ from: c, to: a }) => {
+      const l = e.slice(s).map(c, -1), f = e.slice(s).map(a), u = e.invert().map(l, -1), p = e.invert().map(f);
+      r.push({
+        oldRange: {
+          from: u,
+          to: p
+        },
+        newRange: {
+          from: l,
+          to: f
+        }
+      });
+    });
+  }), rr(r);
+}
+function ee(t, e, n) {
+  const r = [];
+  return t === e ? n.resolve(t).marks().forEach((o) => {
+    const s = n.resolve(t), i = wt(s, o.type);
+    i && r.push({
+      mark: o,
+      ...i
+    });
+  }) : n.nodesBetween(t, e, (o, s) => {
+    !o || o?.nodeSize === void 0 || r.push(
+      ...o.marks.map((i) => ({
+        from: s,
+        to: s + o.nodeSize,
+        mark: i
+      }))
+    );
+  }), r;
+}
+var fo = (t, e, n, r = 20) => {
+  const o = t.doc.resolve(n);
+  let s = r, i = null;
+  for (; s > 0 && i === null; ) {
+    const c = o.node(s);
+    c?.type.name === e ? i = c : s -= 1;
+  }
+  return [i, s];
+};
+function W(t, e) {
+  return e.nodes[t] || e.marks[t] || null;
+}
+function et(t, e, n) {
+  return Object.fromEntries(
+    Object.entries(n).filter(([r]) => {
+      const o = t.find((s) => s.type === e && s.name === r);
+      return o ? o.attribute.keepOnSplit : !1;
+    })
+  );
+}
+var sr = (t, e = 500) => {
+  let n = "";
+  const r = t.parentOffset;
+  return t.parent.nodesBetween(
+    Math.max(0, r - e),
+    r,
+    (o, s, i, c) => {
+      var a, l;
+      const f = ((l = (a = o.type.spec).toText) == null ? void 0 : l.call(a, {
+        node: o,
+        pos: s,
+        parent: i,
+        index: c
+      })) || o.textContent || "%leaf%";
+      n += o.isAtom && !o.isText ? f : f.slice(0, Math.max(0, r - s));
+    }
+  ), n;
+};
+function vt(t, e, n = {}) {
+  const { empty: r, ranges: o } = t.selection, s = e ? D(e, t.schema) : null;
+  if (r)
+    return !!(t.storedMarks || t.selection.$from.marks()).filter((u) => s ? s.name === u.type.name : !0).find((u) => nt(u.attrs, n, { strict: !1 }));
+  let i = 0;
+  const c = [];
+  if (o.forEach(({ $from: u, $to: p }) => {
+    const d = u.pos, h = p.pos;
+    t.doc.nodesBetween(d, h, (m, g) => {
+      if (s && m.inlineContent && !m.type.allowsMarkType(s))
+        return !1;
+      if (!m.isText && !m.marks.length)
+        return;
+      const v = Math.max(d, g), y = Math.min(h, g + m.nodeSize), w = y - v;
+      i += w, c.push(
+        ...m.marks.map((x) => ({
+          mark: x,
+          from: v,
+          to: y
+        }))
+      );
+    });
+  }), i === 0)
+    return !1;
+  const a = c.filter((u) => s ? s.name === u.mark.type.name : !0).filter((u) => nt(u.mark.attrs, n, { strict: !1 })).reduce((u, p) => u + p.to - p.from, 0), l = c.filter((u) => s ? u.mark.type !== s && u.mark.type.excludes(s) : !0).reduce((u, p) => u + p.to - p.from, 0);
+  return (a > 0 ? a + l : a) >= i;
+}
+function ir(t, e, n = {}) {
+  if (!e)
+    return Q(t, null, n) || vt(t, null, n);
+  const r = ct(e, t.schema);
+  return r === "node" ? Q(t, e, n) : r === "mark" ? vt(t, e, n) : !1;
+}
+var po = (t, e) => {
+  const { $from: n, $to: r, $anchor: o } = t.selection;
+  if (e) {
+    const s = lt((c) => c.type.name === e)(t.selection);
+    if (!s)
+      return !1;
+    const i = t.doc.resolve(s.pos + 1);
+    return o.pos + 1 === i.end();
+  }
+  return !(r.parentOffset < r.parent.nodeSize - 2 || n.pos !== r.pos);
+}, mo = (t) => {
+  const { $from: e, $to: n } = t.selection;
+  return !(e.parentOffset > 0 || e.pos !== n.pos);
+};
+function jt(t, e) {
+  return Array.isArray(e) ? e.some((n) => (typeof n == "string" ? n : n.name) === t.name) : e;
+}
+function pt(t, e) {
+  const { nodeExtensions: n } = V(e), r = n.find((i) => i.name === t);
+  if (!r)
+    return !1;
+  const o = {
+    name: r.name,
+    options: r.options,
+    storage: r.storage
+  }, s = M(b(r, "group", o));
+  return typeof s != "string" ? !1 : s.split(" ").includes("list");
+}
+function St(t, {
+  checkChildren: e = !0,
+  ignoreWhitespace: n = !1
+} = {}) {
+  var r;
+  if (n) {
+    if (t.type.name === "hardBreak")
+      return !0;
+    if (t.isText)
+      return !/\S/.test((r = t.text) != null ? r : "");
+  }
+  if (t.isText)
+    return !t.text;
+  if (t.isAtom || t.isLeaf)
+    return !1;
+  if (t.content.childCount === 0)
+    return !0;
+  if (e) {
+    let o = !0;
+    return t.content.forEach((s) => {
+      o !== !1 && (St(s, { ignoreWhitespace: n, checkChildren: e }) || (o = !1));
+    }), o;
+  }
+  return !1;
+}
+function ho(t) {
+  return t instanceof st;
+}
+var ne = class re {
+  constructor(e) {
+    this.position = e;
+  }
+  /**
+   * Creates a MappablePosition from a JSON object.
+   */
+  static fromJSON(e) {
+    return new re(e.position);
+  }
+  /**
+   * Converts the MappablePosition to a JSON object.
+   */
+  toJSON() {
+    return {
+      position: this.position
+    };
+  }
+};
+function ar(t, e) {
+  const n = e.mapping.mapResult(t.position);
+  return {
+    position: new ne(n.pos),
+    mapResult: n
+  };
+}
+function cr(t) {
+  return new ne(t);
+}
+function lr(t, e, n) {
+  var r;
+  const { selection: o } = e;
+  let s = null;
+  if (Wt(o) && (s = o.$cursor), s) {
+    const c = (r = t.storedMarks) != null ? r : s.marks();
+    return s.parent.type.allowsMarkType(n) && (!!n.isInSet(c) || !c.some((l) => l.type.excludes(n)));
+  }
+  const { ranges: i } = o;
+  return i.some(({ $from: c, $to: a }) => {
+    let l = c.depth === 0 ? t.doc.inlineContent && t.doc.type.allowsMarkType(n) : !1;
+    return t.doc.nodesBetween(c.pos, a.pos, (f, u, p) => {
+      if (l)
+        return !1;
+      if (f.isInline) {
+        const d = !p || p.type.allowsMarkType(n), h = !!n.isInSet(f.marks) || !f.marks.some((m) => m.type.excludes(n));
+        l = d && h;
+      }
+      return !l;
+    }), l;
+  });
+}
+var ur = (t, e = {}) => ({ tr: n, state: r, dispatch: o }) => {
+  const { selection: s } = n, { empty: i, ranges: c } = s, a = D(t, r.schema);
+  if (o)
+    if (i) {
+      const l = Kt(r, a);
+      n.addStoredMark(
+        a.create({
+          ...l,
+          ...e
+        })
+      );
+    } else
+      c.forEach((l) => {
+        const f = l.$from.pos, u = l.$to.pos;
+        r.doc.nodesBetween(f, u, (p, d) => {
+          const h = Math.max(d, f), m = Math.min(d + p.nodeSize, u);
+          p.marks.find((v) => v.type === a) ? p.marks.forEach((v) => {
+            a === v.type && n.addMark(
+              h,
+              m,
+              a.create({
+                ...v.attrs,
+                ...e
+              })
+            );
+          }) : n.addMark(h, m, a.create(e));
+        });
+      });
+  return lr(r, n, a);
+}, dr = (t, e) => ({ tr: n }) => (n.setMeta(t, e), !0), fr = (t, e = {}) => ({ state: n, dispatch: r, chain: o }) => {
+  const s = T(t, n.schema);
+  let i;
+  return n.selection.$anchor.sameParent(n.selection.$head) && (i = n.selection.$anchor.parent.attrs), s.isTextblock ? o().command(({ commands: c }) => Ct(s, { ...i, ...e })(n) ? !0 : c.clearNodes()).command(({ state: c }) => Ct(s, { ...i, ...e })(c, r)).run() : (console.warn('[tiptap warn]: Currently "setNode()" only supports text block nodes.'), !1);
+}, pr = (t) => ({ tr: e, dispatch: n }) => {
+  if (n) {
+    const { doc: r } = e, o = z(t, 0, r.content.size), s = st.create(r, o);
+    e.setSelection(s);
+  }
+  return !0;
+}, mr = (t, e) => ({ tr: n, state: r, dispatch: o }) => {
+  const { selection: s } = r;
+  let i, c;
+  return typeof e == "number" ? (i = e, c = e) : e && "from" in e && "to" in e ? (i = e.from, c = e.to) : (i = s.from, c = s.to), o && n.doc.nodesBetween(i, c, (a, l) => {
+    a.isText || n.setNodeMarkup(l, void 0, {
+      ...a.attrs,
+      dir: t
+    });
+  }), !0;
+}, hr = (t) => ({ tr: e, dispatch: n }) => {
+  if (n) {
+    const { doc: r } = e, { from: o, to: s } = typeof t == "number" ? { from: t, to: t } : t, i = O.atStart(r).from, c = O.atEnd(r).to, a = z(o, i, c), l = z(s, i, c), f = O.create(r, a, l);
+    e.setSelection(f);
+  }
+  return !0;
+}, gr = (t) => ({ state: e, dispatch: n }) => {
+  const r = T(t, e.schema);
+  return Je(r)(e, n);
+};
+function _t(t, e) {
+  const n = t.storedMarks || t.selection.$to.parentOffset && t.selection.$from.marks();
+  if (n) {
+    const r = n.filter((o) => e?.includes(o.type.name));
+    t.tr.ensureMarks(r);
+  }
+}
+var vr = ({ keepMarks: t = !0 } = {}) => ({ tr: e, state: n, dispatch: r, editor: o }) => {
+  const { selection: s, doc: i } = e, { $from: c, $to: a } = s, l = o.extensionManager.attributes, f = et(
+    l,
+    c.node().type.name,
+    c.node().attrs
+  );
+  if (s instanceof st && s.node.isBlock)
+    return !c.parentOffset || !X(i, c.pos) ? !1 : (r && (t && _t(n, o.extensionManager.splittableMarks), e.split(c.pos).scrollIntoView()), !0);
+  if (!c.parent.isBlock)
+    return !1;
+  const u = a.parentOffset === a.parent.content.size, p = c.depth === 0 ? void 0 : qn(c.node(-1).contentMatchAt(c.indexAfter(-1)));
+  let d = u && p ? [
+    {
+      type: p,
+      attrs: f
+    }
+  ] : void 0, h = X(e.doc, e.mapping.map(c.pos), 1, d);
+  if (!d && !h && X(e.doc, e.mapping.map(c.pos), 1, p ? [{ type: p }] : void 0) && (h = !0, d = p ? [
+    {
+      type: p,
+      attrs: f
+    }
+  ] : void 0), r) {
+    if (h && (s instanceof O && e.deleteSelection(), e.split(e.mapping.map(c.pos), 1, d), p && !u && !c.parentOffset && c.parent.type !== p)) {
+      const m = e.mapping.map(c.before()), g = e.doc.resolve(m);
+      c.node(-1).canReplaceWith(g.index(), g.index() + 1, p) && e.setNodeMarkup(e.mapping.map(c.before()), p);
+    }
+    t && _t(n, o.extensionManager.splittableMarks), e.scrollIntoView();
+  }
+  return h;
+}, br = (t, e = {}) => ({ tr: n, state: r, dispatch: o, editor: s }) => {
+  var i;
+  const c = T(t, r.schema), { $from: a, $to: l } = r.selection, f = r.selection.node;
+  if (f && f.isBlock || a.depth < 2 || !a.sameParent(l))
+    return !1;
+  const u = a.node(-1);
+  if (u.type !== c)
+    return !1;
+  const p = s.extensionManager.attributes;
+  if (a.parent.content.size === 0 && a.node(-1).childCount === a.indexAfter(-1)) {
+    if (a.depth === 2 || a.node(-3).type !== c || a.index(-2) !== a.node(-2).childCount - 1)
+      return !1;
+    if (o) {
+      let v = j.empty;
+      const y = a.index(-1) ? 1 : a.index(-2) ? 2 : 3;
+      for (let A = a.depth - y; A >= a.depth - 3; A -= 1)
+        v = j.from(a.node(A).copy(v));
+      const w = (
+        // oxlint-disable-next-line no-nested-ternary
+        a.indexAfter(-1) < a.node(-2).childCount ? 1 : a.indexAfter(-2) < a.node(-3).childCount ? 2 : 3
+      ), x = {
+        ...et(p, a.node().type.name, a.node().attrs),
+        ...e
+      }, k = ((i = c.contentMatch.defaultType) == null ? void 0 : i.createAndFill(x)) || void 0;
+      v = v.append(j.from(c.createAndFill(null, k) || void 0));
+      const S = a.before(a.depth - (y - 1));
+      n.replace(S, a.after(-w), new Ue(v, 4 - y, 0));
+      let E = -1;
+      n.doc.nodesBetween(S, n.doc.content.size, (A, C) => {
+        if (E > -1)
+          return !1;
+        A.isTextblock && A.content.size === 0 && (E = C + 1);
+      }), E > -1 && n.setSelection(O.near(n.doc.resolve(E))), n.scrollIntoView();
+    }
+    return !0;
+  }
+  const d = l.pos === a.end() ? u.contentMatchAt(0).defaultType : null, h = {
+    ...et(p, u.type.name, u.attrs),
+    ...e
+  }, m = {
+    ...et(p, a.node().type.name, a.node().attrs),
+    ...e
+  };
+  n.delete(a.pos, l.pos);
+  const g = d ? [
+    { type: c, attrs: h },
+    { type: d, attrs: m }
+  ] : [{ type: c, attrs: h }];
+  if (!X(n.doc, a.pos, 2))
+    return !1;
+  if (o) {
+    const { selection: v, storedMarks: y } = r, { splittableMarks: w } = s.extensionManager, x = y || v.$to.parentOffset && v.$from.marks();
+    if (n.split(a.pos, 2, g).scrollIntoView(), !x || !o)
+      return !0;
+    const k = x.filter((S) => w.includes(S.type.name));
+    n.ensureMarks(k);
+  }
+  return !0;
+}, mt = (t, e) => {
+  const n = lt((i) => i.type === e)(t.selection);
+  if (!n)
+    return !0;
+  const r = t.doc.resolve(Math.max(0, n.pos - 1)).before(n.depth);
+  if (r === void 0)
+    return !0;
+  const o = t.doc.nodeAt(r);
+  return n.node.type === o?.type && bt(t.doc, n.pos) && t.join(n.pos), !0;
+}, ht = (t, e) => {
+  const n = lt((i) => i.type === e)(t.selection);
+  if (!n)
+    return !0;
+  const r = t.doc.resolve(n.start).after(n.depth);
+  if (r === void 0)
+    return !0;
+  const o = t.doc.nodeAt(r);
+  return n.node.type === o?.type && bt(t.doc, r) && t.join(r), !0;
+};
+function yr(t) {
+  const e = t.doc, n = e.firstChild;
+  if (!n)
+    return null;
+  const r = e.resolve(1), o = e.resolve(n.nodeSize - 1);
+  return O.between(r, o);
+}
+var kr = (t, e, n, r = {}) => ({ editor: o, tr: s, state: i, dispatch: c, chain: a, commands: l, can: f }) => {
+  const { extensions: u, splittableMarks: p } = o.extensionManager, d = T(t, i.schema), h = T(e, i.schema), { selection: m, storedMarks: g } = i, { $from: v, $to: y } = m, w = v.blockRange(y), x = g || m.$to.parentOffset && m.$from.marks();
+  if (!w)
+    return !1;
+  const k = lt((I) => pt(I.type.name, u))(m), S = m.from === 0 && m.to === i.doc.content.size, E = i.doc.content.content, A = E.length === 1 ? E[0] : null, C = S && A && pt(A.type.name, u) ? {
+    node: A,
+    pos: 0
+  } : null, $ = k ?? C, H = !!k && w.depth >= 1 && w.depth - k.depth <= 1, L = !!C;
+  if ((H || L) && $) {
+    if ($.node.type === d)
+      return S && L ? a().command(({ tr: I, dispatch: N }) => {
+        const P = yr(I);
+        return P ? (I.setSelection(P), N && N(I), !0) : !1;
+      }).liftListItem(h).run() : l.liftListItem(h);
+    if (pt($.node.type.name, u) && d.validContent($.node.content))
+      return a().command(() => (s.setNodeMarkup($.pos, d), !0)).command(() => mt(s, d)).command(() => ht(s, d)).run();
+  }
+  return !n || !x || !c ? a().command(() => f().wrapInList(d, r) ? !0 : l.clearNodes()).wrapInList(d, r).command(() => mt(s, d)).command(() => ht(s, d)).run() : a().command(() => {
+    const I = f().wrapInList(d, r), N = x.filter((P) => p.includes(P.type.name));
+    return s.ensureMarks(N), I ? !0 : l.clearNodes();
+  }).wrapInList(d, r).command(() => mt(s, d)).command(() => ht(s, d)).run();
+}, wr = (t, e = {}, n = {}) => ({ state: r, commands: o }) => {
+  const { extendEmptyMarkRange: s = !1 } = n, i = D(t, r.schema);
+  return vt(r, i, e) ? o.unsetMark(i, { extendEmptyMarkRange: s }) : o.setMark(i, e);
+}, xr = (t, e, n = {}) => ({ state: r, commands: o }) => {
+  const s = T(t, r.schema), i = T(e, r.schema), c = Q(r, s, n);
+  let a;
+  return r.selection.$anchor.sameParent(r.selection.$head) && (a = r.selection.$anchor.parent.attrs), c ? o.setNode(i, a) : o.setNode(s, { ...a, ...n });
+}, Mr = (t, e = {}) => ({ state: n, commands: r }) => {
+  const o = T(t, n.schema);
+  return Q(n, o, e) ? r.lift(o) : r.wrapIn(o, e);
+}, Sr = () => ({ state: t, dispatch: e }) => {
+  const n = t.plugins;
+  for (let r = 0; r < n.length; r += 1) {
+    const o = n[r];
+    let s;
+    if (o.spec.isInputRules && (s = o.getState(t))) {
+      if (e) {
+        const i = t.tr, c = s.transform;
+        for (let a = c.steps.length - 1; a >= 0; a -= 1)
+          i.step(c.steps[a].invert(c.docs[a]));
+        if (s.text) {
+          const a = i.doc.resolve(s.from).marks();
+          i.replaceWith(s.from, s.to, t.schema.text(s.text, a));
+        } else
+          i.delete(s.from, s.to);
+      }
+      return !0;
+    }
+  }
+  return !1;
+}, Er = () => ({ tr: t, dispatch: e }) => {
+  const { selection: n } = t, { empty: r, ranges: o } = n;
+  return r || e && o.forEach((s) => {
+    t.removeMark(s.$from.pos, s.$to.pos);
+  }), !0;
+}, Tr = (t, e = {}) => ({ tr: n, state: r, dispatch: o }) => {
+  var s;
+  const { extendEmptyMarkRange: i = !1 } = e, { selection: c } = n, a = D(t, r.schema), { $from: l, empty: f, ranges: u } = c;
+  if (!o)
+    return !0;
+  if (f && i) {
+    let { from: p, to: d } = c;
+    const h = (s = l.marks().find((g) => g.type === a)) == null ? void 0 : s.attrs, m = wt(l, a, h);
+    m && (p = m.from, d = m.to), n.removeMark(p, d, a);
+  } else
+    u.forEach((p) => {
+      n.removeMark(p.$from.pos, p.$to.pos, a);
+    });
+  return n.removeStoredMark(a), !0;
+}, Ar = (t) => ({ tr: e, state: n, dispatch: r }) => {
+  const { selection: o } = n;
+  let s, i;
+  return typeof t == "number" ? (s = t, i = t) : t && "from" in t && "to" in t ? (s = t.from, i = t.to) : (s = o.from, i = o.to), r && e.doc.nodesBetween(s, i, (c, a) => {
+    if (c.isText)
+      return;
+    const l = { ...c.attrs };
+    delete l.dir, e.setNodeMarkup(a, void 0, l);
+  }), !0;
+}, Cr = (t, e = {}) => ({ tr: n, state: r, dispatch: o }) => {
+  let s = null, i = null;
+  const c = ct(
+    typeof t == "string" ? t : t.name,
+    r.schema
+  );
+  if (!c)
+    return !1;
+  c === "node" && (s = T(t, r.schema)), c === "mark" && (i = D(t, r.schema));
+  let a = !1;
+  return n.selection.ranges.forEach((l) => {
+    const f = l.$from.pos, u = l.$to.pos;
+    let p, d, h, m;
+    n.selection.empty ? r.doc.nodesBetween(f, u, (g, v) => {
+      s && s === g.type && (a = !0, h = Math.max(v, f), m = Math.min(v + g.nodeSize, u), p = v, d = g);
+    }) : r.doc.nodesBetween(f, u, (g, v) => {
+      v < f && s && s === g.type && (a = !0, h = Math.max(v, f), m = Math.min(v + g.nodeSize, u), p = v, d = g), v >= f && v <= u && (s && s === g.type && (a = !0, o && n.setNodeMarkup(v, void 0, {
+        ...g.attrs,
+        ...e
+      })), i && g.marks.length && g.marks.forEach((y) => {
+        if (i === y.type && (a = !0, o)) {
+          const w = Math.max(v, f), x = Math.min(v + g.nodeSize, u);
+          n.addMark(
+            w,
+            x,
+            i.create({
+              ...y.attrs,
+              ...e
+            })
+          );
+        }
+      }));
+    }), d && (p !== void 0 && o && n.setNodeMarkup(p, void 0, {
+      ...d.attrs,
+      ...e
+    }), i && d.marks.length && d.marks.forEach((g) => {
+      i === g.type && o && n.addMark(
+        h,
+        m,
+        i.create({
+          ...g.attrs,
+          ...e
+        })
+      );
+    }));
+  }), a;
+}, Pr = (t, e = {}) => ({ state: n, dispatch: r }) => {
+  const o = T(t, n.schema);
+  return Fe(o, e)(n, r);
+}, $r = (t, e = {}) => ({ state: n, dispatch: r }) => {
+  const o = T(t, n.schema);
+  return Ke(o, e)(n, r);
+}, Nr = class {
+  constructor() {
+    this.callbacks = {};
+  }
+  on(t, e) {
+    return this.callbacks[t] || (this.callbacks[t] = []), this.callbacks[t].push(e), this;
+  }
+  emit(t, ...e) {
+    const n = this.callbacks[t];
+    return n && n.forEach((r) => r.apply(this, e)), this;
+  }
+  off(t, e) {
+    const n = this.callbacks[t];
+    return n && (e ? this.callbacks[t] = n.filter((r) => r !== e) : delete this.callbacks[t]), this;
+  }
+  once(t, e) {
+    const n = (...r) => {
+      this.off(t, n), e.apply(this, r);
+    };
+    return this.on(t, n);
+  }
+  removeAllListeners() {
+    this.callbacks = {};
+  }
+}, dt = class {
+  constructor(t) {
+    var e;
+    this.find = t.find, this.handler = t.handler, this.undoable = (e = t.undoable) != null ? e : !0;
+  }
+}, Ir = (t, e) => {
+  if (kt(e))
+    return e.exec(t);
+  const n = e(t);
+  if (!n)
+    return null;
+  const r = [n.text];
+  return r.index = n.index, r.input = t, r.data = n.data, n.replaceWith && (n.text.includes(n.replaceWith) || console.warn(
+    '[tiptap warn]: "inputRuleMatch.replaceWith" must be part of "inputRuleMatch.text".'
+  ), r.push(n.replaceWith)), r;
+};
+function Z(t) {
+  var e;
+  const { editor: n, from: r, to: o, text: s, rules: i, plugin: c } = t, { view: a } = n;
+  if (a.composing)
+    return !1;
+  const l = a.state.doc.resolve(r);
+  if (
+    // check for code node
+    l.parent.type.spec.code || (e = l.nodeBefore || l.nodeAfter) != null && e.marks.find((p) => p.type.spec.code)
+  )
+    return !1;
+  let f = !1;
+  const u = sr(l) + s;
+  return i.forEach((p) => {
+    if (f)
+      return;
+    const d = Ir(u, p.find);
+    if (!d)
+      return;
+    const h = a.state.tr, m = it({
+      state: a.state,
+      transaction: h
+    }), g = {
+      from: r - (d[0].length - s.length),
+      to: o
+    }, { commands: v, chain: y, can: w } = new at({
+      editor: n,
+      state: m
+    });
+    p.handler({
+      state: m,
+      range: g,
+      match: d,
+      commands: v,
+      chain: y,
+      can: w
+    }) === null || !h.steps.length || (p.undoable && h.setMeta(c, {
+      transform: h,
+      from: r,
+      to: o,
+      text: s
+    }), a.dispatch(h), f = !0);
+  }), f;
+}
+function Or(t) {
+  const { editor: e, rules: n } = t, r = new R({
+    state: {
+      init() {
+        return null;
+      },
+      apply(o, s, i) {
+        const c = o.getMeta(r);
+        if (c)
+          return c;
+        const a = o.getMeta("applyInputRules");
+        return a && setTimeout(() => {
+          let { text: f } = a;
+          typeof f == "string" ? f = f : f = ut(j.from(f), i.schema);
+          const { from: u } = a, p = u + f.length;
+          Z({
+            editor: e,
+            from: u,
+            to: p,
+            text: f,
+            rules: n,
+            plugin: r
+          });
+        }), o.selectionSet || o.docChanged ? null : s;
+      }
+    },
+    props: {
+      handleTextInput(o, s, i, c) {
+        return Z({
+          editor: e,
+          from: s,
+          to: i,
+          text: c,
+          rules: n,
+          plugin: r
+        });
+      },
+      handleDOMEvents: {
+        compositionend: (o) => (setTimeout(() => {
+          const { $cursor: s } = o.state.selection;
+          s && Z({
+            editor: e,
+            from: s.pos,
+            to: s.pos,
+            text: "",
+            rules: n,
+            plugin: r
+          });
+        }), !1)
+      },
+      // add support for input rules to trigger on enter
+      // this is useful for example for code blocks
+      handleKeyDown(o, s) {
+        if (s.key !== "Enter")
+          return !1;
+        const { $cursor: i } = o.state.selection;
+        return i ? Z({
+          editor: e,
+          from: i.pos,
+          to: i.pos,
+          text: `
+`,
+          rules: n,
+          plugin: r
+        }) : !1;
+      }
+    },
+    // @ts-ignore
+    isInputRules: !0
+  });
+  return r;
+}
+function Rr(t) {
+  return Object.prototype.toString.call(t).slice(8, -1);
+}
+function G(t) {
+  return Rr(t) !== "Object" ? !1 : t.constructor === Object && Object.getPrototypeOf(t) === Object.prototype;
+}
+function oe(t, e) {
+  const n = { ...t };
+  return G(t) && G(e) && Object.keys(e).forEach((r) => {
+    G(e[r]) && G(t[r]) ? n[r] = oe(t[r], e[r]) : n[r] = e[r];
+  }), n;
+}
+var Et = class {
+  constructor(t = {}) {
+    this.type = "extendable", this.parent = null, this.child = null, this.name = "", this.config = {
+      name: this.name
+    }, this.config = {
+      ...this.config,
+      ...t
+    }, this.name = this.config.name;
+  }
+  get options() {
+    return {
+      ...M(
+        b(this, "addOptions", {
+          name: this.name
+        })
+      )
+    };
+  }
+  get storage() {
+    return {
+      ...M(
+        b(this, "addStorage", {
+          name: this.name,
+          options: this.options
+        })
+      )
+    };
+  }
+  configure(t = {}) {
+    const e = this.extend({
+      ...this.config,
+      addOptions: () => oe(this.options, t)
+    });
+    return e.name = this.name, e.parent = this.parent, this.child = null, e;
+  }
+  extend(t = {}) {
+    const e = new this.constructor({ ...this.config, ...t });
+    return e.parent = this, this.child = e, e.name = "name" in t ? t.name : e.parent.name, e;
+  }
+}, Br = class se extends Et {
+  constructor() {
+    super(...arguments), this.type = "mark";
+  }
+  /**
+   * Create a new Mark instance
+   * @param config - Mark configuration object or a function that returns a configuration object
+   */
+  static create(e = {}) {
+    const n = typeof e == "function" ? e() : e;
+    return new se(n);
+  }
+  static handleExit({ editor: e, mark: n }) {
+    const { tr: r } = e.state, o = e.state.selection.$from;
+    if (o.pos === o.end()) {
+      const i = o.marks();
+      if (!!!i.find((l) => l?.type.name === n.name))
+        return !1;
+      const a = i.find((l) => l?.type.name === n.name);
+      return a && r.removeStoredMark(a), r.insertText(" ", o.pos), e.view.dispatch(r), !0;
+    }
+    return !1;
+  }
+  configure(e) {
+    return super.configure(e);
+  }
+  extend(e) {
+    const n = typeof e == "function" ? e() : e;
+    return super.extend(n);
+  }
+};
+function Dr(t) {
+  return typeof t == "number";
+}
+var jr = class {
+  constructor(t) {
+    this.find = t.find, this.handler = t.handler;
+  }
+}, _r = (t, e, n) => {
+  if (kt(e))
+    return [...t.matchAll(e)];
+  const r = e(t, n);
+  return r ? r.map((o) => {
+    const s = [o.text];
+    return s.index = o.index, s.input = t, s.data = o.data, o.replaceWith && (o.text.includes(o.replaceWith) || console.warn(
+      '[tiptap warn]: "pasteRuleMatch.replaceWith" must be part of "pasteRuleMatch.text".'
+    ), s.push(o.replaceWith)), s;
+  }) : [];
+};
+function Lr(t) {
+  const { editor: e, state: n, from: r, to: o, rule: s, pasteEvent: i, dropEvent: c } = t, { commands: a, chain: l, can: f } = new at({
+    editor: e,
+    state: n
+  }), u = [];
+  return n.doc.nodesBetween(r, o, (d, h) => {
+    var m, g, v, y, w;
+    if ((g = (m = d.type) == null ? void 0 : m.spec) != null && g.code || !(d.isText || d.isTextblock || d.isInline))
+      return;
+    const x = (w = (y = (v = d.content) == null ? void 0 : v.size) != null ? y : d.nodeSize) != null ? w : 0, k = Math.max(r, h), S = Math.min(o, h + x);
+    if (k >= S)
+      return;
+    const E = d.isText ? d.text || "" : d.textBetween(k - h, S - h, void 0, "");
+    _r(E, s.find, i).forEach((C) => {
+      if (C.index === void 0)
+        return;
+      const $ = k + C.index + 1, H = $ + C[0].length, L = {
+        from: n.tr.mapping.map($),
+        to: n.tr.mapping.map(H)
+      }, I = s.handler({
+        state: n,
+        range: L,
+        match: C,
+        commands: a,
+        chain: l,
+        can: f,
+        pasteEvent: i,
+        dropEvent: c
+      });
+      u.push(I);
+    });
+  }), u.every((d) => d !== null);
+}
+var Y = null, zr = (t) => {
+  var e;
+  const n = new ClipboardEvent("paste", {
+    clipboardData: new DataTransfer()
+  });
+  return (e = n.clipboardData) == null || e.setData("text/html", t), n;
+};
+function Fr(t) {
+  const { editor: e, rules: n } = t;
+  let r = null, o = !1, s = !1, i = typeof ClipboardEvent < "u" ? new ClipboardEvent("paste") : null, c;
+  try {
+    c = typeof DragEvent < "u" ? new DragEvent("drop") : null;
+  } catch {
+    c = null;
+  }
+  const a = ({
+    state: f,
+    from: u,
+    to: p,
+    rule: d,
+    pasteEvt: h
+  }) => {
+    const m = f.tr, g = it({
+      state: f,
+      transaction: m
+    });
+    if (!(!Lr({
+      editor: e,
+      state: g,
+      from: Math.max(u - 1, 0),
+      to: p.b - 1,
+      rule: d,
+      pasteEvent: h,
+      dropEvent: c
+    }) || !m.steps.length)) {
+      try {
+        c = typeof DragEvent < "u" ? new DragEvent("drop") : null;
+      } catch {
+        c = null;
+      }
+      return i = typeof ClipboardEvent < "u" ? new ClipboardEvent("paste") : null, m;
+    }
+  };
+  return n.map((f) => new R({
+    // we register a global drag handler to track the current drag source element
+    view(u) {
+      const p = (h) => {
+        var m;
+        r = (m = u.dom.parentElement) != null && m.contains(h.target) ? u.dom.parentElement : null, r && (Y = e);
+      }, d = () => {
+        Y && (Y = null);
+      };
+      return window.addEventListener("dragstart", p), window.addEventListener("dragend", d), {
+        destroy() {
+          window.removeEventListener("dragstart", p), window.removeEventListener("dragend", d);
+        }
+      };
+    },
+    props: {
+      handleDOMEvents: {
+        drop: (u, p) => {
+          if (s = r === u.dom.parentElement, c = p, !s) {
+            const d = Y;
+            d?.isEditable && setTimeout(() => {
+              const h = d.state.selection;
+              h && d.commands.deleteRange({
+                from: h.from,
+                to: h.to
+              });
+            }, 10);
+          }
+          return !1;
+        },
+        paste: (u, p) => {
+          var d;
+          const h = (d = p.clipboardData) == null ? void 0 : d.getData("text/html");
+          return i = p, o = !!h?.includes("data-pm-slice"), !1;
+        }
+      }
+    },
+    appendTransaction: (u, p, d) => {
+      const h = u[0], m = h.getMeta("uiEvent") === "paste" && !o, g = h.getMeta("uiEvent") === "drop" && !s, v = h.getMeta("applyPasteRules"), y = !!v;
+      if (!m && !g && !y)
+        return;
+      if (y) {
+        let { text: k } = v;
+        typeof k == "string" ? k = k : k = ut(j.from(k), d.schema);
+        const { from: S } = v, E = S + k.length, A = zr(k);
+        return a({
+          rule: f,
+          state: d,
+          from: S,
+          to: { b: E },
+          pasteEvt: A
+        });
+      }
+      const w = p.doc.content.findDiffStart(d.doc.content), x = p.doc.content.findDiffEnd(d.doc.content);
+      if (!(!Dr(w) || !x || w === x.b))
+        return a({
+          rule: f,
+          state: d,
+          from: w,
+          to: x,
+          pasteEvt: i
+        });
+    }
+  }));
+}
+var ft = class {
+  constructor(t, e) {
+    this.splittableMarks = [], this.editor = e, this.baseExtensions = t, this.extensions = Mt(t), this.schema = Gt(this.extensions, e), this.setupExtensions();
+  }
+  /**
+   * Get all commands from the extensions.
+   * @returns An object with all commands where the key is the command name and the value is the command function
+   */
+  get commands() {
+    return this.extensions.reduce((t, e) => {
+      const n = {
+        name: e.name,
+        options: e.options,
+        storage: this.editor.extensionStorage[e.name],
+        editor: this.editor,
+        type: W(e.name, this.schema)
+      }, r = b(
+        e,
+        "addCommands",
+        n
+      );
+      return r ? {
+        ...t,
+        ...r()
+      } : t;
+    }, {});
+  }
+  /**
+   * Get all registered Prosemirror plugins from the extensions.
+   * @returns An array of Prosemirror plugins
+   */
+  get plugins() {
+    const { editor: t } = this;
+    return J([...this.extensions].reverse()).flatMap((r) => {
+      const o = {
+        name: r.name,
+        options: r.options,
+        storage: this.editor.extensionStorage[r.name],
+        editor: t,
+        type: W(r.name, this.schema)
+      }, s = [], i = b(
+        r,
+        "addKeyboardShortcuts",
+        o
+      );
+      let c = {};
+      if (r.type === "mark" && b(r, "exitable", o) && (c.ArrowRight = () => Br.handleExit({ editor: t, mark: r })), i) {
+        const p = Object.fromEntries(
+          Object.entries(i()).map(([d, h]) => [d, () => h({ editor: t })])
+        );
+        c = { ...c, ...p };
+      }
+      const a = Ze(c);
+      s.push(a);
+      const l = b(
+        r,
+        "addInputRules",
+        o
+      );
+      if (jt(r, t.options.enableInputRules) && l) {
+        const p = l();
+        if (p && p.length) {
+          const d = Or({
+            editor: t,
+            rules: p
+          }), h = Array.isArray(d) ? d : [d];
+          s.push(...h);
+        }
+      }
+      const f = b(
+        r,
+        "addPasteRules",
+        o
+      );
+      if (jt(r, t.options.enablePasteRules) && f) {
+        const p = f();
+        if (p && p.length) {
+          const d = Fr({ editor: t, rules: p });
+          s.push(...d);
+        }
+      }
+      const u = b(
+        r,
+        "addProseMirrorPlugins",
+        o
+      );
+      if (u) {
+        const p = u();
+        s.push(...p);
+      }
+      return s;
+    });
+  }
+  /**
+   * Get all attributes from the extensions.
+   * @returns An array of attributes
+   */
+  get attributes() {
+    return Zt(this.extensions);
+  }
+  /**
+   * Get all node views from the extensions.
+   * @returns An object with all node views where the key is the node name and the value is the node view function
+   */
+  get nodeViews() {
+    const { editor: t } = this, { nodeExtensions: e } = V(this.extensions);
+    return Object.fromEntries(
+      e.filter((n) => !!b(n, "addNodeView")).map((n) => {
+        const r = this.attributes.filter(
+          (a) => a.type === n.name
+        ), o = {
+          name: n.name,
+          options: n.options,
+          storage: this.editor.extensionStorage[n.name],
+          editor: t,
+          type: T(n.name, this.schema)
+        }, s = b(
+          n,
+          "addNodeView",
+          o
+        );
+        if (!s)
+          return [];
+        const i = s();
+        if (!i)
+          return [];
+        const c = (a, l, f, u, p) => {
+          const d = ot(a, r);
+          return i({
+            // pass-through
+            node: a,
+            view: l,
+            getPos: f,
+            decorations: u,
+            innerDecorations: p,
+            // tiptap-specific
+            editor: t,
+            extension: n,
+            HTMLAttributes: d
+          });
+        };
+        return [n.name, c];
+      })
+    );
+  }
+  /**
+   * Get the composed dispatchTransaction function from all extensions.
+   * @param baseDispatch The base dispatch function (e.g. from the editor or user props)
+   * @returns A composed dispatch function
+   */
+  dispatchTransaction(t) {
+    const { editor: e } = this;
+    return J([...this.extensions].reverse()).reduceRight((r, o) => {
+      const s = {
+        name: o.name,
+        options: o.options,
+        storage: this.editor.extensionStorage[o.name],
+        editor: e,
+        type: W(o.name, this.schema)
+      }, i = b(
+        o,
+        "dispatchTransaction",
+        s
+      );
+      return i ? (c) => {
+        i.call(s, { transaction: c, next: r });
+      } : r;
+    }, t);
+  }
+  /**
+   * Get the composed transformPastedHTML function from all extensions.
+   * @param baseTransform The base transform function (e.g. from the editor props)
+   * @returns A composed transform function that chains all extension transforms
+   */
+  transformPastedHTML(t) {
+    const { editor: e } = this;
+    return J([...this.extensions]).reduce(
+      (r, o) => {
+        const s = {
+          name: o.name,
+          options: o.options,
+          storage: this.editor.extensionStorage[o.name],
+          editor: e,
+          type: W(o.name, this.schema)
+        }, i = b(
+          o,
+          "transformPastedHTML",
+          s
+        );
+        return i ? (c, a) => {
+          const l = r(c, a);
+          return i.call(s, l);
+        } : r;
+      },
+      t || ((r) => r)
+    );
+  }
+  get markViews() {
+    const { editor: t } = this, { markExtensions: e } = V(this.extensions);
+    return Object.fromEntries(
+      e.filter((n) => !!b(n, "addMarkView")).map((n) => {
+        const r = this.attributes.filter(
+          (c) => c.type === n.name
+        ), o = {
+          name: n.name,
+          options: n.options,
+          storage: this.editor.extensionStorage[n.name],
+          editor: t,
+          type: D(n.name, this.schema)
+        }, s = b(
+          n,
+          "addMarkView",
+          o
+        );
+        if (!s)
+          return [];
+        const i = (c, a, l) => {
+          const f = ot(c, r);
+          return s()({
+            // pass-through
+            mark: c,
+            view: a,
+            inline: l,
+            // tiptap-specific
+            editor: t,
+            extension: n,
+            HTMLAttributes: f,
+            updateAttributes: (u) => {
+              to(c, t, u);
+            }
+          });
+        };
+        return [n.name, i];
+      })
+    );
+  }
+  /**
+   * Destroy the extension manager and clean up all extension references
+   * to prevent memory leaks through parent/child extension chains.
+   *
+   * Walks each extension's full parent chain and nulls every forward
+   * `parent.child → current` link where the parent still points to the
+   * current node. This breaks the retention path from module-scope
+   * singleton roots through deep extend() chains.
+   *
+   * Only ancestor `.child` links matching the current chain are cleared.
+   * The `.parent` pointer on ancestors is never touched — extensions
+   * may be shared across live editors, so their own backward references
+   * and non-matching forward links must remain intact.
+   */
+  destroy() {
+    this.extensions.forEach((t) => {
+      let e = t;
+      for (; e.parent; ) {
+        const n = e.parent;
+        n.child === e && (n.child = null), e = n;
+      }
+    }), this.extensions = [], this.baseExtensions = [], this.schema = null, this.editor = null;
+  }
+  /**
+   * Go through all extensions, create extension storages & setup marks
+   * & bind editor event listener.
+   */
+  setupExtensions() {
+    const t = this.extensions;
+    this.editor.extensionStorage = Object.fromEntries(
+      t.map((e) => [e.name, e.storage])
+    ), t.forEach((e) => {
+      var n;
+      const r = {
+        name: e.name,
+        options: e.options,
+        storage: this.editor.extensionStorage[e.name],
+        editor: this.editor,
+        type: W(e.name, this.schema)
+      };
+      e.type === "mark" && ((n = M(b(e, "keepOnSplit", r))) == null || n) && this.splittableMarks.push(e.name);
+      const o = b(
+        e,
+        "onBeforeCreate",
+        r
+      ), s = b(e, "onCreate", r), i = b(e, "onUpdate", r), c = b(
+        e,
+        "onSelectionUpdate",
+        r
+      ), a = b(
+        e,
+        "onTransaction",
+        r
+      ), l = b(e, "onFocus", r), f = b(e, "onBlur", r), u = b(e, "onDestroy", r);
+      o && this.editor.on("beforeCreate", o), s && this.editor.on("create", s), i && this.editor.on("update", i), c && this.editor.on("selectionUpdate", c), a && this.editor.on("transaction", a), l && this.editor.on("focus", l), f && this.editor.on("blur", f), u && this.editor.on("destroy", u);
+    });
+  }
+};
+ft.resolve = Mt;
+ft.sort = J;
+ft.flatten = xt;
+var Vr = {};
+yt(Vr, {
+  ClipboardTextSerializer: () => ae,
+  Commands: () => ce,
+  Delete: () => le,
+  Drop: () => ue,
+  Editable: () => de,
+  FocusEvents: () => pe,
+  Keymap: () => me,
+  Paste: () => he,
+  Tabindex: () => ge,
+  TextDirection: () => ve,
+  focusEventsPluginKey: () => fe
+});
+var B = class ie extends Et {
+  constructor() {
+    super(...arguments), this.type = "extension";
+  }
+  /**
+   * Create a new Extension instance
+   * @param config - Extension configuration object or a function that returns a configuration object
+   */
+  static create(e = {}) {
+    const n = typeof e == "function" ? e() : e;
+    return new ie(n);
+  }
+  configure(e) {
+    return super.configure(e);
+  }
+  extend(e) {
+    const n = typeof e == "function" ? e() : e;
+    return super.extend(n);
+  }
+}, ae = B.create({
+  name: "clipboardTextSerializer",
+  addOptions() {
+    return {
+      blockSeparator: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new R({
+        key: new _("clipboardTextSerializer"),
+        props: {
+          clipboardTextSerializer: () => {
+            const { editor: t } = this, { state: e, schema: n } = t, { doc: r, selection: o } = e, { ranges: s } = o, i = Math.min(...s.map((f) => f.$from.pos)), c = Math.max(...s.map((f) => f.$to.pos)), a = te(n);
+            return Xt(r, { from: i, to: c }, {
+              ...this.options.blockSeparator !== void 0 ? { blockSeparator: this.options.blockSeparator } : {},
+              textSerializers: a
+            });
+          }
+        }
+      })
+    ];
+  }
+}), ce = B.create({
+  name: "commands",
+  addCommands() {
+    return {
+      ...Vt
+    };
+  }
+}), le = B.create({
+  name: "delete",
+  onUpdate({ transaction: t, appendedTransactions: e }) {
+    var n, r, o;
+    const s = () => {
+      var i, c, a, l;
+      if ((l = (a = (c = (i = this.editor.options.coreExtensionOptions) == null ? void 0 : i.delete) == null ? void 0 : c.filterTransaction) == null ? void 0 : a.call(c, t)) != null ? l : t.getMeta("y-sync$"))
+        return;
+      const f = Un(t.before, [
+        t,
+        ...e
+      ]);
+      or(f).forEach((d) => {
+        f.mapping.mapResult(d.oldRange.from).deletedAfter && f.mapping.mapResult(d.oldRange.to).deletedBefore && f.before.nodesBetween(
+          d.oldRange.from,
+          d.oldRange.to,
+          (h, m) => {
+            const g = m + h.nodeSize - 2, v = d.oldRange.from <= m && g <= d.oldRange.to;
+            this.editor.emit("delete", {
+              type: "node",
+              node: h,
+              from: m,
+              to: g,
+              newFrom: f.mapping.map(m),
+              newTo: f.mapping.map(g),
+              deletedRange: d.oldRange,
+              newRange: d.newRange,
+              partial: !v,
+              editor: this.editor,
+              transaction: t,
+              combinedTransform: f
+            });
+          }
+        );
+      });
+      const p = f.mapping;
+      f.steps.forEach((d, h) => {
+        var m, g;
+        if (d instanceof we) {
+          const v = p.slice(h).map(d.from, -1), y = p.slice(h).map(d.to), w = p.invert().map(v, -1), x = p.invert().map(y), k = v > 0 ? (m = f.doc.nodeAt(v - 1)) == null ? void 0 : m.marks.some((E) => E.eq(d.mark)) : !1, S = (g = f.doc.nodeAt(y)) == null ? void 0 : g.marks.some((E) => E.eq(d.mark));
+          this.editor.emit("delete", {
+            type: "mark",
+            mark: d.mark,
+            from: d.from,
+            to: d.to,
+            deletedRange: {
+              from: w,
+              to: x
+            },
+            newRange: {
+              from: v,
+              to: y
+            },
+            partial: !!(S || k),
+            editor: this.editor,
+            transaction: t,
+            combinedTransform: f
+          });
+        }
+      });
+    };
+    (o = (r = (n = this.editor.options.coreExtensionOptions) == null ? void 0 : n.delete) == null ? void 0 : r.async) == null || o ? setTimeout(s, 0) : s();
+  }
+}), ue = B.create({
+  name: "drop",
+  addProseMirrorPlugins() {
+    return [
+      new R({
+        key: new _("tiptapDrop"),
+        props: {
+          handleDrop: (t, e, n, r) => {
+            this.editor.emit("drop", {
+              editor: this.editor,
+              event: e,
+              slice: n,
+              moved: r
+            });
+          }
+        }
+      })
+    ];
+  }
+}), de = B.create({
+  name: "editable",
+  addProseMirrorPlugins() {
+    return [
+      new R({
+        key: new _("editable"),
+        props: {
+          editable: () => this.editor.options.editable
+        }
+      })
+    ];
+  }
+}), fe = new _("focusEvents"), pe = B.create({
+  name: "focusEvents",
+  addProseMirrorPlugins() {
+    const { editor: t } = this;
+    return [
+      new R({
+        key: fe,
+        props: {
+          handleDOMEvents: {
+            focus: (e, n) => {
+              t.isFocused = !0;
+              const r = t.state.tr.setMeta("focus", { event: n }).setMeta("addToHistory", !1);
+              return e.dispatch(r), !1;
+            },
+            blur: (e, n) => {
+              t.isFocused = !1;
+              const r = t.state.tr.setMeta("blur", { event: n }).setMeta("addToHistory", !1);
+              return e.dispatch(r), !1;
+            }
+          }
+        }
+      })
+    ];
+  }
+}), me = B.create({
+  name: "keymap",
+  addKeyboardShortcuts() {
+    const t = () => this.editor.commands.first(({ commands: i }) => [
+      () => i.undoInputRule(),
+      // maybe convert first text block node to default node
+      () => i.command(({ tr: c }) => {
+        const { selection: a, doc: l } = c, { empty: f, $anchor: u } = a, { pos: p, parent: d } = u, h = u.parent.isTextblock && p > 0 ? c.doc.resolve(p - 1) : u, m = h.parent.type.spec.isolating, g = u.pos - u.parentOffset, v = m && h.parent.childCount === 1 ? g === u.pos : F.atStart(l).from === p;
+        return !f || !d.type.isTextblock || d.textContent.length || !v || v && u.parent.type.name === "paragraph" ? !1 : i.clearNodes();
+      }),
+      () => i.deleteSelection(),
+      () => i.joinBackward(),
+      () => i.selectNodeBackward()
+    ]), e = () => this.editor.commands.first(({ commands: i }) => [
+      () => i.deleteSelection(),
+      () => i.deleteCurrentNode(),
+      () => i.joinForward(),
+      () => i.selectNodeForward()
+    ]), r = {
+      Enter: () => this.editor.commands.first(({ commands: i }) => [
+        () => i.newlineInCode(),
+        () => i.createParagraphNear(),
+        () => i.liftEmptyBlock(),
+        () => i.splitBlock()
+      ]),
+      "Mod-Enter": () => this.editor.commands.exitCode(),
+      Backspace: t,
+      "Mod-Backspace": t,
+      "Shift-Backspace": t,
+      Delete: e,
+      "Mod-Delete": e,
+      "Mod-a": () => this.editor.commands.selectAll()
+    }, o = {
+      ...r
+    }, s = {
+      ...r,
+      "Ctrl-h": t,
+      "Alt-Backspace": t,
+      "Ctrl-d": e,
+      "Ctrl-Alt-Backspace": e,
+      "Alt-Delete": e,
+      "Alt-d": e,
+      "Ctrl-a": () => this.editor.commands.selectTextblockStart(),
+      "Ctrl-e": () => this.editor.commands.selectTextblockEnd()
+    };
+    return rt() || Jt() ? s : o;
+  },
+  addProseMirrorPlugins() {
+    return [
+      // With this plugin we check if the whole document was selected and deleted.
+      // In this case we will additionally call `clearNodes()` to convert e.g. a heading
+      // to a paragraph if necessary.
+      // This is an alternative to ProseMirror's `AllSelection`, which doesn’t work well
+      // with many other commands.
+      new R({
+        key: new _("clearDocument"),
+        appendTransaction: (t, e, n) => {
+          if (t.some((m) => m.getMeta("composition")))
+            return;
+          const r = t.some((m) => m.docChanged) && !e.doc.eq(n.doc), o = t.some(
+            (m) => m.getMeta("preventClearDocument")
+          );
+          if (!r || o)
+            return;
+          const { empty: s, from: i, to: c } = e.selection, a = F.atStart(e.doc).from, l = F.atEnd(e.doc).to;
+          if (s || !(i === a && c === l) || !St(n.doc))
+            return;
+          const p = n.tr, d = it({
+            state: n,
+            transaction: p
+          }), { commands: h } = new at({
+            editor: this.editor,
+            state: d
+          });
+          if (h.clearNodes(), !!p.steps.length)
+            return p;
+        }
+      })
+    ];
+  }
+}), he = B.create({
+  name: "paste",
+  addProseMirrorPlugins() {
+    return [
+      new R({
+        key: new _("tiptapPaste"),
+        props: {
+          handlePaste: (t, e, n) => {
+            this.editor.emit("paste", {
+              editor: this.editor,
+              event: e,
+              slice: n
+            });
+          }
+        }
+      })
+    ];
+  }
+}), ge = B.create({
+  name: "tabindex",
+  addOptions() {
+    return {
+      value: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new R({
+        key: new _("tabindex"),
+        props: {
+          attributes: () => {
+            var t;
+            return !this.editor.isEditable && this.options.value === void 0 ? {} : { tabindex: (t = this.options.value) != null ? t : "0" };
+          }
+        }
+      })
+    ];
+  }
+}), ve = B.create({
+  name: "textDirection",
+  addOptions() {
+    return {
+      direction: void 0
+    };
+  },
+  addGlobalAttributes() {
+    if (!this.options.direction)
+      return [];
+    const { nodeExtensions: t } = V(this.extensions);
+    return [
+      {
+        types: t.filter((e) => e.name !== "text").map((e) => e.name),
+        attributes: {
+          dir: {
+            default: this.options.direction,
+            parseHTML: (e) => {
+              const n = e.getAttribute("dir");
+              return n && (n === "ltr" || n === "rtl" || n === "auto") ? n : this.options.direction;
+            },
+            renderHTML: (e) => e.dir ? {
+              dir: e.dir
+            } : {}
+          }
+        }
+      }
+    ];
+  },
+  addProseMirrorPlugins() {
+    return [
+      new R({
+        key: new _("textDirection"),
+        props: {
+          attributes: () => {
+            const t = this.options.direction;
+            return t ? {
+              dir: t
+            } : {};
+          }
+        }
+      })
+    ];
+  }
+}), Hr = class q {
+  constructor(e, n, r = !1, o = null) {
+    this.currentNode = null, this.actualDepth = null, this.isBlock = r, this.resolvedPos = e, this.editor = n, this.currentNode = o;
+  }
+  get name() {
+    return this.node.type.name;
+  }
+  get node() {
+    return this.currentNode || this.resolvedPos.node();
+  }
+  get element() {
+    return this.editor.view.domAtPos(this.pos).node;
+  }
+  get depth() {
+    var e;
+    return (e = this.actualDepth) != null ? e : this.resolvedPos.depth;
+  }
+  get pos() {
+    return this.resolvedPos.pos;
+  }
+  get content() {
+    return this.node.content;
+  }
+  set content(e) {
+    let n = this.from, r = this.to;
+    if (this.isBlock) {
+      if (this.content.size === 0) {
+        console.error(
+          `You can’t set content on a block node. Tried to set content on ${this.name} at ${this.pos}`
+        );
+        return;
+      }
+      n = this.from + 1, r = this.to - 1;
+    }
+    this.editor.commands.insertContentAt({ from: n, to: r }, e);
+  }
+  get attributes() {
+    return this.node.attrs;
+  }
+  get textContent() {
+    return this.node.textContent;
+  }
+  get size() {
+    return this.node.nodeSize;
+  }
+  get from() {
+    return this.isBlock ? this.pos : this.resolvedPos.start(this.resolvedPos.depth);
+  }
+  get range() {
+    return {
+      from: this.from,
+      to: this.to
+    };
+  }
+  get to() {
+    return this.isBlock ? this.pos + this.size : this.resolvedPos.end(this.resolvedPos.depth) + (this.node.isText ? 0 : 1);
+  }
+  get parent() {
+    if (this.depth === 0)
+      return null;
+    const e = this.resolvedPos.start(this.resolvedPos.depth - 1), n = this.resolvedPos.doc.resolve(e);
+    return new q(n, this.editor);
+  }
+  get before() {
+    let e = this.resolvedPos.doc.resolve(this.from - (this.isBlock ? 1 : 2));
+    return e.depth !== this.depth && (e = this.resolvedPos.doc.resolve(this.from - 3)), new q(e, this.editor);
+  }
+  get after() {
+    let e = this.resolvedPos.doc.resolve(this.to + (this.isBlock ? 2 : 1));
+    return e.depth !== this.depth && (e = this.resolvedPos.doc.resolve(this.to + 3)), new q(e, this.editor);
+  }
+  get children() {
+    const e = [];
+    return this.node.content.forEach((n, r) => {
+      const o = n.isBlock && !n.isTextblock, s = n.isAtom && !n.isText, i = n.isInline, c = this.pos + r + (s ? 0 : 1);
+      if (c < 0 || c > this.resolvedPos.doc.nodeSize - 2)
+        return;
+      const a = this.resolvedPos.doc.resolve(c);
+      if (!o && !i && a.depth <= this.depth)
+        return;
+      const l = new q(
+        a,
+        this.editor,
+        o,
+        o || i ? n : null
+      );
+      o && (l.actualDepth = this.depth + 1), e.push(l);
+    }), e;
+  }
+  get firstChild() {
+    return this.children[0] || null;
+  }
+  get lastChild() {
+    const e = this.children;
+    return e[e.length - 1] || null;
+  }
+  closest(e, n = {}) {
+    let r = null, o = this.parent;
+    for (; o && !r; ) {
+      if (o.node.type.name === e)
+        if (Object.keys(n).length > 0) {
+          const s = o.node.attrs, i = Object.keys(n);
+          for (let c = 0; c < i.length; c += 1) {
+            const a = i[c];
+            if (s[a] !== n[a])
+              break;
+          }
+        } else
+          r = o;
+      o = o.parent;
+    }
+    return r;
+  }
+  querySelector(e, n = {}) {
+    return this.querySelectorAll(e, n, !0)[0] || null;
+  }
+  querySelectorAll(e, n = {}, r = !1) {
+    let o = [];
+    if (!this.children || this.children.length === 0)
+      return o;
+    const s = Object.keys(n);
+    return this.children.forEach((i) => {
+      r && o.length > 0 || (i.node.type.name === e && s.every(
+        (a) => n[a] === i.node.attrs[a]
+      ) && o.push(i), !(r && o.length > 0) && (o = o.concat(i.querySelectorAll(e, n, r))));
+    }), o;
+  }
+  setAttribute(e) {
+    const { tr: n } = this.editor.state;
+    n.setNodeMarkup(this.from, void 0, {
+      ...this.node.attrs,
+      ...e
+    }), this.editor.view.dispatch(n);
+  }
+}, Wr = `.ProseMirror {
+  position: relative;
+}
+
+.ProseMirror {
+  word-wrap: break-word;
+  white-space: pre-wrap;
+  white-space: break-spaces;
+  -webkit-font-variant-ligatures: none;
+  font-variant-ligatures: none;
+  font-feature-settings: "liga" 0; /* the above doesn't seem to work in Edge */
+}
+
+.ProseMirror [contenteditable="false"] {
+  white-space: normal;
+}
+
+.ProseMirror [contenteditable="false"] [contenteditable="true"] {
+  white-space: pre-wrap;
+}
+
+.ProseMirror pre {
+  white-space: pre-wrap;
+}
+
+img.ProseMirror-separator {
+  display: inline !important;
+  border: none !important;
+  margin: 0 !important;
+  width: 0 !important;
+  height: 0 !important;
+}
+
+.ProseMirror-gapcursor {
+  display: none;
+  pointer-events: none;
+  position: absolute;
+  margin: 0;
+}
+
+.ProseMirror-gapcursor:after {
+  content: "";
+  display: block;
+  position: absolute;
+  top: -2px;
+  width: 20px;
+  border-top: 1px solid black;
+  animation: ProseMirror-cursor-blink 1.1s steps(2, start) infinite;
+}
+
+@keyframes ProseMirror-cursor-blink {
+  to {
+    visibility: hidden;
+  }
+}
+
+.ProseMirror-hideselection *::selection {
+  background: transparent;
+}
+
+.ProseMirror-hideselection *::-moz-selection {
+  background: transparent;
+}
+
+.ProseMirror-hideselection * {
+  caret-color: transparent;
+}
+
+.ProseMirror-focused .ProseMirror-gapcursor {
+  display: block;
+}`;
+function Ur(t, e, n) {
+  const r = document.querySelector("style[data-tiptap-style]");
+  if (r !== null)
+    return r;
+  const o = document.createElement("style");
+  return e && o.setAttribute("nonce", e), o.setAttribute("data-tiptap-style", ""), o.innerHTML = t, document.getElementsByTagName("head")[0].appendChild(o), o;
+}
+var go = class extends Nr {
+  constructor(t = {}) {
+    super(), this.css = null, this.className = "tiptap", this.editorView = null, this.isFocused = !1, this.destroyed = !1, this.isInitialized = !1, this.extensionStorage = {}, this.instanceId = Math.random().toString(36).slice(2, 9), this.options = {
+      element: typeof document < "u" ? document.createElement("div") : null,
+      content: "",
+      injectCSS: !0,
+      injectNonce: void 0,
+      extensions: [],
+      autofocus: !1,
+      editable: !0,
+      textDirection: void 0,
+      editorProps: {},
+      parseOptions: {},
+      coreExtensionOptions: {},
+      enableInputRules: !0,
+      enablePasteRules: !0,
+      enableCoreExtensions: !0,
+      enableContentCheck: !1,
+      emitContentError: !1,
+      onBeforeCreate: () => null,
+      onCreate: () => null,
+      onMount: () => null,
+      onUnmount: () => null,
+      onUpdate: () => null,
+      onSelectionUpdate: () => null,
+      onTransaction: () => null,
+      onFocus: () => null,
+      onBlur: () => null,
+      onDestroy: () => null,
+      onContentError: ({ error: r }) => {
+        throw r;
+      },
+      onPaste: () => null,
+      onDrop: () => null,
+      onDelete: () => null,
+      enableExtensionDispatchTransaction: !0
+    }, this.isCapturingTransaction = !1, this.capturedTransaction = null, this.utils = {
+      getUpdatedPosition: ar,
+      createMappablePosition: cr
+    }, this.setOptions(t), this.createExtensionManager(), this.createCommandManager(), this.createSchema(), this.on("beforeCreate", this.options.onBeforeCreate), this.emit("beforeCreate", { editor: this }), this.on("mount", this.options.onMount), this.on("unmount", this.options.onUnmount), this.on("contentError", this.options.onContentError), this.on("create", this.options.onCreate), this.on("update", this.options.onUpdate), this.on("selectionUpdate", this.options.onSelectionUpdate), this.on("transaction", this.options.onTransaction), this.on("focus", this.options.onFocus), this.on("blur", this.options.onBlur), this.on("destroy", this.options.onDestroy), this.on("drop", ({ event: r, slice: o, moved: s }) => this.options.onDrop(r, o, s)), this.on("paste", ({ event: r, slice: o }) => this.options.onPaste(r, o)), this.on("delete", this.options.onDelete);
+    const e = this.createDoc(), n = Ut(e, this.options.autofocus);
+    this.editorState = Ve.create({
+      doc: e,
+      schema: this.schema,
+      selection: n || void 0
+    }), this.options.element && this.mount(this.options.element);
+  }
+  /**
+   * Attach the editor to the DOM, creating a new editor view.
+   */
+  mount(t) {
+    if (typeof document > "u")
+      throw new Error(
+        "[tiptap error]: The editor cannot be mounted because there is no 'document' defined in this environment."
+      );
+    this.createView(t), this.emit("mount", { editor: this }), this.css && !document.head.contains(this.css) && document.head.appendChild(this.css), window.setTimeout(() => {
+      this.isDestroyed || (this.options.autofocus !== !1 && this.options.autofocus !== null && this.commands.focus(this.options.autofocus), this.emit("create", { editor: this }), this.isInitialized = !0);
+    }, 0);
+  }
+  /**
+   * Remove the editor from the DOM, but still allow remounting at a different point in time
+   */
+  unmount() {
+    if (this.editorView) {
+      const t = this.editorView.dom;
+      t?.editor && delete t.editor, this.editorView.destroy();
+    }
+    if (this.editorView = null, this.isInitialized = !1, this.css && !document.querySelectorAll(`.${this.className}`).length)
+      try {
+        typeof this.css.remove == "function" ? this.css.remove() : this.css.parentNode && this.css.parentNode.removeChild(this.css);
+      } catch (t) {
+        console.warn("Failed to remove CSS element:", t);
+      }
+    this.css = null, this.emit("unmount", { editor: this });
+  }
+  /**
+   * Returns the editor storage.
+   */
+  get storage() {
+    return this.extensionStorage;
+  }
+  /**
+   * An object of all registered commands.
+   */
+  get commands() {
+    return this.commandManager.commands;
+  }
+  /**
+   * Create a command chain to call multiple commands at once.
+   */
+  chain() {
+    return this.commandManager.chain();
+  }
+  /**
+   * Check if a command or a command chain can be executed. Without executing it.
+   */
+  can() {
+    return this.commandManager.can();
+  }
+  /**
+   * Inject CSS styles.
+   */
+  injectCSS() {
+    this.options.injectCSS && typeof document < "u" && (this.css = Ur(Wr, this.options.injectNonce));
+  }
+  /**
+   * Update editor options.
+   *
+   * @param options A list of options
+   */
+  setOptions(t = {}) {
+    this.options = {
+      ...this.options,
+      ...t
+    }, !(!this.editorView || !this.state || this.isDestroyed) && (this.options.editorProps && this.view.setProps(this.options.editorProps), this.view.updateState(this.state));
+  }
+  /**
+   * Update editable state of the editor.
+   */
+  setEditable(t, e = !0) {
+    this.setOptions({ editable: t }), e && this.emit("update", { editor: this, transaction: this.state.tr, appendedTransactions: [] });
+  }
+  /**
+   * Returns whether the editor is editable.
+   */
+  get isEditable() {
+    return this.options.editable && this.view && this.view.editable;
+  }
+  /**
+   * Returns the editor view.
+   */
+  get view() {
+    return this.editorView ? this.editorView : new Proxy(
+      {
+        state: this.editorState,
+        updateState: (t) => {
+          this.editorState = t;
+        },
+        dispatch: (t) => {
+          this.dispatchTransaction(t);
+        },
+        // Stub some commonly accessed properties to prevent errors
+        composing: !1,
+        dragging: null,
+        editable: !0,
+        isDestroyed: !1
+      },
+      {
+        get: (t, e) => {
+          if (this.editorView)
+            return this.editorView[e];
+          if (e === "state")
+            return this.editorState;
+          if (e in t)
+            return Reflect.get(t, e);
+          throw new Error(
+            `[tiptap error]: The editor view is not available. Cannot access view['${e}']. The editor may not be mounted yet.`
+          );
+        }
+      }
+    );
+  }
+  /**
+   * Returns the editor state.
+   */
+  get state() {
+    return this.editorView && (this.editorState = this.view.state), this.editorState;
+  }
+  /**
+   * Register a ProseMirror plugin.
+   *
+   * @param plugin A ProseMirror plugin
+   * @param handlePlugins Control how to merge the plugin into the existing plugins.
+   * @returns The new editor state
+   */
+  registerPlugin(t, e) {
+    const n = Qt(e) ? e(t, [...this.state.plugins]) : [...this.state.plugins, t], r = this.state.reconfigure({ plugins: n });
+    return this.view.updateState(r), r;
+  }
+  /**
+   * Unregister a ProseMirror plugin.
+   *
+   * @param nameOrPluginKeyToRemove The plugins name
+   * @returns The new editor state or undefined if the editor is destroyed
+   */
+  unregisterPlugin(t) {
+    if (this.isDestroyed)
+      return;
+    const e = this.state.plugins;
+    let n = e;
+    if ([].concat(t).forEach((o) => {
+      const s = typeof o == "string" ? `${o}$` : o.key;
+      n = n.filter((i) => !i.key.startsWith(s));
+    }), e.length === n.length)
+      return;
+    const r = this.state.reconfigure({
+      plugins: n
+    });
+    return this.view.updateState(r), r;
+  }
+  /**
+   * Creates an extension manager.
+   */
+  createExtensionManager() {
+    var t, e, n, r;
+    const s = [...this.options.enableCoreExtensions ? [
+      de,
+      ae.configure({
+        blockSeparator: (e = (t = this.options.coreExtensionOptions) == null ? void 0 : t.clipboardTextSerializer) == null ? void 0 : e.blockSeparator
+      }),
+      ce,
+      pe,
+      me,
+      ge.configure({
+        value: (r = (n = this.options.coreExtensionOptions) == null ? void 0 : n.tabindex) == null ? void 0 : r.value
+      }),
+      ue,
+      he,
+      le,
+      ve.configure({
+        direction: this.options.textDirection
+      })
+    ].filter((i) => typeof this.options.enableCoreExtensions == "object" ? this.options.enableCoreExtensions[i.name] !== !1 : !0) : [], ...this.options.extensions].filter((i) => ["extension", "node", "mark"].includes(i?.type));
+    this.extensionManager = new ft(s, this);
+  }
+  /**
+   * Creates an command manager.
+   */
+  createCommandManager() {
+    this.commandManager = new at({
+      editor: this
+    });
+  }
+  /**
+   * Creates a ProseMirror schema.
+   */
+  createSchema() {
+    this.schema = this.extensionManager.schema;
+  }
+  /**
+   * Creates the initial document.
+   */
+  createDoc() {
+    let t;
+    try {
+      t = gt(this.options.content, this.schema, this.options.parseOptions, {
+        errorOnInvalidContent: this.options.enableContentCheck
+      });
+    } catch (e) {
+      if (!(e instanceof Error) || !["[tiptap error]: Invalid JSON content", "[tiptap error]: Invalid HTML content"].includes(
+        e.message
+      ))
+        throw e;
+      this.emit("contentError", {
+        editor: this,
+        error: e,
+        disableCollaboration: () => {
+          "collaboration" in this.storage && typeof this.storage.collaboration == "object" && this.storage.collaboration && (this.storage.collaboration.isDisabled = !0), this.options.extensions = this.options.extensions.filter(
+            (n) => n.name !== "collaboration"
+          ), this.createExtensionManager();
+        }
+      }), t = gt(this.options.content, this.schema, this.options.parseOptions, {
+        errorOnInvalidContent: !1
+      });
+    }
+    return t;
+  }
+  /**
+   * Creates a ProseMirror view.
+   */
+  createView(t) {
+    const { editorProps: e, enableExtensionDispatchTransaction: n } = this.options, r = e.dispatchTransaction || this.dispatchTransaction.bind(this), o = n ? this.extensionManager.dispatchTransaction(r) : r, s = e.transformPastedHTML, i = this.extensionManager.transformPastedHTML(s);
+    this.editorView = new Qe(t, {
+      ...e,
+      attributes: {
+        // add `role="textbox"` to the editor element
+        role: "textbox",
+        ...e?.attributes
+      },
+      dispatchTransaction: o,
+      transformPastedHTML: i,
+      state: this.editorState,
+      markViews: this.extensionManager.markViews,
+      nodeViews: this.extensionManager.nodeViews
+    });
+    const c = this.state.reconfigure({
+      plugins: this.extensionManager.plugins
+    });
+    this.view.updateState(c), this.prependClass(), this.injectCSS();
+    const a = this.view.dom;
+    a.editor = this;
+  }
+  /**
+   * Creates all node and mark views.
+   */
+  createNodeViews() {
+    this.view.isDestroyed || this.view.setProps({
+      markViews: this.extensionManager.markViews,
+      nodeViews: this.extensionManager.nodeViews
+    });
+  }
+  /**
+   * Prepend class name to element.
+   */
+  prependClass() {
+    this.view.dom.className = `${this.className} ${this.view.dom.className}`;
+  }
+  captureTransaction(t) {
+    this.isCapturingTransaction = !0, t(), this.isCapturingTransaction = !1;
+    const e = this.capturedTransaction;
+    return this.capturedTransaction = null, e;
+  }
+  /**
+   * The callback over which to send transactions (state updates) produced by the view.
+   *
+   * @param transaction An editor state transaction
+   */
+  dispatchTransaction(t) {
+    if (this.view.isDestroyed)
+      return;
+    if (this.isCapturingTransaction) {
+      if (!this.capturedTransaction) {
+        this.capturedTransaction = t;
+        return;
+      }
+      t.steps.forEach((l) => {
+        var f;
+        return (f = this.capturedTransaction) == null ? void 0 : f.step(l);
+      });
+      return;
+    }
+    const { state: e, transactions: n } = this.state.applyTransaction(t), r = !this.state.selection.eq(e.selection), o = n.includes(t), s = this.state;
+    if (this.emit("beforeTransaction", {
+      editor: this,
+      transaction: t,
+      nextState: e
+    }), !o)
+      return;
+    this.view.updateState(e), this.emit("transaction", {
+      editor: this,
+      transaction: t,
+      appendedTransactions: n.slice(1)
+    }), r && this.emit("selectionUpdate", {
+      editor: this,
+      transaction: t
+    });
+    const i = n.findLast((l) => l.getMeta("focus") || l.getMeta("blur")), c = i?.getMeta("focus"), a = i?.getMeta("blur");
+    c && this.emit("focus", {
+      editor: this,
+      event: c.event,
+      // oxlint-disable-next-lineno-non-null-assertion
+      transaction: i
+    }), a && this.emit("blur", {
+      editor: this,
+      event: a.event,
+      // oxlint-disable-next-lineno-non-null-assertion
+      transaction: i
+    }), !(t.getMeta("preventUpdate") || !n.some((l) => l.docChanged) || s.doc.eq(e.doc)) && this.emit("update", {
+      editor: this,
+      transaction: t,
+      appendedTransactions: n.slice(1)
+    });
+  }
+  /**
+   * Get attributes of the currently selected node or mark.
+   */
+  getAttributes(t) {
+    return er(this.state, t);
+  }
+  isActive(t, e) {
+    const n = typeof t == "string" ? t : null, r = typeof t == "string" ? e : t;
+    return ir(this.state, n, r);
+  }
+  /**
+   * Get the document as JSON.
+   */
+  getJSON() {
+    return this.state.doc.toJSON();
+  }
+  /**
+   * Get the document as HTML.
+   */
+  getHTML() {
+    return ut(this.state.doc.content, this.schema);
+  }
+  /**
+   * Get the document as text.
+   */
+  getText(t) {
+    const { blockSeparator: e = `
+
+`, textSerializers: n = {} } = t || {};
+    return Xn(this.state.doc, {
+      blockSeparator: e,
+      textSerializers: {
+        ...te(this.schema),
+        ...n
+      }
+    });
+  }
+  /**
+   * Check if there is no content.
+   */
+  get isEmpty() {
+    return St(this.state.doc);
+  }
+  /**
+   * Destroy the editor.
+   */
+  destroy() {
+    this.destroyed || (this.destroyed = !0, this.emit("destroy"), this.unmount(), this.removeAllListeners(), this.extensionManager.destroy(), this.extensionManager = null, this.schema = null, this.commandManager = null, this.extensionStorage = {});
+  }
+  /**
+   * Check if the editor is already destroyed.
+   */
+  get isDestroyed() {
+    var t, e;
+    return (e = (t = this.editorView) == null ? void 0 : t.isDestroyed) != null ? e : !0;
+  }
+  $node(t, e) {
+    var n;
+    return ((n = this.$doc) == null ? void 0 : n.querySelector(t, e)) || null;
+  }
+  $nodes(t, e) {
+    var n;
+    return ((n = this.$doc) == null ? void 0 : n.querySelectorAll(t, e)) || null;
+  }
+  $pos(t) {
+    const e = this.state.doc.resolve(t), n = t > 0 && e.nodeAfter && !e.nodeAfter.isText ? e.nodeAfter : null;
+    return new Hr(e, this, !1, n);
+  }
+  get $doc() {
+    return this.$pos(0);
+  }
+};
+function vo(t) {
+  return new dt({
+    find: t.find,
+    handler: ({ state: e, range: n, match: r }) => {
+      const o = M(t.getAttributes, void 0, r);
+      if (o === !1 || o === null)
+        return null;
+      const { tr: s } = e, i = r[r.length - 1], c = r[0];
+      if (i) {
+        const a = c.search(/\S/), l = n.from + c.indexOf(i), f = l + i.length;
+        if (ee(n.from, n.to, e.doc).filter((d) => d.mark.type.excluded.find((m) => m === t.type && m !== d.mark.type)).filter((d) => d.to > l).length)
+          return null;
+        f < n.to && s.delete(f, n.to), l > n.from && s.delete(n.from + a, l);
+        const p = n.from + a + i.length;
+        s.addMark(n.from + a, p, t.type.create(o || {})), s.removeStoredMark(t.type);
+      }
+    },
+    undoable: t.undoable
+  });
+}
+function bo(t) {
+  return new dt({
+    find: t.find,
+    handler: ({ state: e, range: n, match: r }) => {
+      const o = M(t.getAttributes, void 0, r) || {}, { tr: s } = e, i = n.from;
+      let c = n.to;
+      const a = t.type.create(o);
+      if (r[1]) {
+        const l = r[0].lastIndexOf(r[1]);
+        let f = i + l;
+        f > c ? f = c : c = f + r[1].length;
+        const u = r[0][r[0].length - 1];
+        s.insertText(u, i + r[0].length - 1), s.replaceWith(f, c, a);
+      } else if (r[0]) {
+        const l = t.type.isInline ? i : i - 1;
+        s.insert(l, t.type.create(o)).delete(
+          s.mapping.map(i),
+          s.mapping.map(c)
+        );
+      }
+      s.scrollIntoView();
+    },
+    undoable: t.undoable
+  });
+}
+function yo(t) {
+  return new dt({
+    find: t.find,
+    handler: ({ state: e, range: n, match: r }) => {
+      const o = e.doc.resolve(n.from), s = M(t.getAttributes, void 0, r) || {};
+      if (!o.node(-1).canReplaceWith(o.index(-1), o.indexAfter(-1), t.type))
+        return null;
+      e.tr.delete(n.from, n.to).setBlockType(n.from, n.from, t.type, s);
+    },
+    undoable: t.undoable
+  });
+}
+function ko(t) {
+  return new dt({
+    find: t.find,
+    handler: ({ state: e, range: n, match: r, chain: o }) => {
+      const s = M(t.getAttributes, void 0, r) || {}, i = e.tr.delete(n.from, n.to), a = i.doc.resolve(n.from).blockRange(), l = a && ye(a, t.type, s);
+      if (!l)
+        return null;
+      if (i.wrap(a, l), t.keepMarks && t.editor) {
+        const { selection: u, storedMarks: p } = e, { splittableMarks: d } = t.editor.extensionManager, h = p || u.$to.parentOffset && u.$from.marks();
+        if (h) {
+          const m = h.filter((g) => d.includes(g.type.name));
+          i.ensureMarks(m);
+        }
+      }
+      if (t.keepAttributes) {
+        const u = t.type.name === "bulletList" || t.type.name === "orderedList" ? "listItem" : "taskList";
+        o().updateAttributes(u, s).run();
+      }
+      const f = i.doc.resolve(n.from - 1).nodeBefore;
+      f && f.type === t.type && bt(i.doc, n.from - 1) && (!t.joinPredicate || t.joinPredicate(r, f)) && i.join(n.from - 1);
+    },
+    undoable: t.undoable
+  });
+}
+function wo(t, e) {
+  const { selection: n } = t, { $from: r } = n;
+  if (n instanceof st) {
+    const s = r.index();
+    return r.parent.canReplaceWith(s, s + 1, e);
+  }
+  let o = r.depth;
+  for (; o >= 0; ) {
+    const s = r.index(o);
+    if (r.node(o).contentMatchAt(s).matchType(e))
+      return !0;
+    o -= 1;
+  }
+  return !1;
+}
+var qr = {};
+yt(qr, {
+  createAtomBlockMarkdownSpec: () => Jr,
+  createBlockMarkdownSpec: () => Kr,
+  createInlineMarkdownSpec: () => Gr,
+  parseAttributes: () => Tt,
+  parseIndentedBlocks: () => Yr,
+  renderNestedMarkdownContent: () => Xr,
+  serializeAttributes: () => At
+});
+function Tt(t) {
+  if (!t?.trim())
+    return {};
+  const e = {}, n = [], r = t.replace(/["']([^"']*)["']/g, (l) => (n.push(l), `__QUOTED_${n.length - 1}__`)), o = r.match(/(?:^|\s)\.([a-zA-Z][\w-]*)/g);
+  if (o) {
+    const l = o.map((f) => f.trim().slice(1));
+    e.class = l.join(" ");
+  }
+  const s = r.match(/(?:^|\s)#([a-zA-Z][\w-]*)/);
+  s && (e.id = s[1]);
+  const i = /([a-zA-Z][\w-]*)\s*=\s*(__QUOTED_\d+__)/g;
+  Array.from(r.matchAll(i)).forEach(([, l, f]) => {
+    var u;
+    const p = parseInt(((u = f.match(/__QUOTED_(\d+)__/)) == null ? void 0 : u[1]) || "0", 10), d = n[p];
+    d && (e[l] = d.slice(1, -1));
+  });
+  const a = r.replace(/(?:^|\s)\.([a-zA-Z][\w-]*)/g, "").replace(/(?:^|\s)#([a-zA-Z][\w-]*)/g, "").replace(/([a-zA-Z][\w-]*)\s*=\s*__QUOTED_\d+__/g, "").trim();
+  return a && a.split(/\s+/).filter(Boolean).forEach((f) => {
+    f.match(/^[a-zA-Z][\w-]*$/) && (e[f] = !0);
+  }), e;
+}
+function At(t) {
+  if (!t || Object.keys(t).length === 0)
+    return "";
+  const e = [];
+  return t.class && String(t.class).split(/\s+/).filter(Boolean).forEach((r) => e.push(`.${r}`)), t.id && e.push(`#${t.id}`), Object.entries(t).forEach(([n, r]) => {
+    n === "class" || n === "id" || (r === !0 ? e.push(n) : r !== !1 && r != null && e.push(`${n}="${String(r)}"`));
+  }), e.join(" ");
+}
+function Jr(t) {
+  const {
+    nodeName: e,
+    name: n,
+    parseAttributes: r = Tt,
+    serializeAttributes: o = At,
+    defaultAttributes: s = {},
+    requiredAttributes: i = [],
+    allowedAttributes: c
+  } = t, a = n || e, l = (f) => {
+    if (!c)
+      return f;
+    const u = {};
+    return c.forEach((p) => {
+      p in f && (u[p] = f[p]);
+    }), u;
+  };
+  return {
+    parseMarkdown: (f, u) => {
+      const p = { ...s, ...f.attributes };
+      return u.createNode(e, p, []);
+    },
+    markdownTokenizer: {
+      name: e,
+      level: "block",
+      start(f) {
+        var u;
+        const p = new RegExp(`^:::${a}(?:\\s|$)`, "m"), d = (u = f.match(p)) == null ? void 0 : u.index;
+        return d !== void 0 ? d : -1;
+      },
+      tokenize(f, u, p) {
+        const d = new RegExp(`^:::${a}(?:\\s+\\{([^}]*)\\})?\\s*:::(?:\\n|$)`), h = f.match(d);
+        if (!h)
+          return;
+        const m = h[1] || "", g = r(m);
+        if (!i.find((y) => !(y in g)))
+          return {
+            type: e,
+            raw: h[0],
+            attributes: g
+          };
+      }
+    },
+    renderMarkdown: (f) => {
+      const u = l(f.attrs || {}), p = o(u), d = p ? ` {${p}}` : "";
+      return `:::${a}${d} :::`;
+    }
+  };
+}
+function Kr(t) {
+  const {
+    nodeName: e,
+    name: n,
+    getContent: r,
+    parseAttributes: o = Tt,
+    serializeAttributes: s = At,
+    defaultAttributes: i = {},
+    content: c = "block",
+    allowedAttributes: a
+  } = t, l = n || e, f = (u) => {
+    if (!a)
+      return u;
+    const p = {};
+    return a.forEach((d) => {
+      d in u && (p[d] = u[d]);
+    }), p;
+  };
+  return {
+    parseMarkdown: (u, p) => {
+      let d;
+      if (r) {
+        const m = r(u);
+        d = typeof m == "string" ? [{ type: "text", text: m }] : m;
+      } else c === "block" ? d = p.parseChildren(u.tokens || []) : d = p.parseInline(u.tokens || []);
+      const h = { ...i, ...u.attributes };
+      return p.createNode(e, h, d);
+    },
+    markdownTokenizer: {
+      name: e,
+      level: "block",
+      start(u) {
+        var p;
+        const d = new RegExp(`^:::${l}`, "m"), h = (p = u.match(d)) == null ? void 0 : p.index;
+        return h !== void 0 ? h : -1;
+      },
+      tokenize(u, p, d) {
+        var h;
+        const m = new RegExp(`^:::${l}(?:\\s+\\{([^}]*)\\})?\\s*\\n`), g = u.match(m);
+        if (!g)
+          return;
+        const [v, y = ""] = g, w = o(y);
+        let x = 1;
+        const k = v.length;
+        let S = "";
+        const E = /^:::([\w-]*)(\s.*)?/gm, A = u.slice(k);
+        for (E.lastIndex = 0; ; ) {
+          const C = E.exec(A);
+          if (C === null)
+            break;
+          const $ = C.index, H = C[1];
+          if (!((h = C[2]) != null && h.endsWith(":::"))) {
+            if (H)
+              x += 1;
+            else if (x -= 1, x === 0) {
+              const L = A.slice(0, $);
+              S = L.trim();
+              const I = u.slice(0, k + $ + C[0].length);
+              let N = [];
+              if (S)
+                if (c === "block")
+                  for (N = d.blockTokens(L), N.forEach((P) => {
+                    P.text && (!P.tokens || P.tokens.length === 0) && (P.tokens = d.inlineTokens(P.text));
+                  }); N.length > 0; ) {
+                    const P = N[N.length - 1];
+                    if (P.type === "paragraph" && (!P.text || P.text.trim() === ""))
+                      N.pop();
+                    else
+                      break;
+                  }
+                else
+                  N = d.inlineTokens(S);
+              return {
+                type: e,
+                raw: I,
+                attributes: w,
+                content: S,
+                tokens: N
+              };
+            }
+          }
+        }
+      }
+    },
+    renderMarkdown: (u, p) => {
+      const d = f(u.attrs || {}), h = s(d), m = h ? ` {${h}}` : "", g = p.renderChildren(u.content || [], `
+
+`);
+      return `:::${l}${m}
+
+${g}
+
+:::`;
+    }
+  };
+}
+function Qr(t) {
+  if (!t.trim())
+    return {};
+  const e = {}, n = /(\w+)=(?:"([^"]*)"|'([^']*)')/g;
+  let r = n.exec(t);
+  for (; r !== null; ) {
+    const [, o, s, i] = r;
+    e[o] = s || i, r = n.exec(t);
+  }
+  return e;
+}
+function Zr(t) {
+  return Object.entries(t).filter(([, e]) => e != null).map(([e, n]) => `${e}="${n}"`).join(" ");
+}
+function Gr(t) {
+  const {
+    nodeName: e,
+    name: n,
+    getContent: r,
+    parseAttributes: o = Qr,
+    serializeAttributes: s = Zr,
+    defaultAttributes: i = {},
+    selfClosing: c = !1,
+    allowedAttributes: a
+  } = t, l = n || e, f = (p) => {
+    if (!a)
+      return p;
+    const d = {};
+    return a.forEach((h) => {
+      const m = typeof h == "string" ? h : h.name, g = typeof h == "string" ? void 0 : h.skipIfDefault;
+      if (m in p) {
+        const v = p[m];
+        if (g !== void 0 && v === g)
+          return;
+        d[m] = v;
+      }
+    }), d;
+  }, u = l.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return {
+    parseMarkdown: (p, d) => {
+      const h = { ...i, ...p.attributes };
+      if (c)
+        return d.createNode(e, h);
+      const m = r ? r(p) : p.content || "";
+      return m ? d.createNode(e, h, [d.createTextNode(m)]) : d.createNode(e, h, []);
+    },
+    markdownTokenizer: {
+      name: e,
+      level: "inline",
+      start(p) {
+        const d = c ? new RegExp(`\\[${u}\\s*[^\\]]*\\]`) : new RegExp(`\\[${u}\\s*[^\\]]*\\][\\s\\S]*?\\[\\/${u}\\]`), h = p.match(d), m = h?.index;
+        return m !== void 0 ? m : -1;
+      },
+      tokenize(p, d, h) {
+        const m = c ? new RegExp(`^\\[${u}\\s*([^\\]]*)\\]`) : new RegExp(
+          `^\\[${u}\\s*([^\\]]*)\\]([\\s\\S]*?)\\[\\/${u}\\]`
+        ), g = p.match(m);
+        if (!g)
+          return;
+        let v = "", y = "";
+        if (c) {
+          const [, x] = g;
+          y = x;
+        } else {
+          const [, x, k] = g;
+          y = x, v = k || "";
+        }
+        const w = o(y.trim());
+        return {
+          type: e,
+          raw: g[0],
+          content: v.trim(),
+          attributes: w
+        };
+      }
+    },
+    renderMarkdown: (p) => {
+      let d = "";
+      r ? d = r(p) : p.content && p.content.length > 0 && (d = p.content.filter((v) => v.type === "text").map((v) => v.text).join(""));
+      const h = f(p.attrs || {}), m = s(h), g = m ? ` ${m}` : "";
+      return c ? `[${l}${g}]` : `[${l}${g}]${d}[/${l}]`;
+    }
+  };
+}
+function Yr(t, e, n) {
+  var r, o, s, i;
+  const c = t.split(`
+`), a = [];
+  let l = "", f = 0;
+  const u = e.baseIndentSize || 2;
+  for (; f < c.length; ) {
+    const p = c[f], d = p.match(e.itemPattern);
+    if (!d) {
+      if (a.length > 0)
+        break;
+      if (p.trim() === "") {
+        f += 1, l = `${l}${p}
+`;
+        continue;
+      } else
+        return;
+    }
+    const h = e.extractItemData(d), { indentLevel: m, mainContent: g } = h;
+    l = `${l}${p}
+`;
+    const v = [g];
+    for (f += 1; f < c.length; ) {
+      const k = c[f];
+      if (k.trim() === "") {
+        const E = c.slice(f + 1).findIndex(($) => $.trim() !== "");
+        if (E === -1)
+          break;
+        if ((((o = (r = c[f + 1 + E].match(/^(\s*)/)) == null ? void 0 : r[1]) == null ? void 0 : o.length) || 0) > m) {
+          v.push(k), l = `${l}${k}
+`, f += 1;
+          continue;
+        } else
+          break;
+      }
+      if ((((i = (s = k.match(/^(\s*)/)) == null ? void 0 : s[1]) == null ? void 0 : i.length) || 0) > m)
+        v.push(k), l = `${l}${k}
+`, f += 1;
+      else
+        break;
+    }
+    let y;
+    const w = v.slice(1);
+    if (w.length > 0) {
+      const k = w.map((S) => S.slice(m + u)).join(`
+`);
+      k.trim() && (e.customNestedParser ? y = e.customNestedParser(k) : y = n.blockTokens(k));
+    }
+    const x = e.createToken(h, y);
+    a.push(x);
+  }
+  if (a.length !== 0)
+    return {
+      items: a,
+      raw: l
+    };
+}
+function Xr(t, e, n, r) {
+  if (!t || !Array.isArray(t.content))
+    return "";
+  const o = typeof n == "function" ? n(r) : n, [s, ...i] = t.content, c = e.renderChildren([s]);
+  let a = `${o}${c}`;
+  return i && i.length > 0 && i.forEach((l, f) => {
+    var u, p;
+    const d = (p = (u = e.renderChild) == null ? void 0 : u.call(e, l, f + 1)) != null ? p : e.renderChildren([l]);
+    if (d != null) {
+      const h = d.split(`
+`).map((m) => m ? e.indent(m) : e.indent("")).join(`
+`);
+      a += l.type === "paragraph" ? `
+
+${h}` : `
+${h}`;
+    }
+  }), a;
+}
+function to(t, e, n = {}) {
+  const { state: r } = e, { doc: o, tr: s } = r, i = t;
+  o.descendants((c, a) => {
+    const l = s.mapping.map(a), f = s.mapping.map(a) + c.nodeSize;
+    let u = null;
+    if (c.marks.forEach((d) => {
+      if (d !== i)
+        return !1;
+      u = d;
+    }), !u)
+      return;
+    let p = !1;
+    if (Object.keys(n).forEach((d) => {
+      n[d] !== u.attrs[d] && (p = !0);
+    }), p) {
+      const d = t.type.create({
+        ...t.attrs,
+        ...n
+      });
+      s.removeMark(l, f, t.type), s.addMark(l, f, d);
+    }
+  }), s.docChanged && e.view.dispatch(s);
+}
+var xo = class be extends Et {
+  constructor() {
+    super(...arguments), this.type = "node";
+  }
+  /**
+   * Create a new Node instance
+   * @param config - Node configuration object or a function that returns a configuration object
+   */
+  static create(e = {}) {
+    const n = typeof e == "function" ? e() : e;
+    return new be(n);
+  }
+  configure(e) {
+    return super.configure(e);
+  }
+  extend(e) {
+    const n = typeof e == "function" ? e() : e;
+    return super.extend(n);
+  }
+};
+function Mo(t) {
+  return new jr({
+    find: t.find,
+    handler: ({ state: e, range: n, match: r, pasteEvent: o }) => {
+      const s = M(t.getAttributes, void 0, r, o);
+      if (s === !1 || s === null)
+        return null;
+      const { tr: i } = e, c = r[r.length - 1], a = r[0];
+      let l = n.to;
+      if (c) {
+        const f = a.search(/\S/), u = n.from + a.indexOf(c), p = u + c.length;
+        if (ee(n.from, n.to, e.doc).filter((m) => m.mark.type.excluded.find((v) => v === t.type && v !== m.mark.type)).filter((m) => m.to > u).length)
+          return null;
+        p < n.to && i.delete(p, n.to), u > n.from && i.delete(n.from + f, u), l = n.from + f + c.length, i.addMark(n.from + f, l, t.type.create(s || {})), r.index !== void 0 && r.input !== void 0 && r.index + r[0].length >= r.input.length || i.removeStoredMark(t.type);
+      }
+    }
+  });
+}
+export {
+  at as CommandManager,
+  go as Editor,
+  Et as Extendable,
+  B as Extension,
+  dt as InputRule,
+  ne as MappablePosition,
+  Br as Mark,
+  xo as Node,
+  Hr as NodePos,
+  jr as PasteRule,
+  M as callOrReturn,
+  wo as canInsertNode,
+  Un as combineTransactionSteps,
+  Vt as commands,
+  Jr as createAtomBlockMarkdownSpec,
+  Kr as createBlockMarkdownSpec,
+  it as createChainableState,
+  gt as createDocument,
+  Gr as createInlineMarkdownSpec,
+  cr as createMappablePosition,
+  K as createNodeFromContent,
+  Ur as createStyleTag,
+  qn as defaultBlockAt,
+  It as deleteProps,
+  U as elementFromString,
+  Vr as extensions,
+  co as findChildrenInRange,
+  Yn as findDuplicates,
+  lt as findParentNode,
+  Jn as findParentNodeClosestToPos,
+  xt as flattenExtensions,
+  Gn as fromString,
+  lo as generateHTML,
+  uo as generateJSON,
+  er as getAttributes,
+  Zt as getAttributesFromExtensions,
+  or as getChangedRanges,
+  b as getExtensionField,
+  ut as getHTMLFromFragment,
+  Kt as getMarkAttributes,
+  wt as getMarkRange,
+  D as getMarkType,
+  ee as getMarksBetween,
+  fo as getNodeAtPosition,
+  tr as getNodeAttributes,
+  T as getNodeType,
+  ot as getRenderedAttributes,
+  Yt as getSchema,
+  Gt as getSchemaByResolvedExtensions,
+  W as getSchemaTypeByName,
+  ct as getSchemaTypeNameByName,
+  et as getSplittedAttributes,
+  Xn as getText,
+  Xt as getTextBetween,
+  sr as getTextContentFromNodes,
+  te as getTextSerializersFromSchema,
+  ar as getUpdatedPosition,
+  Rt as injectExtensionAttributesToParseRule,
+  Or as inputRulesPlugin,
+  ir as isActive,
+  Nt as isAndroid,
+  po as isAtEndOfNode,
+  mo as isAtStartOfNode,
+  Kn as isEmptyObject,
+  jt as isExtensionRulesEnabled,
+  Qt as isFunction,
+  pt as isList,
+  Jt as isMacOS,
+  vt as isMarkActive,
+  Q as isNodeActive,
+  St as isNodeEmpty,
+  ho as isNodeSelection,
+  Dr as isNumber,
+  G as isPlainObject,
+  kt as isRegExp,
+  hn as isSafari,
+  Wt as isTextSelection,
+  rt as isiOS,
+  vo as markInputRule,
+  Mo as markPasteRule,
+  qr as markdown,
+  Zn as mergeAttributes,
+  oe as mergeDeep,
+  z as minMax,
+  bo as nodeInputRule,
+  nt as objectIncludes,
+  Tt as parseAttributes,
+  Yr as parseIndentedBlocks,
+  Fr as pasteRulesPlugin,
+  nr as removeDuplicates,
+  Xr as renderNestedMarkdownContent,
+  Mt as resolveExtensions,
+  Ut as resolveFocusPosition,
+  yn as selectionToInsertionEnd,
+  At as serializeAttributes,
+  J as sortExtensions,
+  V as splitExtensions,
+  yo as textblockTypeInputRule,
+  to as updateMarkViewAttributes,
+  ko as wrappingInputRule
+};