@vkzstudio/muza-ui 1.0.8 → 1.0.10

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

@@ -0,0 +1,2857 @@
+import { EditorState as Lt, NodeSelection as J, Plugin as I, PluginKey as j, Selection as F, TextSelection as P, AllSelection as zt } from "../../../prosemirror-state/dist/index.js";
+import { EditorView as Ht } from "../../../prosemirror-view/dist/index.js";
+import { keymap as _t } from "../../../prosemirror-keymap/dist/index.js";
+import { DOMSerializer as Wt, Schema as xt, Fragment as $, Node as Vt, DOMParser as nt, Slice as Kt } from "../../../prosemirror-model/dist/index.js";
+import { findWrapping as Ut, canJoin as dt, Transform as qt, canSplit as V, joinPoint as Ct, liftTarget as Gt, ReplaceStep as Jt, ReplaceAroundStep as Yt } from "../../../prosemirror-transform/dist/index.js";
+import { wrapIn as Qt, setBlockType as gt, selectTextblockStart as Xt, selectTextblockEnd as Zt, selectParentNode as te, selectNodeForward as ee, selectNodeBackward as ne, newlineInCode as re, liftEmptyBlock as oe, lift as se, joinUp as ie, joinTextblockForward as ae, joinTextblockBackward as ce, joinForward as le, joinDown as de, joinBackward as ue, exitCode as fe, deleteSelection as pe, createParagraphNear as he } from "../../../prosemirror-commands/dist/index.js";
+import { wrapInList as me, sinkListItem as ge, liftListItem as ye } from "../../../prosemirror-schema-list/dist/index.js";
+function Y(n) {
+  const { state: t, transaction: e } = n;
+  let { selection: r } = e, { doc: o } = e, { storedMarks: s } = e;
+  return {
+    ...t,
+    apply: t.apply.bind(t),
+    applyTransaction: t.applyTransaction.bind(t),
+    plugins: t.plugins,
+    schema: t.schema,
+    reconfigure: t.reconfigure.bind(t),
+    toJSON: t.toJSON.bind(t),
+    get storedMarks() {
+      return s;
+    },
+    get selection() {
+      return r;
+    },
+    get doc() {
+      return o;
+    },
+    get tr() {
+      return r = e.selection, o = e.doc, s = e.storedMarks, e;
+    }
+  };
+}
+class Q {
+  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: r } = this, { view: o } = e, { tr: s } = r, i = this.buildProps(s);
+    return Object.fromEntries(Object.entries(t).map(([c, a]) => [c, (...u) => {
+      const d = a(...u)(i);
+      return !s.getMeta("preventDispatch") && !this.hasCustomState && o.dispatch(s), d;
+    }]));
+  }
+  get chain() {
+    return () => this.createChain();
+  }
+  get can() {
+    return () => this.createCan();
+  }
+  createChain(t, e = !0) {
+    const { rawCommands: r, editor: o, state: s } = this, { view: i } = o, c = [], a = !!t, l = t || s.tr, u = () => (!a && e && !l.getMeta("preventDispatch") && !this.hasCustomState && i.dispatch(l), c.every((f) => f === !0)), d = {
+      ...Object.fromEntries(Object.entries(r).map(([f, p]) => [f, (...h) => {
+        const g = this.buildProps(l, e), y = p(...h)(g);
+        return c.push(y), d;
+      }])),
+      run: u
+    };
+    return d;
+  }
+  createCan(t) {
+    const { rawCommands: e, state: r } = this, o = !1, s = t || r.tr, i = this.buildProps(s, o);
+    return {
+      ...Object.fromEntries(Object.entries(e).map(([a, l]) => [a, (...u) => l(...u)({ ...i, dispatch: void 0 })])),
+      chain: () => this.createChain(s, o)
+    };
+  }
+  buildProps(t, e = !0) {
+    const { rawCommands: r, editor: o, state: s } = this, { view: i } = o, c = {
+      tr: t,
+      editor: o,
+      view: i,
+      state: Y({
+        state: s,
+        transaction: t
+      }),
+      dispatch: e ? () => {
+      } : void 0,
+      chain: () => this.createChain(t, e),
+      can: () => this.createCan(t),
+      get commands() {
+        return Object.fromEntries(Object.entries(r).map(([a, l]) => [a, (...u) => l(...u)(c)]));
+      }
+    };
+    return c;
+  }
+}
+class ke {
+  constructor() {
+    this.callbacks = {};
+  }
+  on(t, e) {
+    return this.callbacks[t] || (this.callbacks[t] = []), this.callbacks[t].push(e), this;
+  }
+  emit(t, ...e) {
+    const r = this.callbacks[t];
+    return r && r.forEach((o) => o.apply(this, e)), this;
+  }
+  off(t, e) {
+    const r = this.callbacks[t];
+    return r && (e ? this.callbacks[t] = r.filter((o) => o !== e) : delete this.callbacks[t]), this;
+  }
+  once(t, e) {
+    const r = (...o) => {
+      this.off(t, r), e.apply(this, o);
+    };
+    return this.on(t, r);
+  }
+  removeAllListeners() {
+    this.callbacks = {};
+  }
+}
+function k(n, t, e) {
+  return n.config[t] === void 0 && n.parent ? k(n.parent, t, e) : typeof n.config[t] == "function" ? n.config[t].bind({
+    ...e,
+    parent: n.parent ? k(n.parent, t, e) : null
+  }) : n.config[t];
+}
+function X(n) {
+  const t = n.filter((o) => o.type === "extension"), e = n.filter((o) => o.type === "node"), r = n.filter((o) => o.type === "mark");
+  return {
+    baseExtensions: t,
+    nodeExtensions: e,
+    markExtensions: r
+  };
+}
+function Tt(n) {
+  const t = [], { nodeExtensions: e, markExtensions: r } = X(n), o = [...e, ...r], s = {
+    default: null,
+    rendered: !0,
+    renderHTML: null,
+    parseHTML: null,
+    keepOnSplit: !0,
+    isRequired: !1
+  };
+  return n.forEach((i) => {
+    const c = {
+      name: i.name,
+      options: i.options,
+      storage: i.storage,
+      extensions: o
+    }, a = k(i, "addGlobalAttributes", c);
+    if (!a)
+      return;
+    a().forEach((u) => {
+      u.types.forEach((d) => {
+        Object.entries(u.attributes).forEach(([f, p]) => {
+          t.push({
+            type: d,
+            name: f,
+            attribute: {
+              ...s,
+              ...p
+            }
+          });
+        });
+      });
+    });
+  }), o.forEach((i) => {
+    const c = {
+      name: i.name,
+      options: i.options,
+      storage: i.storage
+    }, a = k(i, "addAttributes", c);
+    if (!a)
+      return;
+    const l = a();
+    Object.entries(l).forEach(([u, d]) => {
+      const f = {
+        ...s,
+        ...d
+      };
+      typeof (f == null ? void 0 : f.default) == "function" && (f.default = f.default()), f != null && f.isRequired && (f == null ? void 0 : f.default) === void 0 && delete f.default, t.push({
+        type: i.name,
+        name: u,
+        attribute: f
+      });
+    });
+  }), t;
+}
+function S(n, t) {
+  if (typeof n == "string") {
+    if (!t.nodes[n])
+      throw Error(`There is no node type named '${n}'. Maybe you forgot to add the extension?`);
+    return t.nodes[n];
+  }
+  return n;
+}
+function be(...n) {
+  return n.filter((t) => !!t).reduce((t, e) => {
+    const r = { ...t };
+    return Object.entries(e).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((u) => !a.includes(u));
+        r[o] = [...a, ...l].join(" ");
+      } else if (o === "style") {
+        const c = s ? s.split(";").map((u) => u.trim()).filter(Boolean) : [], a = r[o] ? r[o].split(";").map((u) => u.trim()).filter(Boolean) : [], l = /* @__PURE__ */ new Map();
+        a.forEach((u) => {
+          const [d, f] = u.split(":").map((p) => p.trim());
+          l.set(d, f);
+        }), c.forEach((u) => {
+          const [d, f] = u.split(":").map((p) => p.trim());
+          l.set(d, f);
+        }), r[o] = Array.from(l.entries()).map(([u, d]) => `${u}: ${d}`).join("; ");
+      } else
+        r[o] = s;
+    }), r;
+  }, {});
+}
+function it(n, t) {
+  return t.filter((e) => e.type === n.type.name).filter((e) => e.attribute.rendered).map((e) => e.attribute.renderHTML ? e.attribute.renderHTML(n.attrs) || {} : {
+    [e.name]: n.attrs[e.name]
+  }).reduce((e, r) => be(e, r), {});
+}
+function At(n) {
+  return typeof n == "function";
+}
+function b(n, t = void 0, ...e) {
+  return At(n) ? t ? n.bind(t)(...e) : n(...e) : n;
+}
+function ve(n = {}) {
+  return Object.keys(n).length === 0 && n.constructor === Object;
+}
+function we(n) {
+  return typeof n != "string" ? n : n.match(/^[+-]?(?:\d*\.)?\d+$/) ? Number(n) : n === "true" ? !0 : n === "false" ? !1 : n;
+}
+function yt(n, t) {
+  return "style" in n ? n : {
+    ...n,
+    getAttrs: (e) => {
+      const r = n.getAttrs ? n.getAttrs(e) : n.attrs;
+      if (r === !1)
+        return !1;
+      const o = t.reduce((s, i) => {
+        const c = i.attribute.parseHTML ? i.attribute.parseHTML(e) : we(e.getAttribute(i.name));
+        return c == null ? s : {
+          ...s,
+          [i.name]: c
+        };
+      }, {});
+      return { ...r, ...o };
+    }
+  };
+}
+function kt(n) {
+  return Object.fromEntries(
+    // @ts-ignore
+    Object.entries(n).filter(([t, e]) => t === "attrs" && ve(e) ? !1 : e != null)
+  );
+}
+function Me(n, t) {
+  var e;
+  const r = Tt(n), { nodeExtensions: o, markExtensions: s } = X(n), i = (e = o.find((l) => k(l, "topNode"))) === null || e === void 0 ? void 0 : e.name, c = Object.fromEntries(o.map((l) => {
+    const u = r.filter((y) => y.type === l.name), d = {
+      name: l.name,
+      options: l.options,
+      storage: l.storage,
+      editor: t
+    }, f = n.reduce((y, v) => {
+      const w = k(v, "extendNodeSchema", d);
+      return {
+        ...y,
+        ...w ? w(l) : {}
+      };
+    }, {}), p = kt({
+      ...f,
+      content: b(k(l, "content", d)),
+      marks: b(k(l, "marks", d)),
+      group: b(k(l, "group", d)),
+      inline: b(k(l, "inline", d)),
+      atom: b(k(l, "atom", d)),
+      selectable: b(k(l, "selectable", d)),
+      draggable: b(k(l, "draggable", d)),
+      code: b(k(l, "code", d)),
+      whitespace: b(k(l, "whitespace", d)),
+      linebreakReplacement: b(k(l, "linebreakReplacement", d)),
+      defining: b(k(l, "defining", d)),
+      isolating: b(k(l, "isolating", d)),
+      attrs: Object.fromEntries(u.map((y) => {
+        var v;
+        return [y.name, { default: (v = y == null ? void 0 : y.attribute) === null || v === void 0 ? void 0 : v.default }];
+      }))
+    }), m = b(k(l, "parseHTML", d));
+    m && (p.parseDOM = m.map((y) => yt(y, u)));
+    const h = k(l, "renderHTML", d);
+    h && (p.toDOM = (y) => h({
+      node: y,
+      HTMLAttributes: it(y, u)
+    }));
+    const g = k(l, "renderText", d);
+    return g && (p.toText = g), [l.name, p];
+  })), a = Object.fromEntries(s.map((l) => {
+    const u = r.filter((g) => g.type === l.name), d = {
+      name: l.name,
+      options: l.options,
+      storage: l.storage,
+      editor: t
+    }, f = n.reduce((g, y) => {
+      const v = k(y, "extendMarkSchema", d);
+      return {
+        ...g,
+        ...v ? v(l) : {}
+      };
+    }, {}), p = kt({
+      ...f,
+      inclusive: b(k(l, "inclusive", d)),
+      excludes: b(k(l, "excludes", d)),
+      group: b(k(l, "group", d)),
+      spanning: b(k(l, "spanning", d)),
+      code: b(k(l, "code", d)),
+      attrs: Object.fromEntries(u.map((g) => {
+        var y;
+        return [g.name, { default: (y = g == null ? void 0 : g.attribute) === null || y === void 0 ? void 0 : y.default }];
+      }))
+    }), m = b(k(l, "parseHTML", d));
+    m && (p.parseDOM = m.map((g) => yt(g, u)));
+    const h = k(l, "renderHTML", d);
+    return h && (p.toDOM = (g) => h({
+      mark: g,
+      HTMLAttributes: it(g, u)
+    })), [l.name, p];
+  }));
+  return new xt({
+    topNode: i,
+    nodes: c,
+    marks: a
+  });
+}
+function rt(n, t) {
+  return t.nodes[n] || t.marks[n] || null;
+}
+function bt(n, t) {
+  return Array.isArray(t) ? t.some((e) => (typeof e == "string" ? e : e.name) === n.name) : t;
+}
+function ut(n, t) {
+  const e = Wt.fromSchema(t).serializeFragment(n), o = document.implementation.createHTMLDocument().createElement("div");
+  return o.appendChild(e), o.innerHTML;
+}
+const Se = (n, t = 500) => {
+  let e = "";
+  const r = n.parentOffset;
+  return n.parent.nodesBetween(Math.max(0, r - t), r, (o, s, i, c) => {
+    var a, l;
+    const u = ((l = (a = o.type.spec).toText) === null || l === void 0 ? void 0 : l.call(a, {
+      node: o,
+      pos: s,
+      parent: i,
+      index: c
+    })) || o.textContent || "%leaf%";
+    e += o.isAtom && !o.isText ? u : u.slice(0, Math.max(0, r - s));
+  }), e;
+};
+function ft(n) {
+  return Object.prototype.toString.call(n) === "[object RegExp]";
+}
+class Z {
+  constructor(t) {
+    this.find = t.find, this.handler = t.handler;
+  }
+}
+const Ee = (n, t) => {
+  if (ft(t))
+    return t.exec(n);
+  const e = t(n);
+  if (!e)
+    return null;
+  const r = [e.text];
+  return r.index = e.index, r.input = n, r.data = e.data, e.replaceWith && (e.text.includes(e.replaceWith) || console.warn('[tiptap warn]: "inputRuleMatch.replaceWith" must be part of "inputRuleMatch.text".'), r.push(e.replaceWith)), r;
+};
+function z(n) {
+  var t;
+  const { editor: e, from: r, to: o, text: s, rules: i, plugin: c } = n, { view: a } = e;
+  if (a.composing)
+    return !1;
+  const l = a.state.doc.resolve(r);
+  if (
+    // check for code node
+    l.parent.type.spec.code || !((t = l.nodeBefore || l.nodeAfter) === null || t === void 0) && t.marks.find((f) => f.type.spec.code)
+  )
+    return !1;
+  let u = !1;
+  const d = Se(l) + s;
+  return i.forEach((f) => {
+    if (u)
+      return;
+    const p = Ee(d, f.find);
+    if (!p)
+      return;
+    const m = a.state.tr, h = Y({
+      state: a.state,
+      transaction: m
+    }), g = {
+      from: r - (p[0].length - s.length),
+      to: o
+    }, { commands: y, chain: v, can: w } = new Q({
+      editor: e,
+      state: h
+    });
+    f.handler({
+      state: h,
+      range: g,
+      match: p,
+      commands: y,
+      chain: v,
+      can: w
+    }) === null || !m.steps.length || (m.setMeta(c, {
+      transform: m,
+      from: r,
+      to: o,
+      text: s
+    }), a.dispatch(m), u = !0);
+  }), u;
+}
+function xe(n) {
+  const { editor: t, rules: e } = n, r = new I({
+    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: u } = a;
+          typeof u == "string" ? u = u : u = ut($.from(u), i.schema);
+          const { from: d } = a, f = d + u.length;
+          z({
+            editor: t,
+            from: d,
+            to: f,
+            text: u,
+            rules: e,
+            plugin: r
+          });
+        }), o.selectionSet || o.docChanged ? null : s;
+      }
+    },
+    props: {
+      handleTextInput(o, s, i, c) {
+        return z({
+          editor: t,
+          from: s,
+          to: i,
+          text: c,
+          rules: e,
+          plugin: r
+        });
+      },
+      handleDOMEvents: {
+        compositionend: (o) => (setTimeout(() => {
+          const { $cursor: s } = o.state.selection;
+          s && z({
+            editor: t,
+            from: s.pos,
+            to: s.pos,
+            text: "",
+            rules: e,
+            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: t,
+          from: i.pos,
+          to: i.pos,
+          text: `
+`,
+          rules: e,
+          plugin: r
+        }) : !1;
+      }
+    },
+    // @ts-ignore
+    isInputRules: !0
+  });
+  return r;
+}
+function Ce(n) {
+  return Object.prototype.toString.call(n).slice(8, -1);
+}
+function H(n) {
+  return Ce(n) !== "Object" ? !1 : n.constructor === Object && Object.getPrototypeOf(n) === Object.prototype;
+}
+function tt(n, t) {
+  const e = { ...n };
+  return H(n) && H(t) && Object.keys(t).forEach((r) => {
+    H(t[r]) && H(n[r]) ? e[r] = tt(n[r], t[r]) : e[r] = t[r];
+  }), e;
+}
+class U {
+  constructor(t = {}) {
+    this.type = "mark", this.name = "mark", this.parent = null, this.child = null, this.config = {
+      name: this.name,
+      defaultOptions: {}
+    }, this.config = {
+      ...this.config,
+      ...t
+    }, this.name = this.config.name, t.defaultOptions && Object.keys(t.defaultOptions).length > 0 && console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`), this.options = this.config.defaultOptions, this.config.addOptions && (this.options = b(k(this, "addOptions", {
+      name: this.name
+    }))), this.storage = b(k(this, "addStorage", {
+      name: this.name,
+      options: this.options
+    })) || {};
+  }
+  static create(t = {}) {
+    return new U(t);
+  }
+  configure(t = {}) {
+    const e = this.extend({
+      ...this.config,
+      addOptions: () => tt(this.options, t)
+    });
+    return e.name = this.name, e.parent = this.parent, e;
+  }
+  extend(t = {}) {
+    const e = new U(t);
+    return e.parent = this, this.child = e, e.name = t.name ? t.name : e.parent.name, t.defaultOptions && Object.keys(t.defaultOptions).length > 0 && console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${e.name}".`), e.options = b(k(e, "addOptions", {
+      name: e.name
+    })), e.storage = b(k(e, "addStorage", {
+      name: e.name,
+      options: e.options
+    })), e;
+  }
+  static handleExit({ editor: t, mark: e }) {
+    const { tr: r } = t.state, o = t.state.selection.$from;
+    if (o.pos === o.end()) {
+      const i = o.marks();
+      if (!!!i.find((l) => (l == null ? void 0 : l.type.name) === e.name))
+        return !1;
+      const a = i.find((l) => (l == null ? void 0 : l.type.name) === e.name);
+      return a && r.removeStoredMark(a), r.insertText(" ", o.pos), t.view.dispatch(r), !0;
+    }
+    return !1;
+  }
+}
+function Te(n) {
+  return typeof n == "number";
+}
+class Ae {
+  constructor(t) {
+    this.find = t.find, this.handler = t.handler;
+  }
+}
+const Pe = (n, t, e) => {
+  if (ft(t))
+    return [...n.matchAll(t)];
+  const r = t(n, e);
+  return r ? r.map((o) => {
+    const s = [o.text];
+    return s.index = o.index, s.input = n, 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 Oe(n) {
+  const { editor: t, state: e, from: r, to: o, rule: s, pasteEvent: i, dropEvent: c } = n, { commands: a, chain: l, can: u } = new Q({
+    editor: t,
+    state: e
+  }), d = [];
+  return e.doc.nodesBetween(r, o, (p, m) => {
+    if (!p.isTextblock || p.type.spec.code)
+      return;
+    const h = Math.max(r, m), g = Math.min(o, m + p.content.size), y = p.textBetween(h - m, g - m, void 0, "");
+    Pe(y, s.find, i).forEach((w) => {
+      if (w.index === void 0)
+        return;
+      const E = h + w.index + 1, M = E + w[0].length, x = {
+        from: e.tr.mapping.map(E),
+        to: e.tr.mapping.map(M)
+      }, T = s.handler({
+        state: e,
+        range: x,
+        match: w,
+        commands: a,
+        chain: l,
+        can: u,
+        pasteEvent: i,
+        dropEvent: c
+      });
+      d.push(T);
+    });
+  }), d.every((p) => p !== null);
+}
+let _ = null;
+const Ie = (n) => {
+  var t;
+  const e = new ClipboardEvent("paste", {
+    clipboardData: new DataTransfer()
+  });
+  return (t = e.clipboardData) === null || t === void 0 || t.setData("text/html", n), e;
+};
+function $e(n) {
+  const { editor: t, rules: e } = n;
+  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: u, from: d, to: f, rule: p, pasteEvt: m }) => {
+    const h = u.tr, g = Y({
+      state: u,
+      transaction: h
+    });
+    if (!(!Oe({
+      editor: t,
+      state: g,
+      from: Math.max(d - 1, 0),
+      to: f.b - 1,
+      rule: p,
+      pasteEvent: m,
+      dropEvent: c
+    }) || !h.steps.length)) {
+      try {
+        c = typeof DragEvent < "u" ? new DragEvent("drop") : null;
+      } catch {
+        c = null;
+      }
+      return i = typeof ClipboardEvent < "u" ? new ClipboardEvent("paste") : null, h;
+    }
+  };
+  return e.map((u) => new I({
+    // we register a global drag handler to track the current drag source element
+    view(d) {
+      const f = (m) => {
+        var h;
+        r = !((h = d.dom.parentElement) === null || h === void 0) && h.contains(m.target) ? d.dom.parentElement : null, r && (_ = t);
+      }, p = () => {
+        _ && (_ = null);
+      };
+      return window.addEventListener("dragstart", f), window.addEventListener("dragend", p), {
+        destroy() {
+          window.removeEventListener("dragstart", f), window.removeEventListener("dragend", p);
+        }
+      };
+    },
+    props: {
+      handleDOMEvents: {
+        drop: (d, f) => {
+          if (s = r === d.dom.parentElement, c = f, !s) {
+            const p = _;
+            p != null && p.isEditable && setTimeout(() => {
+              const m = p.state.selection;
+              m && p.commands.deleteRange({ from: m.from, to: m.to });
+            }, 10);
+          }
+          return !1;
+        },
+        paste: (d, f) => {
+          var p;
+          const m = (p = f.clipboardData) === null || p === void 0 ? void 0 : p.getData("text/html");
+          return i = f, o = !!(m != null && m.includes("data-pm-slice")), !1;
+        }
+      }
+    },
+    appendTransaction: (d, f, p) => {
+      const m = d[0], h = m.getMeta("uiEvent") === "paste" && !o, g = m.getMeta("uiEvent") === "drop" && !s, y = m.getMeta("applyPasteRules"), v = !!y;
+      if (!h && !g && !v)
+        return;
+      if (v) {
+        let { text: M } = y;
+        typeof M == "string" ? M = M : M = ut($.from(M), p.schema);
+        const { from: x } = y, T = x + M.length, A = Ie(M);
+        return a({
+          rule: u,
+          state: p,
+          from: x,
+          to: { b: T },
+          pasteEvt: A
+        });
+      }
+      const w = f.doc.content.findDiffStart(p.doc.content), E = f.doc.content.findDiffEnd(p.doc.content);
+      if (!(!Te(w) || !E || w === E.b))
+        return a({
+          rule: u,
+          state: p,
+          from: w,
+          to: E,
+          pasteEvt: i
+        });
+    }
+  }));
+}
+function Be(n) {
+  const t = n.filter((e, r) => n.indexOf(e) !== r);
+  return Array.from(new Set(t));
+}
+class R {
+  constructor(t, e) {
+    this.splittableMarks = [], this.editor = e, this.extensions = R.resolve(t), this.schema = Me(this.extensions, e), this.setupExtensions();
+  }
+  /**
+   * Returns a flattened and sorted extension list while
+   * also checking for duplicated extensions and warns the user.
+   * @param extensions An array of Tiptap extensions
+   * @returns An flattened and sorted array of Tiptap extensions
+   */
+  static resolve(t) {
+    const e = R.sort(R.flatten(t)), r = Be(e.map((o) => o.name));
+    return r.length && console.warn(`[tiptap warn]: Duplicate extension names found: [${r.map((o) => `'${o}'`).join(", ")}]. This can lead to issues.`), e;
+  }
+  /**
+   * Create a flattened array of extensions by traversing the `addExtensions` field.
+   * @param extensions An array of Tiptap extensions
+   * @returns A flattened array of Tiptap extensions
+   */
+  static flatten(t) {
+    return t.map((e) => {
+      const r = {
+        name: e.name,
+        options: e.options,
+        storage: e.storage
+      }, o = k(e, "addExtensions", r);
+      return o ? [e, ...this.flatten(o())] : e;
+    }).flat(10);
+  }
+  /**
+   * Sort extensions by priority.
+   * @param extensions An array of Tiptap extensions
+   * @returns A sorted array of Tiptap extensions by priority
+   */
+  static sort(t) {
+    return t.sort((r, o) => {
+      const s = k(r, "priority") || 100, i = k(o, "priority") || 100;
+      return s > i ? -1 : s < i ? 1 : 0;
+    });
+  }
+  /**
+   * 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 r = {
+        name: e.name,
+        options: e.options,
+        storage: e.storage,
+        editor: this.editor,
+        type: rt(e.name, this.schema)
+      }, o = k(e, "addCommands", r);
+      return o ? {
+        ...t,
+        ...o()
+      } : t;
+    }, {});
+  }
+  /**
+   * Get all registered Prosemirror plugins from the extensions.
+   * @returns An array of Prosemirror plugins
+   */
+  get plugins() {
+    const { editor: t } = this, e = R.sort([...this.extensions].reverse()), r = [], o = [], s = e.map((i) => {
+      const c = {
+        name: i.name,
+        options: i.options,
+        storage: i.storage,
+        editor: t,
+        type: rt(i.name, this.schema)
+      }, a = [], l = k(i, "addKeyboardShortcuts", c);
+      let u = {};
+      if (i.type === "mark" && k(i, "exitable", c) && (u.ArrowRight = () => U.handleExit({ editor: t, mark: i })), l) {
+        const h = Object.fromEntries(Object.entries(l()).map(([g, y]) => [g, () => y({ editor: t })]));
+        u = { ...u, ...h };
+      }
+      const d = _t(u);
+      a.push(d);
+      const f = k(i, "addInputRules", c);
+      bt(i, t.options.enableInputRules) && f && r.push(...f());
+      const p = k(i, "addPasteRules", c);
+      bt(i, t.options.enablePasteRules) && p && o.push(...p());
+      const m = k(i, "addProseMirrorPlugins", c);
+      if (m) {
+        const h = m();
+        a.push(...h);
+      }
+      return a;
+    }).flat();
+    return [
+      xe({
+        editor: t,
+        rules: r
+      }),
+      ...$e({
+        editor: t,
+        rules: o
+      }),
+      ...s
+    ];
+  }
+  /**
+   * Get all attributes from the extensions.
+   * @returns An array of attributes
+   */
+  get attributes() {
+    return Tt(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 } = X(this.extensions);
+    return Object.fromEntries(e.filter((r) => !!k(r, "addNodeView")).map((r) => {
+      const o = this.attributes.filter((a) => a.type === r.name), s = {
+        name: r.name,
+        options: r.options,
+        storage: r.storage,
+        editor: t,
+        type: S(r.name, this.schema)
+      }, i = k(r, "addNodeView", s);
+      if (!i)
+        return [];
+      const c = (a, l, u, d, f) => {
+        const p = it(a, o);
+        return i()({
+          // pass-through
+          node: a,
+          view: l,
+          getPos: u,
+          decorations: d,
+          innerDecorations: f,
+          // tiptap-specific
+          editor: t,
+          extension: r,
+          HTMLAttributes: p
+        });
+      };
+      return [r.name, c];
+    }));
+  }
+  /**
+   * Go through all extensions, create extension storages & setup marks
+   * & bind editor event listener.
+   */
+  setupExtensions() {
+    this.extensions.forEach((t) => {
+      var e;
+      this.editor.extensionStorage[t.name] = t.storage;
+      const r = {
+        name: t.name,
+        options: t.options,
+        storage: t.storage,
+        editor: this.editor,
+        type: rt(t.name, this.schema)
+      };
+      t.type === "mark" && (!((e = b(k(t, "keepOnSplit", r))) !== null && e !== void 0) || e) && this.splittableMarks.push(t.name);
+      const o = k(t, "onBeforeCreate", r), s = k(t, "onCreate", r), i = k(t, "onUpdate", r), c = k(t, "onSelectionUpdate", r), a = k(t, "onTransaction", r), l = k(t, "onFocus", r), u = k(t, "onBlur", r), d = k(t, "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), u && this.editor.on("blur", u), d && this.editor.on("destroy", d);
+    });
+  }
+}
+class C {
+  constructor(t = {}) {
+    this.type = "extension", this.name = "extension", this.parent = null, this.child = null, this.config = {
+      name: this.name,
+      defaultOptions: {}
+    }, this.config = {
+      ...this.config,
+      ...t
+    }, this.name = this.config.name, t.defaultOptions && Object.keys(t.defaultOptions).length > 0 && console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`), this.options = this.config.defaultOptions, this.config.addOptions && (this.options = b(k(this, "addOptions", {
+      name: this.name
+    }))), this.storage = b(k(this, "addStorage", {
+      name: this.name,
+      options: this.options
+    })) || {};
+  }
+  static create(t = {}) {
+    return new C(t);
+  }
+  configure(t = {}) {
+    const e = this.extend({
+      ...this.config,
+      addOptions: () => tt(this.options, t)
+    });
+    return e.name = this.name, e.parent = this.parent, e;
+  }
+  extend(t = {}) {
+    const e = new C({ ...this.config, ...t });
+    return e.parent = this, this.child = e, e.name = t.name ? t.name : e.parent.name, t.defaultOptions && Object.keys(t.defaultOptions).length > 0 && console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${e.name}".`), e.options = b(k(e, "addOptions", {
+      name: e.name
+    })), e.storage = b(k(e, "addStorage", {
+      name: e.name,
+      options: e.options
+    })), e;
+  }
+}
+function Pt(n, t, e) {
+  const { from: r, to: o } = t, { blockSeparator: s = `
+
+`, textSerializers: i = {} } = e || {};
+  let c = "";
+  return n.nodesBetween(r, o, (a, l, u, d) => {
+    var f;
+    a.isBlock && l > r && (c += s);
+    const p = i == null ? void 0 : i[a.type.name];
+    if (p)
+      return u && (c += p({
+        node: a,
+        pos: l,
+        parent: u,
+        index: d,
+        range: t
+      })), !1;
+    a.isText && (c += (f = a == null ? void 0 : a.text) === null || f === void 0 ? void 0 : f.slice(Math.max(r, l) - l, o - l));
+  }), c;
+}
+function Ot(n) {
+  return Object.fromEntries(Object.entries(n.nodes).filter(([, t]) => t.spec.toText).map(([t, e]) => [t, e.spec.toText]));
+}
+const Ne = C.create({
+  name: "clipboardTextSerializer",
+  addOptions() {
+    return {
+      blockSeparator: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new I({
+        key: new j("clipboardTextSerializer"),
+        props: {
+          clipboardTextSerializer: () => {
+            const { editor: n } = this, { state: t, schema: e } = n, { doc: r, selection: o } = t, { ranges: s } = o, i = Math.min(...s.map((u) => u.$from.pos)), c = Math.max(...s.map((u) => u.$to.pos)), a = Ot(e);
+            return Pt(r, { from: i, to: c }, {
+              ...this.options.blockSeparator !== void 0 ? { blockSeparator: this.options.blockSeparator } : {},
+              textSerializers: a
+            });
+          }
+        }
+      })
+    ];
+  }
+}), je = () => ({ editor: n, view: t }) => (requestAnimationFrame(() => {
+  var e;
+  n.isDestroyed || (t.dom.blur(), (e = window == null ? void 0 : window.getSelection()) === null || e === void 0 || e.removeAllRanges());
+}), !0), Re = (n = !1) => ({ commands: t }) => t.setContent("", n), Fe = () => ({ state: n, tr: t, dispatch: e }) => {
+  const { selection: r } = t, { ranges: o } = r;
+  return e && o.forEach(({ $from: s, $to: i }) => {
+    n.doc.nodesBetween(s.pos, i.pos, (c, a) => {
+      if (c.type.isText)
+        return;
+      const { doc: l, mapping: u } = t, d = l.resolve(u.map(a)), f = l.resolve(u.map(a + c.nodeSize)), p = d.blockRange(f);
+      if (!p)
+        return;
+      const m = Gt(p);
+      if (c.type.isTextblock) {
+        const { defaultType: h } = d.parent.contentMatchAt(d.index());
+        t.setNodeMarkup(p.start, h);
+      }
+      (m || m === 0) && t.lift(p, m);
+    });
+  }), !0;
+}, De = (n) => (t) => n(t), Le = () => ({ state: n, dispatch: t }) => he(n, t), ze = (n, t) => ({ editor: e, tr: r }) => {
+  const { state: o } = e, s = o.doc.slice(n.from, n.to);
+  r.deleteRange(n.from, n.to);
+  const i = r.mapping.map(t);
+  return r.insert(i, s.content), r.setSelection(new P(r.doc.resolve(Math.max(i - 1, 0)))), !0;
+}, He = () => ({ tr: n, dispatch: t }) => {
+  const { selection: e } = n, r = e.$anchor.node();
+  if (r.content.size > 0)
+    return !1;
+  const o = n.selection.$anchor;
+  for (let s = o.depth; s > 0; s -= 1)
+    if (o.node(s).type === r.type) {
+      if (t) {
+        const c = o.before(s), a = o.after(s);
+        n.delete(c, a).scrollIntoView();
+      }
+      return !0;
+    }
+  return !1;
+}, _e = (n) => ({ tr: t, state: e, dispatch: r }) => {
+  const o = S(n, e.schema), s = t.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);
+        t.delete(a, l).scrollIntoView();
+      }
+      return !0;
+    }
+  return !1;
+}, We = (n) => ({ tr: t, dispatch: e }) => {
+  const { from: r, to: o } = n;
+  return e && t.delete(r, o), !0;
+}, Ve = () => ({ state: n, dispatch: t }) => pe(n, t), Ke = () => ({ commands: n }) => n.keyboardShortcut("Enter"), Ue = () => ({ state: n, dispatch: t }) => fe(n, t);
+function q(n, t, e = { strict: !0 }) {
+  const r = Object.keys(t);
+  return r.length ? r.every((o) => e.strict ? t[o] === n[o] : ft(t[o]) ? t[o].test(n[o]) : t[o] === n[o]) : !0;
+}
+function It(n, t, e = {}) {
+  return n.find((r) => r.type === t && q(
+    // Only check equality for the attributes that are provided
+    Object.fromEntries(Object.keys(e).map((o) => [o, r.attrs[o]])),
+    e
+  ));
+}
+function vt(n, t, e = {}) {
+  return !!It(n, t, e);
+}
+function pt(n, t, e) {
+  var r;
+  if (!n || !t)
+    return;
+  let o = n.parent.childAfter(n.parentOffset);
+  if ((!o.node || !o.node.marks.some((u) => u.type === t)) && (o = n.parent.childBefore(n.parentOffset)), !o.node || !o.node.marks.some((u) => u.type === t) || (e = e || ((r = o.node.marks[0]) === null || r === void 0 ? void 0 : r.attrs), !It([...o.node.marks], t, e)))
+    return;
+  let i = o.index, c = n.start() + o.offset, a = i + 1, l = c + o.node.nodeSize;
+  for (; i > 0 && vt([...n.parent.child(i - 1).marks], t, e); )
+    i -= 1, c -= n.parent.child(i).nodeSize;
+  for (; a < n.parent.childCount && vt([...n.parent.child(a).marks], t, e); )
+    l += n.parent.child(a).nodeSize, a += 1;
+  return {
+    from: c,
+    to: l
+  };
+}
+function B(n, t) {
+  if (typeof n == "string") {
+    if (!t.marks[n])
+      throw Error(`There is no mark type named '${n}'. Maybe you forgot to add the extension?`);
+    return t.marks[n];
+  }
+  return n;
+}
+const qe = (n, t = {}) => ({ tr: e, state: r, dispatch: o }) => {
+  const s = B(n, r.schema), { doc: i, selection: c } = e, { $from: a, from: l, to: u } = c;
+  if (o) {
+    const d = pt(a, s, t);
+    if (d && d.from <= l && d.to >= u) {
+      const f = P.create(i, d.from, d.to);
+      e.setSelection(f);
+    }
+  }
+  return !0;
+}, Ge = (n) => (t) => {
+  const e = typeof n == "function" ? n(t) : n;
+  for (let r = 0; r < e.length; r += 1)
+    if (e[r](t))
+      return !0;
+  return !1;
+};
+function $t(n) {
+  return n instanceof P;
+}
+function O(n = 0, t = 0, e = 0) {
+  return Math.min(Math.max(n, t), e);
+}
+function Bt(n, t = null) {
+  if (!t)
+    return null;
+  const e = F.atStart(n), r = F.atEnd(n);
+  if (t === "start" || t === !0)
+    return e;
+  if (t === "end")
+    return r;
+  const o = e.from, s = r.to;
+  return t === "all" ? P.create(n, O(0, o, s), O(n.content.size, o, s)) : P.create(n, O(t, o, s), O(t, o, s));
+}
+function wt() {
+  return navigator.platform === "Android" || /android/i.test(navigator.userAgent);
+}
+function G() {
+  return [
+    "iPad Simulator",
+    "iPhone Simulator",
+    "iPod Simulator",
+    "iPad",
+    "iPhone",
+    "iPod"
+  ].includes(navigator.platform) || navigator.userAgent.includes("Mac") && "ontouchend" in document;
+}
+function Je() {
+  return typeof navigator < "u" ? /^((?!chrome|android).)*safari/i.test(navigator.userAgent) : !1;
+}
+const Ye = (n = null, t = {}) => ({ editor: e, view: r, tr: o, dispatch: s }) => {
+  t = {
+    scrollIntoView: !0,
+    ...t
+  };
+  const i = () => {
+    (G() || wt()) && r.dom.focus(), requestAnimationFrame(() => {
+      e.isDestroyed || (r.focus(), Je() && !G() && !wt() && r.dom.focus({ preventScroll: !0 }));
+    });
+  };
+  if (r.hasFocus() && n === null || n === !1)
+    return !0;
+  if (s && n === null && !$t(e.state.selection))
+    return i(), !0;
+  const c = Bt(o.doc, n) || e.state.selection, a = e.state.selection.eq(c);
+  return s && (a || o.setSelection(c), a && o.storedMarks && o.setStoredMarks(o.storedMarks), i()), !0;
+}, Qe = (n, t) => (e) => n.every((r, o) => t(r, { ...e, index: o })), Xe = (n, t) => ({ tr: e, commands: r }) => r.insertContentAt({ from: e.selection.from, to: e.selection.to }, n, t), Nt = (n) => {
+  const t = n.childNodes;
+  for (let e = t.length - 1; e >= 0; e -= 1) {
+    const r = t[e];
+    r.nodeType === 3 && r.nodeValue && /^(\n\s\s|\n)$/.test(r.nodeValue) ? n.removeChild(r) : r.nodeType === 1 && Nt(r);
+  }
+  return n;
+};
+function W(n) {
+  const t = `<body>${n}</body>`, e = new window.DOMParser().parseFromString(t, "text/html").body;
+  return Nt(e);
+}
+function D(n, t, e) {
+  if (n instanceof Vt || n instanceof $)
+    return n;
+  e = {
+    slice: !0,
+    parseOptions: {},
+    ...e
+  };
+  const r = typeof n == "object" && n !== null, o = typeof n == "string";
+  if (r)
+    try {
+      if (Array.isArray(n) && n.length > 0)
+        return $.fromArray(n.map((c) => t.nodeFromJSON(c)));
+      const i = t.nodeFromJSON(n);
+      return e.errorOnInvalidContent && i.check(), i;
+    } catch (s) {
+      if (e.errorOnInvalidContent)
+        throw new Error("[tiptap error]: Invalid JSON content", { cause: s });
+      return console.warn("[tiptap warn]: Invalid content.", "Passed value:", n, "Error:", s), D("", t, e);
+    }
+  if (o) {
+    if (e.errorOnInvalidContent) {
+      let i = !1, c = "";
+      const a = new xt({
+        topNode: t.spec.topNode,
+        marks: t.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: t.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 (e.slice ? nt.fromSchema(a).parseSlice(W(n), e.parseOptions) : nt.fromSchema(a).parse(W(n), e.parseOptions), e.errorOnInvalidContent && i)
+        throw new Error("[tiptap error]: Invalid HTML content", { cause: new Error(`Invalid element found: ${c}`) });
+    }
+    const s = nt.fromSchema(t);
+    return e.slice ? s.parseSlice(W(n), e.parseOptions).content : s.parse(W(n), e.parseOptions);
+  }
+  return D("", t, e);
+}
+function Ze(n, t, e) {
+  const r = n.steps.length - 1;
+  if (r < t)
+    return;
+  const o = n.steps[r];
+  if (!(o instanceof Jt || o instanceof Yt))
+    return;
+  const s = n.mapping.maps[r];
+  let i = 0;
+  s.forEach((c, a, l, u) => {
+    i === 0 && (i = u);
+  }), n.setSelection(F.near(n.doc.resolve(i), e));
+}
+const tn = (n) => !("type" in n), en = (n, t, e) => ({ tr: r, dispatch: o, editor: s }) => {
+  var i;
+  if (o) {
+    e = {
+      parseOptions: s.options.parseOptions,
+      updateSelection: !0,
+      applyInputRules: !1,
+      applyPasteRules: !1,
+      ...e
+    };
+    let c;
+    const a = (g) => {
+      s.emit("contentError", {
+        editor: s,
+        error: g,
+        disableCollaboration: () => {
+          s.storage.collaboration && (s.storage.collaboration.isDisabled = !0);
+        }
+      });
+    }, l = {
+      preserveWhitespace: "full",
+      ...e.parseOptions
+    };
+    if (!e.errorOnInvalidContent && !s.options.enableContentCheck && s.options.emitContentError)
+      try {
+        D(t, s.schema, {
+          parseOptions: l,
+          errorOnInvalidContent: !0
+        });
+      } catch (g) {
+        a(g);
+      }
+    try {
+      c = D(t, s.schema, {
+        parseOptions: l,
+        errorOnInvalidContent: (i = e.errorOnInvalidContent) !== null && i !== void 0 ? i : s.options.enableContentCheck
+      });
+    } catch (g) {
+      return a(g), !1;
+    }
+    let { from: u, to: d } = typeof n == "number" ? { from: n, to: n } : { from: n.from, to: n.to }, f = !0, p = !0;
+    if ((tn(c) ? c : [c]).forEach((g) => {
+      g.check(), f = f ? g.isText && g.marks.length === 0 : !1, p = p ? g.isBlock : !1;
+    }), u === d && p) {
+      const { parent: g } = r.doc.resolve(u);
+      g.isTextblock && !g.type.spec.code && !g.childCount && (u -= 1, d += 1);
+    }
+    let h;
+    if (f) {
+      if (Array.isArray(t))
+        h = t.map((g) => g.text || "").join("");
+      else if (t instanceof $) {
+        let g = "";
+        t.forEach((y) => {
+          y.text && (g += y.text);
+        }), h = g;
+      } else typeof t == "object" && t && t.text ? h = t.text : h = t;
+      r.insertText(h, u, d);
+    } else
+      h = c, r.replaceWith(u, d, h);
+    e.updateSelection && Ze(r, r.steps.length - 1, -1), e.applyInputRules && r.setMeta("applyInputRules", { from: u, text: h }), e.applyPasteRules && r.setMeta("applyPasteRules", { from: u, text: h });
+  }
+  return !0;
+}, nn = () => ({ state: n, dispatch: t }) => ie(n, t), rn = () => ({ state: n, dispatch: t }) => de(n, t), on = () => ({ state: n, dispatch: t }) => ue(n, t), sn = () => ({ state: n, dispatch: t }) => le(n, t), an = () => ({ state: n, dispatch: t, tr: e }) => {
+  try {
+    const r = Ct(n.doc, n.selection.$from.pos, -1);
+    return r == null ? !1 : (e.join(r, 2), t && t(e), !0);
+  } catch {
+    return !1;
+  }
+}, cn = () => ({ state: n, dispatch: t, tr: e }) => {
+  try {
+    const r = Ct(n.doc, n.selection.$from.pos, 1);
+    return r == null ? !1 : (e.join(r, 2), t && t(e), !0);
+  } catch {
+    return !1;
+  }
+}, ln = () => ({ state: n, dispatch: t }) => ce(n, t), dn = () => ({ state: n, dispatch: t }) => ae(n, t);
+function jt() {
+  return typeof navigator < "u" ? /Mac/.test(navigator.platform) : !1;
+}
+function un(n) {
+  const t = n.split(/-(?!$)/);
+  let e = t[t.length - 1];
+  e === "Space" && (e = " ");
+  let r, o, s, i;
+  for (let c = 0; c < t.length - 1; c += 1) {
+    const a = t[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))
+      G() || jt() ? i = !0 : o = !0;
+    else
+      throw new Error(`Unrecognized modifier name: ${a}`);
+  }
+  return r && (e = `Alt-${e}`), o && (e = `Ctrl-${e}`), i && (e = `Meta-${e}`), s && (e = `Shift-${e}`), e;
+}
+const fn = (n) => ({ editor: t, view: e, tr: r, dispatch: o }) => {
+  const s = un(n).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 = t.captureTransaction(() => {
+    e.someProp("handleKeyDown", (l) => l(e, c));
+  });
+  return a == null || a.steps.forEach((l) => {
+    const u = l.map(r.mapping);
+    u && o && r.maybeStep(u);
+  }), !0;
+};
+function L(n, t, e = {}) {
+  const { from: r, to: o, empty: s } = n.selection, i = t ? S(t, n.schema) : null, c = [];
+  n.doc.nodesBetween(r, o, (d, f) => {
+    if (d.isText)
+      return;
+    const p = Math.max(r, f), m = Math.min(o, f + d.nodeSize);
+    c.push({
+      node: d,
+      from: p,
+      to: m
+    });
+  });
+  const a = o - r, l = c.filter((d) => i ? i.name === d.node.type.name : !0).filter((d) => q(d.node.attrs, e, { strict: !1 }));
+  return s ? !!l.length : l.reduce((d, f) => d + f.to - f.from, 0) >= a;
+}
+const pn = (n, t = {}) => ({ state: e, dispatch: r }) => {
+  const o = S(n, e.schema);
+  return L(e, o, t) ? se(e, r) : !1;
+}, hn = () => ({ state: n, dispatch: t }) => oe(n, t), mn = (n) => ({ state: t, dispatch: e }) => {
+  const r = S(n, t.schema);
+  return ye(r)(t, e);
+}, gn = () => ({ state: n, dispatch: t }) => re(n, t);
+function et(n, t) {
+  return t.nodes[n] ? "node" : t.marks[n] ? "mark" : null;
+}
+function Mt(n, t) {
+  const e = typeof t == "string" ? [t] : t;
+  return Object.keys(n).reduce((r, o) => (e.includes(o) || (r[o] = n[o]), r), {});
+}
+const yn = (n, t) => ({ tr: e, state: r, dispatch: o }) => {
+  let s = null, i = null;
+  const c = et(typeof n == "string" ? n : n.name, r.schema);
+  return c ? (c === "node" && (s = S(n, r.schema)), c === "mark" && (i = B(n, r.schema)), o && e.selection.ranges.forEach((a) => {
+    r.doc.nodesBetween(a.$from.pos, a.$to.pos, (l, u) => {
+      s && s === l.type && e.setNodeMarkup(u, void 0, Mt(l.attrs, t)), i && l.marks.length && l.marks.forEach((d) => {
+        i === d.type && e.addMark(u, u + l.nodeSize, i.create(Mt(d.attrs, t)));
+      });
+    });
+  }), !0) : !1;
+}, kn = () => ({ tr: n, dispatch: t }) => (t && n.scrollIntoView(), !0), bn = () => ({ tr: n, dispatch: t }) => {
+  if (t) {
+    const e = new zt(n.doc);
+    n.setSelection(e);
+  }
+  return !0;
+}, vn = () => ({ state: n, dispatch: t }) => ne(n, t), wn = () => ({ state: n, dispatch: t }) => ee(n, t), Mn = () => ({ state: n, dispatch: t }) => te(n, t), Sn = () => ({ state: n, dispatch: t }) => Zt(n, t), En = () => ({ state: n, dispatch: t }) => Xt(n, t);
+function at(n, t, e = {}, r = {}) {
+  return D(n, t, {
+    slice: !1,
+    parseOptions: e,
+    errorOnInvalidContent: r.errorOnInvalidContent
+  });
+}
+const xn = (n, t = !1, e = {}, r = {}) => ({ editor: o, tr: s, dispatch: i, commands: c }) => {
+  var a, l;
+  const { doc: u } = s;
+  if (e.preserveWhitespace !== "full") {
+    const d = at(n, o.schema, e, {
+      errorOnInvalidContent: (a = r.errorOnInvalidContent) !== null && a !== void 0 ? a : o.options.enableContentCheck
+    });
+    return i && s.replaceWith(0, u.content.size, d).setMeta("preventUpdate", !t), !0;
+  }
+  return i && s.setMeta("preventUpdate", !t), c.insertContentAt({ from: 0, to: u.content.size }, n, {
+    parseOptions: e,
+    errorOnInvalidContent: (l = r.errorOnInvalidContent) !== null && l !== void 0 ? l : o.options.enableContentCheck
+  });
+};
+function Rt(n, t) {
+  const e = B(t, n.schema), { from: r, to: o, empty: s } = n.selection, i = [];
+  s ? (n.storedMarks && i.push(...n.storedMarks), i.push(...n.selection.$head.marks())) : n.doc.nodesBetween(r, o, (a) => {
+    i.push(...a.marks);
+  });
+  const c = i.find((a) => a.type.name === e.name);
+  return c ? { ...c.attrs } : {};
+}
+function yr(n, t) {
+  const e = new qt(n);
+  return t.forEach((r) => {
+    r.steps.forEach((o) => {
+      e.step(o);
+    });
+  }), e;
+}
+function Cn(n) {
+  for (let t = 0; t < n.edgeCount; t += 1) {
+    const { type: e } = n.edge(t);
+    if (e.isTextblock && !e.hasRequiredAttrs())
+      return e;
+  }
+  return null;
+}
+function kr(n, t, e) {
+  const r = [];
+  return n.nodesBetween(t.from, t.to, (o, s) => {
+    e(o) && r.push({
+      node: o,
+      pos: s
+    });
+  }), r;
+}
+function Tn(n, t) {
+  for (let e = n.depth; e > 0; e -= 1) {
+    const r = n.node(e);
+    if (t(r))
+      return {
+        pos: e > 0 ? n.before(e) : 0,
+        start: n.start(e),
+        depth: e,
+        node: r
+      };
+  }
+}
+function ht(n) {
+  return (t) => Tn(t.$from, n);
+}
+function An(n, t) {
+  const e = {
+    from: 0,
+    to: n.content.size
+  };
+  return Pt(n, e, t);
+}
+function Pn(n, t) {
+  const e = S(t, n.schema), { from: r, to: o } = n.selection, s = [];
+  n.doc.nodesBetween(r, o, (c) => {
+    s.push(c);
+  });
+  const i = s.reverse().find((c) => c.type.name === e.name);
+  return i ? { ...i.attrs } : {};
+}
+function On(n, t) {
+  const e = et(typeof t == "string" ? t : t.name, n.schema);
+  return e === "node" ? Pn(n, t) : e === "mark" ? Rt(n, t) : {};
+}
+function In(n, t = JSON.stringify) {
+  const e = {};
+  return n.filter((r) => {
+    const o = t(r);
+    return Object.prototype.hasOwnProperty.call(e, o) ? !1 : e[o] = !0;
+  });
+}
+function $n(n) {
+  const t = In(n);
+  return t.length === 1 ? t : t.filter((e, r) => !t.filter((s, i) => i !== r).some((s) => e.oldRange.from >= s.oldRange.from && e.oldRange.to <= s.oldRange.to && e.newRange.from >= s.newRange.from && e.newRange.to <= s.newRange.to));
+}
+function br(n) {
+  const { mapping: t, steps: e } = n, r = [];
+  return t.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 } = e[s];
+      if (c === void 0 || a === void 0)
+        return;
+      i.push({ from: c, to: a });
+    }
+    i.forEach(({ from: c, to: a }) => {
+      const l = t.slice(s).map(c, -1), u = t.slice(s).map(a), d = t.invert().map(l, -1), f = t.invert().map(u);
+      r.push({
+        oldRange: {
+          from: d,
+          to: f
+        },
+        newRange: {
+          from: l,
+          to: u
+        }
+      });
+    });
+  }), $n(r);
+}
+function Ft(n, t, e) {
+  const r = [];
+  return n === t ? e.resolve(n).marks().forEach((o) => {
+    const s = e.resolve(n), i = pt(s, o.type);
+    i && r.push({
+      mark: o,
+      ...i
+    });
+  }) : e.nodesBetween(n, t, (o, s) => {
+    !o || (o == null ? void 0 : o.nodeSize) === void 0 || r.push(...o.marks.map((i) => ({
+      from: s,
+      to: s + o.nodeSize,
+      mark: i
+    })));
+  }), r;
+}
+function K(n, t, e) {
+  return Object.fromEntries(Object.entries(e).filter(([r]) => {
+    const o = n.find((s) => s.type === t && s.name === r);
+    return o ? o.attribute.keepOnSplit : !1;
+  }));
+}
+function ct(n, t, e = {}) {
+  const { empty: r, ranges: o } = n.selection, s = t ? B(t, n.schema) : null;
+  if (r)
+    return !!(n.storedMarks || n.selection.$from.marks()).filter((d) => s ? s.name === d.type.name : !0).find((d) => q(d.attrs, e, { strict: !1 }));
+  let i = 0;
+  const c = [];
+  if (o.forEach(({ $from: d, $to: f }) => {
+    const p = d.pos, m = f.pos;
+    n.doc.nodesBetween(p, m, (h, g) => {
+      if (!h.isText && !h.marks.length)
+        return;
+      const y = Math.max(p, g), v = Math.min(m, g + h.nodeSize), w = v - y;
+      i += w, c.push(...h.marks.map((E) => ({
+        mark: E,
+        from: y,
+        to: v
+      })));
+    });
+  }), i === 0)
+    return !1;
+  const a = c.filter((d) => s ? s.name === d.mark.type.name : !0).filter((d) => q(d.mark.attrs, e, { strict: !1 })).reduce((d, f) => d + f.to - f.from, 0), l = c.filter((d) => s ? d.mark.type !== s && d.mark.type.excludes(s) : !0).reduce((d, f) => d + f.to - f.from, 0);
+  return (a > 0 ? a + l : a) >= i;
+}
+function Bn(n, t, e = {}) {
+  if (!t)
+    return L(n, null, e) || ct(n, null, e);
+  const r = et(t, n.schema);
+  return r === "node" ? L(n, t, e) : r === "mark" ? ct(n, t, e) : !1;
+}
+function St(n, t) {
+  const { nodeExtensions: e } = X(t), r = e.find((i) => i.name === n);
+  if (!r)
+    return !1;
+  const o = {
+    name: r.name,
+    options: r.options,
+    storage: r.storage
+  }, s = b(k(r, "group", o));
+  return typeof s != "string" ? !1 : s.split(" ").includes("list");
+}
+function mt(n, { checkChildren: t = !0, ignoreWhitespace: e = !1 } = {}) {
+  var r;
+  if (e) {
+    if (n.type.name === "hardBreak")
+      return !0;
+    if (n.isText)
+      return /^\s*$/m.test((r = n.text) !== null && r !== void 0 ? r : "");
+  }
+  if (n.isText)
+    return !n.text;
+  if (n.isAtom || n.isLeaf)
+    return !1;
+  if (n.content.childCount === 0)
+    return !0;
+  if (t) {
+    let o = !0;
+    return n.content.forEach((s) => {
+      o !== !1 && (mt(s, { ignoreWhitespace: e, checkChildren: t }) || (o = !1));
+    }), o;
+  }
+  return !1;
+}
+function vr(n) {
+  return n instanceof J;
+}
+function wr(n, t, e) {
+  const o = n.state.doc.content.size, s = O(t, 0, o), i = O(e, 0, o), c = n.coordsAtPos(s), a = n.coordsAtPos(i, -1), l = Math.min(c.top, a.top), u = Math.max(c.bottom, a.bottom), d = Math.min(c.left, a.left), f = Math.max(c.right, a.right), p = f - d, m = u - l, y = {
+    top: l,
+    bottom: u,
+    left: d,
+    right: f,
+    width: p,
+    height: m,
+    x: d,
+    y: l
+  };
+  return {
+    ...y,
+    toJSON: () => y
+  };
+}
+function Nn(n, t, e) {
+  var r;
+  const { selection: o } = t;
+  let s = null;
+  if ($t(o) && (s = o.$cursor), s) {
+    const c = (r = n.storedMarks) !== null && r !== void 0 ? r : s.marks();
+    return !!e.isInSet(c) || !c.some((a) => a.type.excludes(e));
+  }
+  const { ranges: i } = o;
+  return i.some(({ $from: c, $to: a }) => {
+    let l = c.depth === 0 ? n.doc.inlineContent && n.doc.type.allowsMarkType(e) : !1;
+    return n.doc.nodesBetween(c.pos, a.pos, (u, d, f) => {
+      if (l)
+        return !1;
+      if (u.isInline) {
+        const p = !f || f.type.allowsMarkType(e), m = !!e.isInSet(u.marks) || !u.marks.some((h) => h.type.excludes(e));
+        l = p && m;
+      }
+      return !l;
+    }), l;
+  });
+}
+const jn = (n, t = {}) => ({ tr: e, state: r, dispatch: o }) => {
+  const { selection: s } = e, { empty: i, ranges: c } = s, a = B(n, r.schema);
+  if (o)
+    if (i) {
+      const l = Rt(r, a);
+      e.addStoredMark(a.create({
+        ...l,
+        ...t
+      }));
+    } else
+      c.forEach((l) => {
+        const u = l.$from.pos, d = l.$to.pos;
+        r.doc.nodesBetween(u, d, (f, p) => {
+          const m = Math.max(p, u), h = Math.min(p + f.nodeSize, d);
+          f.marks.find((y) => y.type === a) ? f.marks.forEach((y) => {
+            a === y.type && e.addMark(m, h, a.create({
+              ...y.attrs,
+              ...t
+            }));
+          }) : e.addMark(m, h, a.create(t));
+        });
+      });
+  return Nn(r, e, a);
+}, Rn = (n, t) => ({ tr: e }) => (e.setMeta(n, t), !0), Fn = (n, t = {}) => ({ state: e, dispatch: r, chain: o }) => {
+  const s = S(n, e.schema);
+  let i;
+  return e.selection.$anchor.sameParent(e.selection.$head) && (i = e.selection.$anchor.parent.attrs), s.isTextblock ? o().command(({ commands: c }) => gt(s, { ...i, ...t })(e) ? !0 : c.clearNodes()).command(({ state: c }) => gt(s, { ...i, ...t })(c, r)).run() : (console.warn('[tiptap warn]: Currently "setNode()" only supports text block nodes.'), !1);
+}, Dn = (n) => ({ tr: t, dispatch: e }) => {
+  if (e) {
+    const { doc: r } = t, o = O(n, 0, r.content.size), s = J.create(r, o);
+    t.setSelection(s);
+  }
+  return !0;
+}, Ln = (n) => ({ tr: t, dispatch: e }) => {
+  if (e) {
+    const { doc: r } = t, { from: o, to: s } = typeof n == "number" ? { from: n, to: n } : n, i = P.atStart(r).from, c = P.atEnd(r).to, a = O(o, i, c), l = O(s, i, c), u = P.create(r, a, l);
+    t.setSelection(u);
+  }
+  return !0;
+}, zn = (n) => ({ state: t, dispatch: e }) => {
+  const r = S(n, t.schema);
+  return ge(r)(t, e);
+};
+function Et(n, t) {
+  const e = n.storedMarks || n.selection.$to.parentOffset && n.selection.$from.marks();
+  if (e) {
+    const r = e.filter((o) => t == null ? void 0 : t.includes(o.type.name));
+    n.tr.ensureMarks(r);
+  }
+}
+const Hn = ({ keepMarks: n = !0 } = {}) => ({ tr: t, state: e, dispatch: r, editor: o }) => {
+  const { selection: s, doc: i } = t, { $from: c, $to: a } = s, l = o.extensionManager.attributes, u = K(l, c.node().type.name, c.node().attrs);
+  if (s instanceof J && s.node.isBlock)
+    return !c.parentOffset || !V(i, c.pos) ? !1 : (r && (n && Et(e, o.extensionManager.splittableMarks), t.split(c.pos).scrollIntoView()), !0);
+  if (!c.parent.isBlock)
+    return !1;
+  const d = a.parentOffset === a.parent.content.size, f = c.depth === 0 ? void 0 : Cn(c.node(-1).contentMatchAt(c.indexAfter(-1)));
+  let p = d && f ? [
+    {
+      type: f,
+      attrs: u
+    }
+  ] : void 0, m = V(t.doc, t.mapping.map(c.pos), 1, p);
+  if (!p && !m && V(t.doc, t.mapping.map(c.pos), 1, f ? [{ type: f }] : void 0) && (m = !0, p = f ? [
+    {
+      type: f,
+      attrs: u
+    }
+  ] : void 0), r) {
+    if (m && (s instanceof P && t.deleteSelection(), t.split(t.mapping.map(c.pos), 1, p), f && !d && !c.parentOffset && c.parent.type !== f)) {
+      const h = t.mapping.map(c.before()), g = t.doc.resolve(h);
+      c.node(-1).canReplaceWith(g.index(), g.index() + 1, f) && t.setNodeMarkup(t.mapping.map(c.before()), f);
+    }
+    n && Et(e, o.extensionManager.splittableMarks), t.scrollIntoView();
+  }
+  return m;
+}, _n = (n, t = {}) => ({ tr: e, state: r, dispatch: o, editor: s }) => {
+  var i;
+  const c = S(n, r.schema), { $from: a, $to: l } = r.selection, u = r.selection.node;
+  if (u && u.isBlock || a.depth < 2 || !a.sameParent(l))
+    return !1;
+  const d = a.node(-1);
+  if (d.type !== c)
+    return !1;
+  const f = 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 y = $.empty;
+      const v = a.index(-1) ? 1 : a.index(-2) ? 2 : 3;
+      for (let A = a.depth - v; A >= a.depth - 3; A -= 1)
+        y = $.from(a.node(A).copy(y));
+      const w = a.indexAfter(-1) < a.node(-2).childCount ? 1 : a.indexAfter(-2) < a.node(-3).childCount ? 2 : 3, E = {
+        ...K(f, a.node().type.name, a.node().attrs),
+        ...t
+      }, M = ((i = c.contentMatch.defaultType) === null || i === void 0 ? void 0 : i.createAndFill(E)) || void 0;
+      y = y.append($.from(c.createAndFill(null, M) || void 0));
+      const x = a.before(a.depth - (v - 1));
+      e.replace(x, a.after(-w), new Kt(y, 4 - v, 0));
+      let T = -1;
+      e.doc.nodesBetween(x, e.doc.content.size, (A, Dt) => {
+        if (T > -1)
+          return !1;
+        A.isTextblock && A.content.size === 0 && (T = Dt + 1);
+      }), T > -1 && e.setSelection(P.near(e.doc.resolve(T))), e.scrollIntoView();
+    }
+    return !0;
+  }
+  const p = l.pos === a.end() ? d.contentMatchAt(0).defaultType : null, m = {
+    ...K(f, d.type.name, d.attrs),
+    ...t
+  }, h = {
+    ...K(f, a.node().type.name, a.node().attrs),
+    ...t
+  };
+  e.delete(a.pos, l.pos);
+  const g = p ? [
+    { type: c, attrs: m },
+    { type: p, attrs: h }
+  ] : [{ type: c, attrs: m }];
+  if (!V(e.doc, a.pos, 2))
+    return !1;
+  if (o) {
+    const { selection: y, storedMarks: v } = r, { splittableMarks: w } = s.extensionManager, E = v || y.$to.parentOffset && y.$from.marks();
+    if (e.split(a.pos, 2, g).scrollIntoView(), !E || !o)
+      return !0;
+    const M = E.filter((x) => w.includes(x.type.name));
+    e.ensureMarks(M);
+  }
+  return !0;
+}, ot = (n, t) => {
+  const e = ht((i) => i.type === t)(n.selection);
+  if (!e)
+    return !0;
+  const r = n.doc.resolve(Math.max(0, e.pos - 1)).before(e.depth);
+  if (r === void 0)
+    return !0;
+  const o = n.doc.nodeAt(r);
+  return e.node.type === (o == null ? void 0 : o.type) && dt(n.doc, e.pos) && n.join(e.pos), !0;
+}, st = (n, t) => {
+  const e = ht((i) => i.type === t)(n.selection);
+  if (!e)
+    return !0;
+  const r = n.doc.resolve(e.start).after(e.depth);
+  if (r === void 0)
+    return !0;
+  const o = n.doc.nodeAt(r);
+  return e.node.type === (o == null ? void 0 : o.type) && dt(n.doc, r) && n.join(r), !0;
+}, Wn = (n, t, e, r = {}) => ({ editor: o, tr: s, state: i, dispatch: c, chain: a, commands: l, can: u }) => {
+  const { extensions: d, splittableMarks: f } = o.extensionManager, p = S(n, i.schema), m = S(t, i.schema), { selection: h, storedMarks: g } = i, { $from: y, $to: v } = h, w = y.blockRange(v), E = g || h.$to.parentOffset && h.$from.marks();
+  if (!w)
+    return !1;
+  const M = ht((x) => St(x.type.name, d))(h);
+  if (w.depth >= 1 && M && w.depth - M.depth <= 1) {
+    if (M.node.type === p)
+      return l.liftListItem(m);
+    if (St(M.node.type.name, d) && p.validContent(M.node.content) && c)
+      return a().command(() => (s.setNodeMarkup(M.pos, p), !0)).command(() => ot(s, p)).command(() => st(s, p)).run();
+  }
+  return !e || !E || !c ? a().command(() => u().wrapInList(p, r) ? !0 : l.clearNodes()).wrapInList(p, r).command(() => ot(s, p)).command(() => st(s, p)).run() : a().command(() => {
+    const x = u().wrapInList(p, r), T = E.filter((A) => f.includes(A.type.name));
+    return s.ensureMarks(T), x ? !0 : l.clearNodes();
+  }).wrapInList(p, r).command(() => ot(s, p)).command(() => st(s, p)).run();
+}, Vn = (n, t = {}, e = {}) => ({ state: r, commands: o }) => {
+  const { extendEmptyMarkRange: s = !1 } = e, i = B(n, r.schema);
+  return ct(r, i, t) ? o.unsetMark(i, { extendEmptyMarkRange: s }) : o.setMark(i, t);
+}, Kn = (n, t, e = {}) => ({ state: r, commands: o }) => {
+  const s = S(n, r.schema), i = S(t, r.schema), c = L(r, s, e);
+  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, ...e });
+}, Un = (n, t = {}) => ({ state: e, commands: r }) => {
+  const o = S(n, e.schema);
+  return L(e, o, t) ? r.lift(o) : r.wrapIn(o, t);
+}, qn = () => ({ state: n, dispatch: t }) => {
+  const e = n.plugins;
+  for (let r = 0; r < e.length; r += 1) {
+    const o = e[r];
+    let s;
+    if (o.spec.isInputRules && (s = o.getState(n))) {
+      if (t) {
+        const i = n.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, n.schema.text(s.text, a));
+        } else
+          i.delete(s.from, s.to);
+      }
+      return !0;
+    }
+  }
+  return !1;
+}, Gn = () => ({ tr: n, dispatch: t }) => {
+  const { selection: e } = n, { empty: r, ranges: o } = e;
+  return r || t && o.forEach((s) => {
+    n.removeMark(s.$from.pos, s.$to.pos);
+  }), !0;
+}, Jn = (n, t = {}) => ({ tr: e, state: r, dispatch: o }) => {
+  var s;
+  const { extendEmptyMarkRange: i = !1 } = t, { selection: c } = e, a = B(n, r.schema), { $from: l, empty: u, ranges: d } = c;
+  if (!o)
+    return !0;
+  if (u && i) {
+    let { from: f, to: p } = c;
+    const m = (s = l.marks().find((g) => g.type === a)) === null || s === void 0 ? void 0 : s.attrs, h = pt(l, a, m);
+    h && (f = h.from, p = h.to), e.removeMark(f, p, a);
+  } else
+    d.forEach((f) => {
+      e.removeMark(f.$from.pos, f.$to.pos, a);
+    });
+  return e.removeStoredMark(a), !0;
+}, Yn = (n, t = {}) => ({ tr: e, state: r, dispatch: o }) => {
+  let s = null, i = null;
+  const c = et(typeof n == "string" ? n : n.name, r.schema);
+  return c ? (c === "node" && (s = S(n, r.schema)), c === "mark" && (i = B(n, r.schema)), o && e.selection.ranges.forEach((a) => {
+    const l = a.$from.pos, u = a.$to.pos;
+    let d, f, p, m;
+    e.selection.empty ? r.doc.nodesBetween(l, u, (h, g) => {
+      s && s === h.type && (p = Math.max(g, l), m = Math.min(g + h.nodeSize, u), d = g, f = h);
+    }) : r.doc.nodesBetween(l, u, (h, g) => {
+      g < l && s && s === h.type && (p = Math.max(g, l), m = Math.min(g + h.nodeSize, u), d = g, f = h), g >= l && g <= u && (s && s === h.type && e.setNodeMarkup(g, void 0, {
+        ...h.attrs,
+        ...t
+      }), i && h.marks.length && h.marks.forEach((y) => {
+        if (i === y.type) {
+          const v = Math.max(g, l), w = Math.min(g + h.nodeSize, u);
+          e.addMark(v, w, i.create({
+            ...y.attrs,
+            ...t
+          }));
+        }
+      }));
+    }), f && (d !== void 0 && e.setNodeMarkup(d, void 0, {
+      ...f.attrs,
+      ...t
+    }), i && f.marks.length && f.marks.forEach((h) => {
+      i === h.type && e.addMark(p, m, i.create({
+        ...h.attrs,
+        ...t
+      }));
+    }));
+  }), !0) : !1;
+}, Qn = (n, t = {}) => ({ state: e, dispatch: r }) => {
+  const o = S(n, e.schema);
+  return Qt(o, t)(e, r);
+}, Xn = (n, t = {}) => ({ state: e, dispatch: r }) => {
+  const o = S(n, e.schema);
+  return me(o, t)(e, r);
+};
+var Zn = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  blur: je,
+  clearContent: Re,
+  clearNodes: Fe,
+  command: De,
+  createParagraphNear: Le,
+  cut: ze,
+  deleteCurrentNode: He,
+  deleteNode: _e,
+  deleteRange: We,
+  deleteSelection: Ve,
+  enter: Ke,
+  exitCode: Ue,
+  extendMarkRange: qe,
+  first: Ge,
+  focus: Ye,
+  forEach: Qe,
+  insertContent: Xe,
+  insertContentAt: en,
+  joinBackward: on,
+  joinDown: rn,
+  joinForward: sn,
+  joinItemBackward: an,
+  joinItemForward: cn,
+  joinTextblockBackward: ln,
+  joinTextblockForward: dn,
+  joinUp: nn,
+  keyboardShortcut: fn,
+  lift: pn,
+  liftEmptyBlock: hn,
+  liftListItem: mn,
+  newlineInCode: gn,
+  resetAttributes: yn,
+  scrollIntoView: kn,
+  selectAll: bn,
+  selectNodeBackward: vn,
+  selectNodeForward: wn,
+  selectParentNode: Mn,
+  selectTextblockEnd: Sn,
+  selectTextblockStart: En,
+  setContent: xn,
+  setMark: jn,
+  setMeta: Rn,
+  setNode: Fn,
+  setNodeSelection: Dn,
+  setTextSelection: Ln,
+  sinkListItem: zn,
+  splitBlock: Hn,
+  splitListItem: _n,
+  toggleList: Wn,
+  toggleMark: Vn,
+  toggleNode: Kn,
+  toggleWrap: Un,
+  undoInputRule: qn,
+  unsetAllMarks: Gn,
+  unsetMark: Jn,
+  updateAttributes: Yn,
+  wrapIn: Qn,
+  wrapInList: Xn
+});
+const tr = C.create({
+  name: "commands",
+  addCommands() {
+    return {
+      ...Zn
+    };
+  }
+}), er = C.create({
+  name: "drop",
+  addProseMirrorPlugins() {
+    return [
+      new I({
+        key: new j("tiptapDrop"),
+        props: {
+          handleDrop: (n, t, e, r) => {
+            this.editor.emit("drop", {
+              editor: this.editor,
+              event: t,
+              slice: e,
+              moved: r
+            });
+          }
+        }
+      })
+    ];
+  }
+}), nr = C.create({
+  name: "editable",
+  addProseMirrorPlugins() {
+    return [
+      new I({
+        key: new j("editable"),
+        props: {
+          editable: () => this.editor.options.editable
+        }
+      })
+    ];
+  }
+}), rr = new j("focusEvents"), or = C.create({
+  name: "focusEvents",
+  addProseMirrorPlugins() {
+    const { editor: n } = this;
+    return [
+      new I({
+        key: rr,
+        props: {
+          handleDOMEvents: {
+            focus: (t, e) => {
+              n.isFocused = !0;
+              const r = n.state.tr.setMeta("focus", { event: e }).setMeta("addToHistory", !1);
+              return t.dispatch(r), !1;
+            },
+            blur: (t, e) => {
+              n.isFocused = !1;
+              const r = n.state.tr.setMeta("blur", { event: e }).setMeta("addToHistory", !1);
+              return t.dispatch(r), !1;
+            }
+          }
+        }
+      })
+    ];
+  }
+}), sr = C.create({
+  name: "keymap",
+  addKeyboardShortcuts() {
+    const n = () => 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: u, $anchor: d } = a, { pos: f, parent: p } = d, m = d.parent.isTextblock && f > 0 ? c.doc.resolve(f - 1) : d, h = m.parent.type.spec.isolating, g = d.pos - d.parentOffset, y = h && m.parent.childCount === 1 ? g === d.pos : F.atStart(l).from === f;
+        return !u || !p.type.isTextblock || p.textContent.length || !y || y && d.parent.type.name === "paragraph" ? !1 : i.clearNodes();
+      }),
+      () => i.deleteSelection(),
+      () => i.joinBackward(),
+      () => i.selectNodeBackward()
+    ]), t = () => 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: n,
+      "Mod-Backspace": n,
+      "Shift-Backspace": n,
+      Delete: t,
+      "Mod-Delete": t,
+      "Mod-a": () => this.editor.commands.selectAll()
+    }, o = {
+      ...r
+    }, s = {
+      ...r,
+      "Ctrl-h": n,
+      "Alt-Backspace": n,
+      "Ctrl-d": t,
+      "Ctrl-Alt-Backspace": t,
+      "Alt-Delete": t,
+      "Alt-d": t,
+      "Ctrl-a": () => this.editor.commands.selectTextblockStart(),
+      "Ctrl-e": () => this.editor.commands.selectTextblockEnd()
+    };
+    return G() || 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 I({
+        key: new j("clearDocument"),
+        appendTransaction: (n, t, e) => {
+          if (n.some((h) => h.getMeta("composition")))
+            return;
+          const r = n.some((h) => h.docChanged) && !t.doc.eq(e.doc), o = n.some((h) => h.getMeta("preventClearDocument"));
+          if (!r || o)
+            return;
+          const { empty: s, from: i, to: c } = t.selection, a = F.atStart(t.doc).from, l = F.atEnd(t.doc).to;
+          if (s || !(i === a && c === l) || !mt(e.doc))
+            return;
+          const f = e.tr, p = Y({
+            state: e,
+            transaction: f
+          }), { commands: m } = new Q({
+            editor: this.editor,
+            state: p
+          });
+          if (m.clearNodes(), !!f.steps.length)
+            return f;
+        }
+      })
+    ];
+  }
+}), ir = C.create({
+  name: "paste",
+  addProseMirrorPlugins() {
+    return [
+      new I({
+        key: new j("tiptapPaste"),
+        props: {
+          handlePaste: (n, t, e) => {
+            this.editor.emit("paste", {
+              editor: this.editor,
+              event: t,
+              slice: e
+            });
+          }
+        }
+      })
+    ];
+  }
+}), ar = C.create({
+  name: "tabindex",
+  addProseMirrorPlugins() {
+    return [
+      new I({
+        key: new j("tabindex"),
+        props: {
+          attributes: () => this.editor.isEditable ? { tabindex: "0" } : {}
+        }
+      })
+    ];
+  }
+});
+class N {
+  get name() {
+    return this.node.type.name;
+  }
+  constructor(t, e, r = !1, o = null) {
+    this.currentNode = null, this.actualDepth = null, this.isBlock = r, this.resolvedPos = t, this.editor = e, this.currentNode = o;
+  }
+  get node() {
+    return this.currentNode || this.resolvedPos.node();
+  }
+  get element() {
+    return this.editor.view.domAtPos(this.pos).node;
+  }
+  get depth() {
+    var t;
+    return (t = this.actualDepth) !== null && t !== void 0 ? t : this.resolvedPos.depth;
+  }
+  get pos() {
+    return this.resolvedPos.pos;
+  }
+  get content() {
+    return this.node.content;
+  }
+  set content(t) {
+    let e = 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;
+      }
+      e = this.from + 1, r = this.to - 1;
+    }
+    this.editor.commands.insertContentAt({ from: e, to: r }, t);
+  }
+  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 t = this.resolvedPos.start(this.resolvedPos.depth - 1), e = this.resolvedPos.doc.resolve(t);
+    return new N(e, this.editor);
+  }
+  get before() {
+    let t = this.resolvedPos.doc.resolve(this.from - (this.isBlock ? 1 : 2));
+    return t.depth !== this.depth && (t = this.resolvedPos.doc.resolve(this.from - 3)), new N(t, this.editor);
+  }
+  get after() {
+    let t = this.resolvedPos.doc.resolve(this.to + (this.isBlock ? 2 : 1));
+    return t.depth !== this.depth && (t = this.resolvedPos.doc.resolve(this.to + 3)), new N(t, this.editor);
+  }
+  get children() {
+    const t = [];
+    return this.node.content.forEach((e, r) => {
+      const o = e.isBlock && !e.isTextblock, s = e.isAtom && !e.isText, i = this.pos + r + (s ? 0 : 1);
+      if (i < 0 || i > this.resolvedPos.doc.nodeSize - 2)
+        return;
+      const c = this.resolvedPos.doc.resolve(i);
+      if (!o && c.depth <= this.depth)
+        return;
+      const a = new N(c, this.editor, o, o ? e : null);
+      o && (a.actualDepth = this.depth + 1), t.push(new N(c, this.editor, o, o ? e : null));
+    }), t;
+  }
+  get firstChild() {
+    return this.children[0] || null;
+  }
+  get lastChild() {
+    const t = this.children;
+    return t[t.length - 1] || null;
+  }
+  closest(t, e = {}) {
+    let r = null, o = this.parent;
+    for (; o && !r; ) {
+      if (o.node.type.name === t)
+        if (Object.keys(e).length > 0) {
+          const s = o.node.attrs, i = Object.keys(e);
+          for (let c = 0; c < i.length; c += 1) {
+            const a = i[c];
+            if (s[a] !== e[a])
+              break;
+          }
+        } else
+          r = o;
+      o = o.parent;
+    }
+    return r;
+  }
+  querySelector(t, e = {}) {
+    return this.querySelectorAll(t, e, !0)[0] || null;
+  }
+  querySelectorAll(t, e = {}, r = !1) {
+    let o = [];
+    if (!this.children || this.children.length === 0)
+      return o;
+    const s = Object.keys(e);
+    return this.children.forEach((i) => {
+      r && o.length > 0 || (i.node.type.name === t && s.every((a) => e[a] === i.node.attrs[a]) && o.push(i), !(r && o.length > 0) && (o = o.concat(i.querySelectorAll(t, e, r))));
+    }), o;
+  }
+  setAttribute(t) {
+    const { tr: e } = this.editor.state;
+    e.setNodeMarkup(this.from, void 0, {
+      ...this.node.attrs,
+      ...t
+    }), this.editor.view.dispatch(e);
+  }
+}
+const cr = `.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;
+}
+
+.tippy-box[data-animation=fade][data-state=hidden] {
+  opacity: 0
+}`;
+function lr(n, t, e) {
+  const r = document.querySelector("style[data-tiptap-style]");
+  if (r !== null)
+    return r;
+  const o = document.createElement("style");
+  return t && o.setAttribute("nonce", t), o.setAttribute("data-tiptap-style", ""), o.innerHTML = n, document.getElementsByTagName("head")[0].appendChild(o), o;
+}
+class Mr extends ke {
+  constructor(t = {}) {
+    super(), this.isFocused = !1, this.isInitialized = !1, this.extensionStorage = {}, this.options = {
+      element: document.createElement("div"),
+      content: "",
+      injectCSS: !0,
+      injectNonce: void 0,
+      extensions: [],
+      autofocus: !1,
+      editable: !0,
+      editorProps: {},
+      parseOptions: {},
+      coreExtensionOptions: {},
+      enableInputRules: !0,
+      enablePasteRules: !0,
+      enableCoreExtensions: !0,
+      enableContentCheck: !1,
+      emitContentError: !1,
+      onBeforeCreate: () => null,
+      onCreate: () => null,
+      onUpdate: () => null,
+      onSelectionUpdate: () => null,
+      onTransaction: () => null,
+      onFocus: () => null,
+      onBlur: () => null,
+      onDestroy: () => null,
+      onContentError: ({ error: e }) => {
+        throw e;
+      },
+      onPaste: () => null,
+      onDrop: () => null
+    }, this.isCapturingTransaction = !1, this.capturedTransaction = null, this.setOptions(t), this.createExtensionManager(), this.createCommandManager(), this.createSchema(), this.on("beforeCreate", this.options.onBeforeCreate), this.emit("beforeCreate", { editor: this }), this.on("contentError", this.options.onContentError), this.createView(), this.injectCSS(), 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: e, slice: r, moved: o }) => this.options.onDrop(e, r, o)), this.on("paste", ({ event: e, slice: r }) => this.options.onPaste(e, r)), window.setTimeout(() => {
+      this.isDestroyed || (this.commands.focus(this.options.autofocus), this.emit("create", { editor: this }), this.isInitialized = !0);
+    }, 0);
+  }
+  /**
+   * 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 && document && (this.css = lr(cr, this.options.injectNonce));
+  }
+  /**
+   * Update editor options.
+   *
+   * @param options A list of options
+   */
+  setOptions(t = {}) {
+    this.options = {
+      ...this.options,
+      ...t
+    }, !(!this.view || !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 });
+  }
+  /**
+   * Returns whether the editor is editable.
+   */
+  get isEditable() {
+    return this.options.editable && this.view && this.view.editable;
+  }
+  /**
+   * Returns the editor state.
+   */
+  get state() {
+    return this.view.state;
+  }
+  /**
+   * 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 r = At(e) ? e(t, [...this.state.plugins]) : [...this.state.plugins, t], o = this.state.reconfigure({ plugins: r });
+    return this.view.updateState(o), o;
+  }
+  /**
+   * 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 r = e;
+    if ([].concat(t).forEach((s) => {
+      const i = typeof s == "string" ? `${s}$` : s.key;
+      r = r.filter((c) => !c.key.startsWith(i));
+    }), e.length === r.length)
+      return;
+    const o = this.state.reconfigure({
+      plugins: r
+    });
+    return this.view.updateState(o), o;
+  }
+  /**
+   * Creates an extension manager.
+   */
+  createExtensionManager() {
+    var t, e;
+    const o = [...this.options.enableCoreExtensions ? [
+      nr,
+      Ne.configure({
+        blockSeparator: (e = (t = this.options.coreExtensionOptions) === null || t === void 0 ? void 0 : t.clipboardTextSerializer) === null || e === void 0 ? void 0 : e.blockSeparator
+      }),
+      tr,
+      or,
+      sr,
+      ar,
+      er,
+      ir
+    ].filter((s) => typeof this.options.enableCoreExtensions == "object" ? this.options.enableCoreExtensions[s.name] !== !1 : !0) : [], ...this.options.extensions].filter((s) => ["extension", "node", "mark"].includes(s == null ? void 0 : s.type));
+    this.extensionManager = new R(o, this);
+  }
+  /**
+   * Creates an command manager.
+   */
+  createCommandManager() {
+    this.commandManager = new Q({
+      editor: this
+    });
+  }
+  /**
+   * Creates a ProseMirror schema.
+   */
+  createSchema() {
+    this.schema = this.extensionManager.schema;
+  }
+  /**
+   * Creates a ProseMirror view.
+   */
+  createView() {
+    var t;
+    let e;
+    try {
+      e = at(this.options.content, this.schema, this.options.parseOptions, { errorOnInvalidContent: this.options.enableContentCheck });
+    } catch (i) {
+      if (!(i instanceof Error) || !["[tiptap error]: Invalid JSON content", "[tiptap error]: Invalid HTML content"].includes(i.message))
+        throw i;
+      this.emit("contentError", {
+        editor: this,
+        error: i,
+        disableCollaboration: () => {
+          this.storage.collaboration && (this.storage.collaboration.isDisabled = !0), this.options.extensions = this.options.extensions.filter((c) => c.name !== "collaboration"), this.createExtensionManager();
+        }
+      }), e = at(this.options.content, this.schema, this.options.parseOptions, { errorOnInvalidContent: !1 });
+    }
+    const r = Bt(e, this.options.autofocus);
+    this.view = new Ht(this.options.element, {
+      ...this.options.editorProps,
+      attributes: {
+        // add `role="textbox"` to the editor element
+        role: "textbox",
+        ...(t = this.options.editorProps) === null || t === void 0 ? void 0 : t.attributes
+      },
+      dispatchTransaction: this.dispatchTransaction.bind(this),
+      state: Lt.create({
+        doc: e,
+        selection: r || void 0
+      })
+    });
+    const o = this.state.reconfigure({
+      plugins: this.extensionManager.plugins
+    });
+    this.view.updateState(o), this.createNodeViews(), this.prependClass();
+    const s = this.view.dom;
+    s.editor = this;
+  }
+  /**
+   * Creates all node views.
+   */
+  createNodeViews() {
+    this.view.isDestroyed || this.view.setProps({
+      nodeViews: this.extensionManager.nodeViews
+    });
+  }
+  /**
+   * Prepend class name to element.
+   */
+  prependClass() {
+    this.view.dom.className = `tiptap ${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((i) => {
+        var c;
+        return (c = this.capturedTransaction) === null || c === void 0 ? void 0 : c.step(i);
+      });
+      return;
+    }
+    const e = this.state.apply(t), r = !this.state.selection.eq(e.selection);
+    this.emit("beforeTransaction", {
+      editor: this,
+      transaction: t,
+      nextState: e
+    }), this.view.updateState(e), this.emit("transaction", {
+      editor: this,
+      transaction: t
+    }), r && this.emit("selectionUpdate", {
+      editor: this,
+      transaction: t
+    });
+    const o = t.getMeta("focus"), s = t.getMeta("blur");
+    o && this.emit("focus", {
+      editor: this,
+      event: o.event,
+      transaction: t
+    }), s && this.emit("blur", {
+      editor: this,
+      event: s.event,
+      transaction: t
+    }), !(!t.docChanged || t.getMeta("preventUpdate")) && this.emit("update", {
+      editor: this,
+      transaction: t
+    });
+  }
+  /**
+   * Get attributes of the currently selected node or mark.
+   */
+  getAttributes(t) {
+    return On(this.state, t);
+  }
+  isActive(t, e) {
+    const r = typeof t == "string" ? t : null, o = typeof t == "string" ? e : t;
+    return Bn(this.state, r, o);
+  }
+  /**
+   * 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: r = {} } = t || {};
+    return An(this.state.doc, {
+      blockSeparator: e,
+      textSerializers: {
+        ...Ot(this.schema),
+        ...r
+      }
+    });
+  }
+  /**
+   * Check if there is no content.
+   */
+  get isEmpty() {
+    return mt(this.state.doc);
+  }
+  /**
+   * Get the number of characters for the current document.
+   *
+   * @deprecated
+   */
+  getCharacterCount() {
+    return console.warn('[tiptap warn]: "editor.getCharacterCount()" is deprecated. Please use "editor.storage.characterCount.characters()" instead.'), this.state.doc.content.size - 2;
+  }
+  /**
+   * Destroy the editor.
+   */
+  destroy() {
+    if (this.emit("destroy"), this.view) {
+      const t = this.view.dom;
+      t && t.editor && delete t.editor, this.view.destroy();
+    }
+    this.removeAllListeners();
+  }
+  /**
+   * Check if the editor is already destroyed.
+   */
+  get isDestroyed() {
+    var t;
+    return !(!((t = this.view) === null || t === void 0) && t.docView);
+  }
+  $node(t, e) {
+    var r;
+    return ((r = this.$doc) === null || r === void 0 ? void 0 : r.querySelector(t, e)) || null;
+  }
+  $nodes(t, e) {
+    var r;
+    return ((r = this.$doc) === null || r === void 0 ? void 0 : r.querySelectorAll(t, e)) || null;
+  }
+  $pos(t) {
+    const e = this.state.doc.resolve(t);
+    return new N(e, this);
+  }
+  get $doc() {
+    return this.$pos(0);
+  }
+}
+function Sr(n) {
+  return new Z({
+    find: n.find,
+    handler: ({ state: t, range: e, match: r }) => {
+      const o = b(n.getAttributes, void 0, r);
+      if (o === !1 || o === null)
+        return null;
+      const { tr: s } = t, i = r[r.length - 1], c = r[0];
+      if (i) {
+        const a = c.search(/\S/), l = e.from + c.indexOf(i), u = l + i.length;
+        if (Ft(e.from, e.to, t.doc).filter((p) => p.mark.type.excluded.find((h) => h === n.type && h !== p.mark.type)).filter((p) => p.to > l).length)
+          return null;
+        u < e.to && s.delete(u, e.to), l > e.from && s.delete(e.from + a, l);
+        const f = e.from + a + i.length;
+        s.addMark(e.from + a, f, n.type.create(o || {})), s.removeStoredMark(n.type);
+      }
+    }
+  });
+}
+function Er(n) {
+  return new Z({
+    find: n.find,
+    handler: ({ state: t, range: e, match: r }) => {
+      const o = b(n.getAttributes, void 0, r) || {}, { tr: s } = t, i = e.from;
+      let c = e.to;
+      const a = n.type.create(o);
+      if (r[1]) {
+        const l = r[0].lastIndexOf(r[1]);
+        let u = i + l;
+        u > c ? u = c : c = u + r[1].length;
+        const d = r[0][r[0].length - 1];
+        s.insertText(d, i + r[0].length - 1), s.replaceWith(u, c, a);
+      } else if (r[0]) {
+        const l = n.type.isInline ? i : i - 1;
+        s.insert(l, n.type.create(o)).delete(s.mapping.map(i), s.mapping.map(c));
+      }
+      s.scrollIntoView();
+    }
+  });
+}
+function xr(n) {
+  return new Z({
+    find: n.find,
+    handler: ({ state: t, range: e, match: r }) => {
+      const o = t.doc.resolve(e.from), s = b(n.getAttributes, void 0, r) || {};
+      if (!o.node(-1).canReplaceWith(o.index(-1), o.indexAfter(-1), n.type))
+        return null;
+      t.tr.delete(e.from, e.to).setBlockType(e.from, e.from, n.type, s);
+    }
+  });
+}
+function Cr(n) {
+  return new Z({
+    find: n.find,
+    handler: ({ state: t, range: e, match: r, chain: o }) => {
+      const s = b(n.getAttributes, void 0, r) || {}, i = t.tr.delete(e.from, e.to), a = i.doc.resolve(e.from).blockRange(), l = a && Ut(a, n.type, s);
+      if (!l)
+        return null;
+      if (i.wrap(a, l), n.keepMarks && n.editor) {
+        const { selection: d, storedMarks: f } = t, { splittableMarks: p } = n.editor.extensionManager, m = f || d.$to.parentOffset && d.$from.marks();
+        if (m) {
+          const h = m.filter((g) => p.includes(g.type.name));
+          i.ensureMarks(h);
+        }
+      }
+      if (n.keepAttributes) {
+        const d = n.type.name === "bulletList" || n.type.name === "orderedList" ? "listItem" : "taskList";
+        o().updateAttributes(d, s).run();
+      }
+      const u = i.doc.resolve(e.from - 1).nodeBefore;
+      u && u.type === n.type && dt(i.doc, e.from - 1) && (!n.joinPredicate || n.joinPredicate(r, u)) && i.join(e.from - 1);
+    }
+  });
+}
+class lt {
+  constructor(t = {}) {
+    this.type = "node", this.name = "node", this.parent = null, this.child = null, this.config = {
+      name: this.name,
+      defaultOptions: {}
+    }, this.config = {
+      ...this.config,
+      ...t
+    }, this.name = this.config.name, t.defaultOptions && Object.keys(t.defaultOptions).length > 0 && console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${this.name}".`), this.options = this.config.defaultOptions, this.config.addOptions && (this.options = b(k(this, "addOptions", {
+      name: this.name
+    }))), this.storage = b(k(this, "addStorage", {
+      name: this.name,
+      options: this.options
+    })) || {};
+  }
+  static create(t = {}) {
+    return new lt(t);
+  }
+  configure(t = {}) {
+    const e = this.extend({
+      ...this.config,
+      addOptions: () => tt(this.options, t)
+    });
+    return e.name = this.name, e.parent = this.parent, e;
+  }
+  extend(t = {}) {
+    const e = new lt(t);
+    return e.parent = this, this.child = e, e.name = t.name ? t.name : e.parent.name, t.defaultOptions && Object.keys(t.defaultOptions).length > 0 && console.warn(`[tiptap warn]: BREAKING CHANGE: "defaultOptions" is deprecated. Please use "addOptions" instead. Found in extension: "${e.name}".`), e.options = b(k(e, "addOptions", {
+      name: e.name
+    })), e.storage = b(k(e, "addStorage", {
+      name: e.name,
+      options: e.options
+    })), e;
+  }
+}
+function Tr(n) {
+  return new Ae({
+    find: n.find,
+    handler: ({ state: t, range: e, match: r, pasteEvent: o }) => {
+      const s = b(n.getAttributes, void 0, r, o);
+      if (s === !1 || s === null)
+        return null;
+      const { tr: i } = t, c = r[r.length - 1], a = r[0];
+      let l = e.to;
+      if (c) {
+        const u = a.search(/\S/), d = e.from + a.indexOf(c), f = d + c.length;
+        if (Ft(e.from, e.to, t.doc).filter((m) => m.mark.type.excluded.find((g) => g === n.type && g !== m.mark.type)).filter((m) => m.to > d).length)
+          return null;
+        f < e.to && i.delete(f, e.to), d > e.from && i.delete(e.from + u, d), l = e.from + u + c.length, i.addMark(e.from + u, l, n.type.create(s || {})), i.removeStoredMark(n.type);
+      }
+    }
+  });
+}
+function Ar(n, t) {
+  const { selection: e } = n, { $from: r } = e;
+  if (e instanceof J) {
+    const s = r.index();
+    return r.parent.canReplaceWith(s, s + 1, t);
+  }
+  let o = r.depth;
+  for (; o >= 0; ) {
+    const s = r.index(o);
+    if (r.node(o).contentMatchAt(s).matchType(t))
+      return !0;
+    o -= 1;
+  }
+  return !1;
+}
+export {
+  Q as CommandManager,
+  Mr as Editor,
+  C as Extension,
+  Z as InputRule,
+  U as Mark,
+  lt as Node,
+  N as NodePos,
+  Ae as PasteRule,
+  b as callOrReturn,
+  Ar as canInsertNode,
+  yr as combineTransactionSteps,
+  Y as createChainableState,
+  at as createDocument,
+  D as createNodeFromContent,
+  lr as createStyleTag,
+  Cn as defaultBlockAt,
+  Mt as deleteProps,
+  W as elementFromString,
+  kr as findChildrenInRange,
+  Be as findDuplicates,
+  ht as findParentNode,
+  Tn as findParentNodeClosestToPos,
+  we as fromString,
+  On as getAttributes,
+  Tt as getAttributesFromExtensions,
+  br as getChangedRanges,
+  k as getExtensionField,
+  ut as getHTMLFromFragment,
+  Rt as getMarkAttributes,
+  pt as getMarkRange,
+  B as getMarkType,
+  Ft as getMarksBetween,
+  Pn as getNodeAttributes,
+  S as getNodeType,
+  it as getRenderedAttributes,
+  Me as getSchemaByResolvedExtensions,
+  rt as getSchemaTypeByName,
+  et as getSchemaTypeNameByName,
+  K as getSplittedAttributes,
+  An as getText,
+  Pt as getTextBetween,
+  Se as getTextContentFromNodes,
+  Ot as getTextSerializersFromSchema,
+  yt as injectExtensionAttributesToParseRule,
+  xe as inputRulesPlugin,
+  Bn as isActive,
+  ve as isEmptyObject,
+  bt as isExtensionRulesEnabled,
+  At as isFunction,
+  St as isList,
+  jt as isMacOS,
+  ct as isMarkActive,
+  L as isNodeActive,
+  mt as isNodeEmpty,
+  vr as isNodeSelection,
+  Te as isNumber,
+  H as isPlainObject,
+  ft as isRegExp,
+  Je as isSafari,
+  $t as isTextSelection,
+  G as isiOS,
+  Sr as markInputRule,
+  Tr as markPasteRule,
+  be as mergeAttributes,
+  tt as mergeDeep,
+  O as minMax,
+  Er as nodeInputRule,
+  q as objectIncludes,
+  $e as pasteRulesPlugin,
+  wr as posToDOMRect,
+  In as removeDuplicates,
+  Bt as resolveFocusPosition,
+  Ze as selectionToInsertionEnd,
+  X as splitExtensions,
+  xr as textblockTypeInputRule,
+  Cr as wrappingInputRule
+};