ablok-components 0.3.32 → 0.3.34

package/dist/index-C9XBp_Jh.mjs

@@ -0,0 +1,2333 @@
+import { e as b, a$ as E, aE as y, d as K, aC as B, aB as D, b0 as C, b1 as I, b2 as A, aZ as G, b3 as H, aH as He, i as Ne, at as he, b4 as J, b as w, aP as fe, ar as X, aj as Oe, ai as Re, a2 as me, a0 as _e, a3 as $e, aL as ee, b5 as Be, b6 as De, b7 as te, b8 as ge, b9 as N, ba as j, bb as ze, h as Ke, W as je, as as Ve } from "./index-Ki1Egcx9.mjs";
+import { h as ne, B as We } from "./index-Bk6yOA7Y.mjs";
+import { Link as Fe } from "./index-DbvQcSeJ.mjs";
+var Ue = /^\s*>\s$/, Ge = b.create({
+  name: "blockquote",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  content: "block+",
+  group: "block",
+  defining: !0,
+  parseHTML() {
+    return [{ tag: "blockquote" }];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return /* @__PURE__ */ ne("blockquote", { ...y(this.options.HTMLAttributes, e), children: /* @__PURE__ */ ne("slot", {}) });
+  },
+  parseMarkdown: (e, t) => t.createNode("blockquote", void 0, t.parseChildren(e.tokens || [])),
+  renderMarkdown: (e, t) => {
+    if (!e.content)
+      return "";
+    const n = ">", s = [];
+    return e.content.forEach((r) => {
+      const a = t.renderChildren([r]).split(`
+`).map((l) => l.trim() === "" ? n : `${n} ${l}`);
+      s.push(a.join(`
+`));
+    }), s.join(`
+${n}
+`);
+  },
+  addCommands() {
+    return {
+      setBlockquote: () => ({ commands: e }) => e.wrapIn(this.name),
+      toggleBlockquote: () => ({ commands: e }) => e.toggleWrap(this.name),
+      unsetBlockquote: () => ({ commands: e }) => e.lift(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-b": () => this.editor.commands.toggleBlockquote()
+    };
+  },
+  addInputRules() {
+    return [
+      E({
+        find: Ue,
+        type: this.type
+      })
+    ];
+  }
+}), Xe = /(^|[^`])`([^`]+)`(?!`)$/, qe = /(^|[^`])`([^`]+)`(?!`)/g, Ye = K.create({
+  name: "code",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  excludes: "_",
+  code: !0,
+  exitable: !0,
+  parseHTML() {
+    return [{ tag: "code" }];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["code", y(this.options.HTMLAttributes, e), 0];
+  },
+  markdownTokenName: "codespan",
+  parseMarkdown: (e, t) => t.applyMark("code", [{ type: "text", text: e.text || "" }]),
+  renderMarkdown: (e, t) => e.content ? `\`${t.renderChildren(e.content)}\`` : "",
+  addCommands() {
+    return {
+      setCode: () => ({ commands: e }) => e.setMark(this.name),
+      toggleCode: () => ({ commands: e }) => e.toggleMark(this.name),
+      unsetCode: () => ({ commands: e }) => e.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-e": () => this.editor.commands.toggleCode()
+    };
+  },
+  addInputRules() {
+    return [
+      D({
+        find: Xe,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      B({
+        find: qe,
+        type: this.type
+      })
+    ];
+  }
+}), W = 4, Je = /^```([a-z]+)?[\s\n]$/, Ze = /^~~~([a-z]+)?[\s\n]$/, Qe = b.create({
+  name: "codeBlock",
+  addOptions() {
+    return {
+      languageClassPrefix: "language-",
+      exitOnTripleEnter: !0,
+      exitOnArrowDown: !0,
+      defaultLanguage: null,
+      enableTabIndentation: !1,
+      tabSize: W,
+      HTMLAttributes: {}
+    };
+  },
+  content: "text*",
+  marks: "",
+  group: "block",
+  code: !0,
+  defining: !0,
+  addAttributes() {
+    return {
+      language: {
+        default: this.options.defaultLanguage,
+        parseHTML: (e) => {
+          var t;
+          const { languageClassPrefix: n } = this.options;
+          if (!n)
+            return null;
+          const i = [...((t = e.firstElementChild) == null ? void 0 : t.classList) || []].filter((o) => o.startsWith(n)).map((o) => o.replace(n, ""))[0];
+          return i || null;
+        },
+        rendered: !1
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "pre",
+        preserveWhitespace: "full"
+      }
+    ];
+  },
+  renderHTML({ node: e, HTMLAttributes: t }) {
+    return [
+      "pre",
+      y(this.options.HTMLAttributes, t),
+      [
+        "code",
+        {
+          class: e.attrs.language ? this.options.languageClassPrefix + e.attrs.language : null
+        },
+        0
+      ]
+    ];
+  },
+  markdownTokenName: "code",
+  parseMarkdown: (e, t) => {
+    var n;
+    return ((n = e.raw) == null ? void 0 : n.startsWith("```")) === !1 && e.codeBlockStyle !== "indented" ? [] : t.createNode(
+      "codeBlock",
+      { language: e.lang || null },
+      e.text ? [t.createTextNode(e.text)] : []
+    );
+  },
+  renderMarkdown: (e, t) => {
+    var n;
+    let s = "";
+    const r = ((n = e.attrs) == null ? void 0 : n.language) || "";
+    return e.content ? s = [`\`\`\`${r}`, t.renderChildren(e.content), "```"].join(`
+`) : s = `\`\`\`${r}
+
+\`\`\``, s;
+  },
+  addCommands() {
+    return {
+      setCodeBlock: (e) => ({ commands: t }) => t.setNode(this.name, e),
+      toggleCodeBlock: (e) => ({ commands: t }) => t.toggleNode(this.name, "paragraph", e)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Alt-c": () => this.editor.commands.toggleCodeBlock(),
+      // remove code block when at start of document or code block is empty
+      Backspace: () => {
+        const { empty: e, $anchor: t } = this.editor.state.selection, n = t.pos === 1;
+        return !e || t.parent.type.name !== this.name ? !1 : n || !t.parent.textContent.length ? this.editor.commands.clearNodes() : !1;
+      },
+      // handle tab indentation
+      Tab: ({ editor: e }) => {
+        var t;
+        if (!this.options.enableTabIndentation)
+          return !1;
+        const n = (t = this.options.tabSize) != null ? t : W, { state: s } = e, { selection: r } = s, { $from: i, empty: o } = r;
+        if (i.parent.type !== this.type)
+          return !1;
+        const a = " ".repeat(n);
+        return o ? e.commands.insertContent(a) : e.commands.command(({ tr: l }) => {
+          const { from: u, to: p } = r, h = s.doc.textBetween(u, p, `
+`, `
+`).split(`
+`).map((f) => a + f).join(`
+`);
+          return l.replaceWith(u, p, s.schema.text(h)), !0;
+        });
+      },
+      // handle shift+tab reverse indentation
+      "Shift-Tab": ({ editor: e }) => {
+        var t;
+        if (!this.options.enableTabIndentation)
+          return !1;
+        const n = (t = this.options.tabSize) != null ? t : W, { state: s } = e, { selection: r } = s, { $from: i, empty: o } = r;
+        return i.parent.type !== this.type ? !1 : o ? e.commands.command(({ tr: a }) => {
+          var l;
+          const { pos: u } = i, p = i.start(), d = i.end(), h = s.doc.textBetween(p, d, `
+`, `
+`).split(`
+`);
+          let f = 0, m = 0;
+          const k = u - p;
+          for (let T = 0; T < h.length; T += 1) {
+            if (m + h[T].length >= k) {
+              f = T;
+              break;
+            }
+            m += h[T].length + 1;
+          }
+          const Pe = ((l = h[f].match(/^ */)) == null ? void 0 : l[0]) || "", V = Math.min(Pe.length, n);
+          if (V === 0)
+            return !0;
+          let P = p;
+          for (let T = 0; T < f; T += 1)
+            P += h[T].length + 1;
+          return a.delete(P, P + V), u - P <= V && a.setSelection(A.create(a.doc, P)), !0;
+        }) : e.commands.command(({ tr: a }) => {
+          const { from: l, to: u } = r, c = s.doc.textBetween(l, u, `
+`, `
+`).split(`
+`).map((h) => {
+            var f;
+            const m = ((f = h.match(/^ */)) == null ? void 0 : f[0]) || "", k = Math.min(m.length, n);
+            return h.slice(k);
+          }).join(`
+`);
+          return a.replaceWith(l, u, s.schema.text(c)), !0;
+        });
+      },
+      // exit node on triple enter
+      Enter: ({ editor: e }) => {
+        if (!this.options.exitOnTripleEnter)
+          return !1;
+        const { state: t } = e, { selection: n } = t, { $from: s, empty: r } = n;
+        if (!r || s.parent.type !== this.type)
+          return !1;
+        const i = s.parentOffset === s.parent.nodeSize - 2, o = s.parent.textContent.endsWith(`
+
+`);
+        return !i || !o ? !1 : e.chain().command(({ tr: a }) => (a.delete(s.pos - 2, s.pos), !0)).exitCode().run();
+      },
+      // exit node on arrow down
+      ArrowDown: ({ editor: e }) => {
+        if (!this.options.exitOnArrowDown)
+          return !1;
+        const { state: t } = e, { selection: n, doc: s } = t, { $from: r, empty: i } = n;
+        if (!i || r.parent.type !== this.type || !(r.parentOffset === r.parent.nodeSize - 2))
+          return !1;
+        const a = r.after();
+        return a === void 0 ? !1 : s.nodeAt(a) ? e.commands.command(({ tr: u }) => (u.setSelection(H.near(s.resolve(a))), !0)) : e.commands.exitCode();
+      }
+    };
+  },
+  addInputRules() {
+    return [
+      G({
+        find: Je,
+        type: this.type,
+        getAttributes: (e) => ({
+          language: e[1]
+        })
+      }),
+      G({
+        find: Ze,
+        type: this.type,
+        getAttributes: (e) => ({
+          language: e[1]
+        })
+      })
+    ];
+  },
+  addProseMirrorPlugins() {
+    return [
+      // this plugin creates a code block for pasted content from VS Code
+      // we can also detect the copied code language
+      new C({
+        key: new I("codeBlockVSCodeHandler"),
+        props: {
+          handlePaste: (e, t) => {
+            if (!t.clipboardData || this.editor.isActive(this.type.name))
+              return !1;
+            const n = t.clipboardData.getData("text/plain"), s = t.clipboardData.getData("vscode-editor-data"), r = s ? JSON.parse(s) : void 0, i = r?.mode;
+            if (!n || !i)
+              return !1;
+            const { tr: o, schema: a } = e.state, l = a.text(n.replace(/\r\n?/g, `
+`));
+            return o.replaceSelectionWith(this.type.create({ language: i }, l)), o.selection.$from.parent.type !== this.type && o.setSelection(A.near(o.doc.resolve(Math.max(0, o.selection.from - 2)))), o.setMeta("paste", !0), e.dispatch(o), !0;
+          }
+        }
+      })
+    ];
+  }
+}), et = b.create({
+  name: "doc",
+  topNode: !0,
+  content: "block+",
+  renderMarkdown: (e, t) => e.content ? t.renderChildren(e.content, `
+
+`) : ""
+}), tt = b.create({
+  name: "hardBreak",
+  markdownTokenName: "br",
+  addOptions() {
+    return {
+      keepMarks: !0,
+      HTMLAttributes: {}
+    };
+  },
+  inline: !0,
+  group: "inline",
+  selectable: !1,
+  linebreakReplacement: !0,
+  parseHTML() {
+    return [{ tag: "br" }];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["br", y(this.options.HTMLAttributes, e)];
+  },
+  renderText() {
+    return `
+`;
+  },
+  renderMarkdown: () => `  
+`,
+  parseMarkdown: () => ({
+    type: "hardBreak"
+  }),
+  addCommands() {
+    return {
+      setHardBreak: () => ({ commands: e, chain: t, state: n, editor: s }) => e.first([
+        () => e.exitCode(),
+        () => e.command(() => {
+          const { selection: r, storedMarks: i } = n;
+          if (r.$from.parent.type.spec.isolating)
+            return !1;
+          const { keepMarks: o } = this.options, { splittableMarks: a } = s.extensionManager, l = i || r.$to.parentOffset && r.$from.marks();
+          return t().insertContent({ type: this.name }).command(({ tr: u, dispatch: p }) => {
+            if (p && l && o) {
+              const d = l.filter((c) => a.includes(c.type.name));
+              u.ensureMarks(d);
+            }
+            return !0;
+          }).run();
+        })
+      ])
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Enter": () => this.editor.commands.setHardBreak(),
+      "Shift-Enter": () => this.editor.commands.setHardBreak()
+    };
+  }
+}), nt = b.create({
+  name: "heading",
+  addOptions() {
+    return {
+      levels: [1, 2, 3, 4, 5, 6],
+      HTMLAttributes: {}
+    };
+  },
+  content: "inline*",
+  group: "block",
+  defining: !0,
+  addAttributes() {
+    return {
+      level: {
+        default: 1,
+        rendered: !1
+      }
+    };
+  },
+  parseHTML() {
+    return this.options.levels.map((e) => ({
+      tag: `h${e}`,
+      attrs: { level: e }
+    }));
+  },
+  renderHTML({ node: e, HTMLAttributes: t }) {
+    return [`h${this.options.levels.includes(e.attrs.level) ? e.attrs.level : this.options.levels[0]}`, y(this.options.HTMLAttributes, t), 0];
+  },
+  parseMarkdown: (e, t) => t.createNode("heading", { level: e.depth || 1 }, t.parseInline(e.tokens || [])),
+  renderMarkdown: (e, t) => {
+    var n;
+    const s = (n = e.attrs) != null && n.level ? parseInt(e.attrs.level, 10) : 1, r = "#".repeat(s);
+    return e.content ? `${r} ${t.renderChildren(e.content)}` : "";
+  },
+  addCommands() {
+    return {
+      setHeading: (e) => ({ commands: t }) => this.options.levels.includes(e.level) ? t.setNode(this.name, e) : !1,
+      toggleHeading: (e) => ({ commands: t }) => this.options.levels.includes(e.level) ? t.toggleNode(this.name, "paragraph", e) : !1
+    };
+  },
+  addKeyboardShortcuts() {
+    return this.options.levels.reduce(
+      (e, t) => ({
+        ...e,
+        [`Mod-Alt-${t}`]: () => this.editor.commands.toggleHeading({ level: t })
+      }),
+      {}
+    );
+  },
+  addInputRules() {
+    return this.options.levels.map((e) => G({
+      find: new RegExp(`^(#{${Math.min(...this.options.levels)},${e}})\\s$`),
+      type: this.type,
+      getAttributes: {
+        level: e
+      }
+    }));
+  }
+}), rt = b.create({
+  name: "horizontalRule",
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      nextNodeType: "paragraph"
+    };
+  },
+  group: "block",
+  parseHTML() {
+    return [{ tag: "hr" }];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["hr", y(this.options.HTMLAttributes, e)];
+  },
+  markdownTokenName: "hr",
+  parseMarkdown: (e, t) => t.createNode("horizontalRule"),
+  renderMarkdown: () => "---",
+  addCommands() {
+    return {
+      setHorizontalRule: () => ({ chain: e, state: t }) => {
+        if (!Ne(t, t.schema.nodes[this.name]))
+          return !1;
+        const { selection: n } = t, { $to: s } = n, r = e();
+        return he(n) ? r.insertContentAt(s.pos, {
+          type: this.name
+        }) : r.insertContent({ type: this.name }), r.command(({ state: i, tr: o, dispatch: a }) => {
+          if (a) {
+            const { $to: l } = o.selection, u = l.end();
+            if (l.nodeAfter)
+              l.nodeAfter.isTextblock ? o.setSelection(A.create(o.doc, l.pos + 1)) : l.nodeAfter.isBlock ? o.setSelection(J.create(o.doc, l.pos)) : o.setSelection(A.create(o.doc, l.pos));
+            else {
+              const p = i.schema.nodes[this.options.nextNodeType] || l.parent.type.contentMatch.defaultType, d = p?.create();
+              d && (o.insert(u, d), o.setSelection(A.create(o.doc, u + 1)));
+            }
+            o.scrollIntoView();
+          }
+          return !0;
+        }).run();
+      }
+    };
+  },
+  addInputRules() {
+    return [
+      He({
+        find: /^(?:---|—-|___\s|\*\*\*\s)$/,
+        type: this.type
+      })
+    ];
+  }
+}), st = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))$/, it = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))/g, ot = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))$/, at = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))/g, lt = K.create({
+  name: "italic",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "em"
+      },
+      {
+        tag: "i",
+        getAttrs: (e) => e.style.fontStyle !== "normal" && null
+      },
+      {
+        style: "font-style=normal",
+        clearMark: (e) => e.type.name === this.name
+      },
+      {
+        style: "font-style=italic"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["em", y(this.options.HTMLAttributes, e), 0];
+  },
+  addCommands() {
+    return {
+      setItalic: () => ({ commands: e }) => e.setMark(this.name),
+      toggleItalic: () => ({ commands: e }) => e.toggleMark(this.name),
+      unsetItalic: () => ({ commands: e }) => e.unsetMark(this.name)
+    };
+  },
+  markdownTokenName: "em",
+  parseMarkdown: (e, t) => t.applyMark("italic", t.parseInline(e.tokens || [])),
+  renderMarkdown: (e, t) => `*${t.renderChildren(e)}*`,
+  addKeyboardShortcuts() {
+    return {
+      "Mod-i": () => this.editor.commands.toggleItalic(),
+      "Mod-I": () => this.editor.commands.toggleItalic()
+    };
+  },
+  addInputRules() {
+    return [
+      D({
+        find: st,
+        type: this.type
+      }),
+      D({
+        find: ot,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      B({
+        find: it,
+        type: this.type
+      }),
+      B({
+        find: at,
+        type: this.type
+      })
+    ];
+  }
+}), dt = Object.defineProperty, ut = (e, t) => {
+  for (var n in t)
+    dt(e, n, { get: t[n], enumerable: !0 });
+}, ct = "listItem", re = "textStyle", se = /^\s*([-+*])\s$/, ke = b.create({
+  name: "bulletList",
+  addOptions() {
+    return {
+      itemTypeName: "listItem",
+      HTMLAttributes: {},
+      keepMarks: !1,
+      keepAttributes: !1
+    };
+  },
+  group: "block list",
+  content() {
+    return `${this.options.itemTypeName}+`;
+  },
+  parseHTML() {
+    return [{ tag: "ul" }];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["ul", y(this.options.HTMLAttributes, e), 0];
+  },
+  markdownTokenName: "list",
+  parseMarkdown: (e, t) => e.type !== "list" || e.ordered ? [] : {
+    type: "bulletList",
+    content: e.items ? t.parseChildren(e.items) : []
+  },
+  renderMarkdown: (e, t) => e.content ? t.renderChildren(e.content, `
+`) : "",
+  markdownOptions: {
+    indentsContent: !0
+  },
+  addCommands() {
+    return {
+      toggleBulletList: () => ({ commands: e, chain: t }) => this.options.keepAttributes ? t().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(ct, this.editor.getAttributes(re)).run() : e.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-8": () => this.editor.commands.toggleBulletList()
+    };
+  },
+  addInputRules() {
+    let e = E({
+      find: se,
+      type: this.type
+    });
+    return (this.options.keepMarks || this.options.keepAttributes) && (e = E({
+      find: se,
+      type: this.type,
+      keepMarks: this.options.keepMarks,
+      keepAttributes: this.options.keepAttributes,
+      getAttributes: () => this.editor.getAttributes(re),
+      editor: this.editor
+    })), [e];
+  }
+}), ve = b.create({
+  name: "listItem",
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      bulletListTypeName: "bulletList",
+      orderedListTypeName: "orderedList"
+    };
+  },
+  content: "paragraph block*",
+  defining: !0,
+  parseHTML() {
+    return [
+      {
+        tag: "li"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["li", y(this.options.HTMLAttributes, e), 0];
+  },
+  markdownTokenName: "list_item",
+  parseMarkdown: (e, t) => {
+    if (e.type !== "list_item")
+      return [];
+    let n = [];
+    if (e.tokens && e.tokens.length > 0)
+      if (e.tokens.some((r) => r.type === "paragraph"))
+        n = t.parseChildren(e.tokens);
+      else {
+        const r = e.tokens[0];
+        if (r && r.type === "text" && r.tokens && r.tokens.length > 0) {
+          if (n = [
+            {
+              type: "paragraph",
+              content: t.parseInline(r.tokens)
+            }
+          ], e.tokens.length > 1) {
+            const o = e.tokens.slice(1), a = t.parseChildren(o);
+            n.push(...a);
+          }
+        } else
+          n = t.parseChildren(e.tokens);
+      }
+    return n.length === 0 && (n = [
+      {
+        type: "paragraph",
+        content: []
+      }
+    ]), {
+      type: "listItem",
+      content: n
+    };
+  },
+  renderMarkdown: (e, t, n) => fe(
+    e,
+    t,
+    (s) => {
+      var r, i;
+      return s.parentType === "bulletList" ? "- " : s.parentType === "orderedList" ? `${(((i = (r = s.meta) == null ? void 0 : r.parentAttrs) == null ? void 0 : i.start) || 1) + s.index}. ` : "- ";
+    },
+    n
+  ),
+  addKeyboardShortcuts() {
+    return {
+      Enter: () => this.editor.commands.splitListItem(this.name),
+      Tab: () => this.editor.commands.sinkListItem(this.name),
+      "Shift-Tab": () => this.editor.commands.liftListItem(this.name)
+    };
+  }
+}), pt = {};
+ut(pt, {
+  findListItemPos: () => O,
+  getNextListDepth: () => Z,
+  handleBackspace: () => q,
+  handleDelete: () => Y,
+  hasListBefore: () => ye,
+  hasListItemAfter: () => ht,
+  hasListItemBefore: () => be,
+  listItemHasSubList: () => Me,
+  nextListIsDeeper: () => we,
+  nextListIsHigher: () => Le
+});
+var O = (e, t) => {
+  const { $from: n } = t.selection, s = me(e, t.schema);
+  let r = null, i = n.depth, o = n.pos, a = null;
+  for (; i > 0 && a === null; )
+    r = n.node(i), r.type === s ? a = i : (i -= 1, o -= 1);
+  return a === null ? null : { $pos: t.doc.resolve(o), depth: a };
+}, Z = (e, t) => {
+  const n = O(e, t);
+  if (!n)
+    return !1;
+  const [, s] = _e(t, e, n.$pos.pos + 4);
+  return s;
+}, ye = (e, t, n) => {
+  const { $anchor: s } = e.selection, r = Math.max(0, s.pos - 2), i = e.doc.resolve(r).node();
+  return !(!i || !n.includes(i.type.name));
+}, be = (e, t) => {
+  var n;
+  const { $anchor: s } = t.selection, r = t.doc.resolve(s.pos - 2);
+  return !(r.index() === 0 || ((n = r.nodeBefore) == null ? void 0 : n.type.name) !== e);
+}, Me = (e, t, n) => {
+  if (!n)
+    return !1;
+  const s = me(e, t.schema);
+  let r = !1;
+  return n.descendants((i) => {
+    i.type === s && (r = !0);
+  }), r;
+}, q = (e, t, n) => {
+  if (e.commands.undoInputRule())
+    return !0;
+  if (e.state.selection.from !== e.state.selection.to)
+    return !1;
+  if (!X(e.state, t) && ye(e.state, t, n)) {
+    const { $anchor: a } = e.state.selection, l = e.state.doc.resolve(a.before() - 1), u = [];
+    l.node().descendants((c, h) => {
+      c.type.name === t && u.push({ node: c, pos: h });
+    });
+    const p = u.at(-1);
+    if (!p)
+      return !1;
+    const d = e.state.doc.resolve(l.start() + p.pos + 1);
+    return e.chain().cut({ from: a.start() - 1, to: a.end() + 1 }, d.end()).joinForward().run();
+  }
+  if (!X(e.state, t) || !Oe(e.state))
+    return !1;
+  const s = O(t, e.state);
+  if (!s)
+    return !1;
+  const i = e.state.doc.resolve(s.$pos.pos - 2).node(s.depth), o = Me(t, e.state, i);
+  return be(t, e.state) && !o ? e.commands.joinItemBackward() : e.chain().liftListItem(t).run();
+}, we = (e, t) => {
+  const n = Z(e, t), s = O(e, t);
+  return !s || !n ? !1 : n > s.depth;
+}, Le = (e, t) => {
+  const n = Z(e, t), s = O(e, t);
+  return !s || !n ? !1 : n < s.depth;
+}, Y = (e, t) => {
+  if (!X(e.state, t) || !Re(e.state, t))
+    return !1;
+  const { selection: n } = e.state, { $from: s, $to: r } = n;
+  return !n.empty && s.sameParent(r) ? !1 : we(t, e.state) ? e.chain().focus(e.state.selection.from + 4).lift(t).joinBackward().run() : Le(t, e.state) ? e.chain().joinForward().joinBackward().run() : e.commands.joinItemForward();
+}, ht = (e, t) => {
+  var n;
+  const { $anchor: s } = t.selection, r = t.doc.resolve(s.pos - s.parentOffset - 2);
+  return !(r.index() === r.parent.childCount - 1 || ((n = r.nodeAfter) == null ? void 0 : n.type.name) !== e);
+}, Te = w.create({
+  name: "listKeymap",
+  addOptions() {
+    return {
+      listTypes: [
+        {
+          itemName: "listItem",
+          wrapperNames: ["bulletList", "orderedList"]
+        },
+        {
+          itemName: "taskItem",
+          wrapperNames: ["taskList"]
+        }
+      ]
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      Delete: ({ editor: e }) => {
+        let t = !1;
+        return this.options.listTypes.forEach(({ itemName: n }) => {
+          e.state.schema.nodes[n] !== void 0 && Y(e, n) && (t = !0);
+        }), t;
+      },
+      "Mod-Delete": ({ editor: e }) => {
+        let t = !1;
+        return this.options.listTypes.forEach(({ itemName: n }) => {
+          e.state.schema.nodes[n] !== void 0 && Y(e, n) && (t = !0);
+        }), t;
+      },
+      Backspace: ({ editor: e }) => {
+        let t = !1;
+        return this.options.listTypes.forEach(({ itemName: n, wrapperNames: s }) => {
+          e.state.schema.nodes[n] !== void 0 && q(e, n, s) && (t = !0);
+        }), t;
+      },
+      "Mod-Backspace": ({ editor: e }) => {
+        let t = !1;
+        return this.options.listTypes.forEach(({ itemName: n, wrapperNames: s }) => {
+          e.state.schema.nodes[n] !== void 0 && q(e, n, s) && (t = !0);
+        }), t;
+      }
+    };
+  }
+}), ie = /^(\s*)(\d+)\.\s+(.*)$/, ft = /^\s/;
+function mt(e) {
+  const t = [];
+  let n = 0, s = 0;
+  for (; n < e.length; ) {
+    const r = e[n], i = r.match(ie);
+    if (!i)
+      break;
+    const [, o, a, l] = i, u = o.length;
+    let p = l, d = n + 1;
+    const c = [r];
+    for (; d < e.length; ) {
+      const h = e[d];
+      if (h.match(ie))
+        break;
+      if (h.trim() === "")
+        c.push(h), p += `
+`, d += 1;
+      else if (h.match(ft))
+        c.push(h), p += `
+${h.slice(u + 2)}`, d += 1;
+      else
+        break;
+    }
+    t.push({
+      indent: u,
+      number: parseInt(a, 10),
+      content: p.trim(),
+      raw: c.join(`
+`)
+    }), s = d, n = d;
+  }
+  return [t, s];
+}
+function Ce(e, t, n) {
+  var s;
+  const r = [];
+  let i = 0;
+  for (; i < e.length; ) {
+    const o = e[i];
+    if (o.indent === t) {
+      const a = o.content.split(`
+`), l = ((s = a[0]) == null ? void 0 : s.trim()) || "", u = [];
+      l && u.push({
+        type: "paragraph",
+        raw: l,
+        tokens: n.inlineTokens(l)
+      });
+      const p = a.slice(1).join(`
+`).trim();
+      if (p) {
+        const h = n.blockTokens(p);
+        u.push(...h);
+      }
+      let d = i + 1;
+      const c = [];
+      for (; d < e.length && e[d].indent > t; )
+        c.push(e[d]), d += 1;
+      if (c.length > 0) {
+        const h = Math.min(...c.map((m) => m.indent)), f = Ce(c, h, n);
+        u.push({
+          type: "list",
+          ordered: !0,
+          start: c[0].number,
+          items: f,
+          raw: c.map((m) => m.raw).join(`
+`)
+        });
+      }
+      r.push({
+        type: "list_item",
+        raw: o.raw,
+        tokens: u
+      }), i = d;
+    } else
+      i += 1;
+  }
+  return r;
+}
+function gt(e, t) {
+  return e.map((n) => {
+    if (n.type !== "list_item")
+      return t.parseChildren([n])[0];
+    const s = [];
+    return n.tokens && n.tokens.length > 0 && n.tokens.forEach((r) => {
+      if (r.type === "paragraph" || r.type === "list" || r.type === "blockquote" || r.type === "code")
+        s.push(...t.parseChildren([r]));
+      else if (r.type === "text" && r.tokens) {
+        const i = t.parseChildren([r]);
+        s.push({
+          type: "paragraph",
+          content: i
+        });
+      } else {
+        const i = t.parseChildren([r]);
+        i.length > 0 && s.push(...i);
+      }
+    }), {
+      type: "listItem",
+      content: s
+    };
+  });
+}
+var kt = "listItem", oe = "textStyle", ae = /^(\d+)\.\s$/, xe = b.create({
+  name: "orderedList",
+  addOptions() {
+    return {
+      itemTypeName: "listItem",
+      HTMLAttributes: {},
+      keepMarks: !1,
+      keepAttributes: !1
+    };
+  },
+  group: "block list",
+  content() {
+    return `${this.options.itemTypeName}+`;
+  },
+  addAttributes() {
+    return {
+      start: {
+        default: 1,
+        parseHTML: (e) => e.hasAttribute("start") ? parseInt(e.getAttribute("start") || "", 10) : 1
+      },
+      type: {
+        default: null,
+        parseHTML: (e) => e.getAttribute("type")
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "ol"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    const { start: t, ...n } = e;
+    return t === 1 ? ["ol", y(this.options.HTMLAttributes, n), 0] : ["ol", y(this.options.HTMLAttributes, e), 0];
+  },
+  markdownTokenName: "list",
+  parseMarkdown: (e, t) => {
+    if (e.type !== "list" || !e.ordered)
+      return [];
+    const n = e.start || 1, s = e.items ? gt(e.items, t) : [];
+    return n !== 1 ? {
+      type: "orderedList",
+      attrs: { start: n },
+      content: s
+    } : {
+      type: "orderedList",
+      content: s
+    };
+  },
+  renderMarkdown: (e, t) => e.content ? t.renderChildren(e.content, `
+`) : "",
+  markdownTokenizer: {
+    name: "orderedList",
+    level: "block",
+    start: (e) => {
+      const t = e.match(/^(\s*)(\d+)\.\s+/), n = t?.index;
+      return n !== void 0 ? n : -1;
+    },
+    tokenize: (e, t, n) => {
+      var s;
+      const r = e.split(`
+`), [i, o] = mt(r);
+      if (i.length === 0)
+        return;
+      const a = Ce(i, 0, n);
+      return a.length === 0 ? void 0 : {
+        type: "list",
+        ordered: !0,
+        start: ((s = i[0]) == null ? void 0 : s.number) || 1,
+        items: a,
+        raw: r.slice(0, o).join(`
+`)
+      };
+    }
+  },
+  markdownOptions: {
+    indentsContent: !0
+  },
+  addCommands() {
+    return {
+      toggleOrderedList: () => ({ commands: e, chain: t }) => this.options.keepAttributes ? t().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(kt, this.editor.getAttributes(oe)).run() : e.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-7": () => this.editor.commands.toggleOrderedList()
+    };
+  },
+  addInputRules() {
+    let e = E({
+      find: ae,
+      type: this.type,
+      getAttributes: (t) => ({ start: +t[1] }),
+      joinPredicate: (t, n) => n.childCount + n.attrs.start === +t[1]
+    });
+    return (this.options.keepMarks || this.options.keepAttributes) && (e = E({
+      find: ae,
+      type: this.type,
+      keepMarks: this.options.keepMarks,
+      keepAttributes: this.options.keepAttributes,
+      getAttributes: (t) => ({ start: +t[1], ...this.editor.getAttributes(oe) }),
+      joinPredicate: (t, n) => n.childCount + n.attrs.start === +t[1],
+      editor: this.editor
+    })), [e];
+  }
+}), vt = /^\s*(\[([( |x])?\])\s$/, yt = b.create({
+  name: "taskItem",
+  addOptions() {
+    return {
+      nested: !1,
+      HTMLAttributes: {},
+      taskListTypeName: "taskList",
+      a11y: void 0
+    };
+  },
+  content() {
+    return this.options.nested ? "paragraph block*" : "paragraph+";
+  },
+  defining: !0,
+  addAttributes() {
+    return {
+      checked: {
+        default: !1,
+        keepOnSplit: !1,
+        parseHTML: (e) => {
+          const t = e.getAttribute("data-checked");
+          return t === "" || t === "true";
+        },
+        renderHTML: (e) => ({
+          "data-checked": e.checked
+        })
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: `li[data-type="${this.name}"]`,
+        priority: 51
+      }
+    ];
+  },
+  renderHTML({ node: e, HTMLAttributes: t }) {
+    return [
+      "li",
+      y(this.options.HTMLAttributes, t, {
+        "data-type": this.name
+      }),
+      [
+        "label",
+        [
+          "input",
+          {
+            type: "checkbox",
+            checked: e.attrs.checked ? "checked" : null
+          }
+        ],
+        ["span"]
+      ],
+      ["div", 0]
+    ];
+  },
+  parseMarkdown: (e, t) => {
+    const n = [];
+    if (e.tokens && e.tokens.length > 0 ? n.push(t.createNode("paragraph", {}, t.parseInline(e.tokens))) : e.text ? n.push(t.createNode("paragraph", {}, [t.createNode("text", { text: e.text })])) : n.push(t.createNode("paragraph", {}, [])), e.nestedTokens && e.nestedTokens.length > 0) {
+      const s = t.parseChildren(e.nestedTokens);
+      n.push(...s);
+    }
+    return t.createNode("taskItem", { checked: e.checked || !1 }, n);
+  },
+  renderMarkdown: (e, t) => {
+    var n;
+    const r = `- [${(n = e.attrs) != null && n.checked ? "x" : " "}] `;
+    return fe(e, t, r);
+  },
+  addKeyboardShortcuts() {
+    const e = {
+      Enter: () => this.editor.commands.splitListItem(this.name),
+      "Shift-Tab": () => this.editor.commands.liftListItem(this.name)
+    };
+    return this.options.nested ? {
+      ...e,
+      Tab: () => this.editor.commands.sinkListItem(this.name)
+    } : e;
+  },
+  addNodeView() {
+    return ({ node: e, HTMLAttributes: t, getPos: n, editor: s }) => {
+      const r = document.createElement("li"), i = document.createElement("label"), o = document.createElement("span"), a = document.createElement("input"), l = document.createElement("div"), u = (d) => {
+        var c, h;
+        a.ariaLabel = ((h = (c = this.options.a11y) == null ? void 0 : c.checkboxLabel) == null ? void 0 : h.call(c, d, a.checked)) || `Task item checkbox for ${d.textContent || "empty task item"}`;
+      };
+      u(e), i.contentEditable = "false", a.type = "checkbox", a.addEventListener("mousedown", (d) => d.preventDefault()), a.addEventListener("change", (d) => {
+        if (!s.isEditable && !this.options.onReadOnlyChecked) {
+          a.checked = !a.checked;
+          return;
+        }
+        const { checked: c } = d.target;
+        s.isEditable && typeof n == "function" && s.chain().focus(void 0, { scrollIntoView: !1 }).command(({ tr: h }) => {
+          const f = n();
+          if (typeof f != "number")
+            return !1;
+          const m = h.doc.nodeAt(f);
+          return h.setNodeMarkup(f, void 0, {
+            ...m?.attrs,
+            checked: c
+          }), !0;
+        }).run(), !s.isEditable && this.options.onReadOnlyChecked && (this.options.onReadOnlyChecked(e, c) || (a.checked = !a.checked));
+      }), Object.entries(this.options.HTMLAttributes).forEach(([d, c]) => {
+        r.setAttribute(d, c);
+      }), r.dataset.checked = e.attrs.checked, a.checked = e.attrs.checked, i.append(a, o), r.append(i, l), Object.entries(t).forEach(([d, c]) => {
+        r.setAttribute(d, c);
+      });
+      let p = new Set(Object.keys(t));
+      return {
+        dom: r,
+        contentDOM: l,
+        update: (d) => {
+          if (d.type !== this.type)
+            return !1;
+          r.dataset.checked = d.attrs.checked, a.checked = d.attrs.checked, u(d);
+          const c = s.extensionManager.attributes, h = $e(d, c), f = new Set(Object.keys(h)), m = this.options.HTMLAttributes;
+          return p.forEach((k) => {
+            f.has(k) || (k in m ? r.setAttribute(k, m[k]) : r.removeAttribute(k));
+          }), Object.entries(h).forEach(([k, R]) => {
+            R == null ? k in m ? r.setAttribute(k, m[k]) : r.removeAttribute(k) : r.setAttribute(k, R);
+          }), p = f, !0;
+        }
+      };
+    };
+  },
+  addInputRules() {
+    return [
+      E({
+        find: vt,
+        type: this.type,
+        getAttributes: (e) => ({
+          checked: e[e.length - 1] === "x"
+        })
+      })
+    ];
+  }
+}), bt = b.create({
+  name: "taskList",
+  addOptions() {
+    return {
+      itemTypeName: "taskItem",
+      HTMLAttributes: {}
+    };
+  },
+  group: "block list",
+  content() {
+    return `${this.options.itemTypeName}+`;
+  },
+  parseHTML() {
+    return [
+      {
+        tag: `ul[data-type="${this.name}"]`,
+        priority: 51
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["ul", y(this.options.HTMLAttributes, e, { "data-type": this.name }), 0];
+  },
+  parseMarkdown: (e, t) => t.createNode("taskList", {}, t.parseChildren(e.items || [])),
+  renderMarkdown: (e, t) => e.content ? t.renderChildren(e.content, `
+`) : "",
+  markdownTokenizer: {
+    name: "taskList",
+    level: "block",
+    start(e) {
+      var t;
+      const n = (t = e.match(/^\s*[-+*]\s+\[([ xX])\]\s+/)) == null ? void 0 : t.index;
+      return n !== void 0 ? n : -1;
+    },
+    tokenize(e, t, n) {
+      const s = (i) => {
+        const o = ee(
+          i,
+          {
+            itemPattern: /^(\s*)([-+*])\s+\[([ xX])\]\s+(.*)$/,
+            extractItemData: (a) => ({
+              indentLevel: a[1].length,
+              mainContent: a[4],
+              checked: a[3].toLowerCase() === "x"
+            }),
+            createToken: (a, l) => ({
+              type: "taskItem",
+              raw: "",
+              mainContent: a.mainContent,
+              indentLevel: a.indentLevel,
+              checked: a.checked,
+              text: a.mainContent,
+              tokens: n.inlineTokens(a.mainContent),
+              nestedTokens: l
+            }),
+            // Allow recursive nesting
+            customNestedParser: s
+          },
+          n
+        );
+        return o ? [
+          {
+            type: "taskList",
+            raw: o.raw,
+            items: o.items
+          }
+        ] : n.blockTokens(i);
+      }, r = ee(
+        e,
+        {
+          itemPattern: /^(\s*)([-+*])\s+\[([ xX])\]\s+(.*)$/,
+          extractItemData: (i) => ({
+            indentLevel: i[1].length,
+            mainContent: i[4],
+            checked: i[3].toLowerCase() === "x"
+          }),
+          createToken: (i, o) => ({
+            type: "taskItem",
+            raw: "",
+            mainContent: i.mainContent,
+            indentLevel: i.indentLevel,
+            checked: i.checked,
+            text: i.mainContent,
+            tokens: n.inlineTokens(i.mainContent),
+            nestedTokens: o
+          }),
+          // Use the recursive parser for nested content
+          customNestedParser: s
+        },
+        n
+      );
+      if (r)
+        return {
+          type: "taskList",
+          raw: r.raw,
+          items: r.items
+        };
+    }
+  },
+  markdownOptions: {
+    indentsContent: !0
+  },
+  addCommands() {
+    return {
+      toggleTaskList: () => ({ commands: e }) => e.toggleList(this.name, this.options.itemTypeName)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-9": () => this.editor.commands.toggleTaskList()
+    };
+  }
+});
+w.create({
+  name: "listKit",
+  addExtensions() {
+    const e = [];
+    return this.options.bulletList !== !1 && e.push(ke.configure(this.options.bulletList)), this.options.listItem !== !1 && e.push(ve.configure(this.options.listItem)), this.options.listKeymap !== !1 && e.push(Te.configure(this.options.listKeymap)), this.options.orderedList !== !1 && e.push(xe.configure(this.options.orderedList)), this.options.taskItem !== !1 && e.push(yt.configure(this.options.taskItem)), this.options.taskList !== !1 && e.push(bt.configure(this.options.taskList)), e;
+  }
+});
+var le = "&nbsp;", Mt = " ", wt = b.create({
+  name: "paragraph",
+  priority: 1e3,
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  group: "block",
+  content: "inline*",
+  parseHTML() {
+    return [{ tag: "p" }];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["p", y(this.options.HTMLAttributes, e), 0];
+  },
+  parseMarkdown: (e, t) => {
+    const n = e.tokens || [];
+    if (n.length === 1 && n[0].type === "image")
+      return t.parseChildren([n[0]]);
+    const s = t.parseInline(n);
+    return s.length === 1 && s[0].type === "text" && (s[0].text === le || s[0].text === Mt) ? t.createNode("paragraph", void 0, []) : t.createNode("paragraph", void 0, s);
+  },
+  renderMarkdown: (e, t) => {
+    if (!e)
+      return "";
+    const n = Array.isArray(e.content) ? e.content : [];
+    return n.length === 0 ? le : t.renderChildren(n);
+  },
+  addCommands() {
+    return {
+      setParagraph: () => ({ commands: e }) => e.setNode(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Alt-0": () => this.editor.commands.setParagraph()
+    };
+  }
+}), Lt = /(?:^|\s)(~~(?!\s+~~)((?:[^~]+))~~(?!\s+~~))$/, Tt = /(?:^|\s)(~~(?!\s+~~)((?:[^~]+))~~(?!\s+~~))/g, Ct = K.create({
+  name: "strike",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "s"
+      },
+      {
+        tag: "del"
+      },
+      {
+        tag: "strike"
+      },
+      {
+        style: "text-decoration",
+        consuming: !1,
+        getAttrs: (e) => e.includes("line-through") ? {} : !1
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["s", y(this.options.HTMLAttributes, e), 0];
+  },
+  markdownTokenName: "del",
+  parseMarkdown: (e, t) => t.applyMark("strike", t.parseInline(e.tokens || [])),
+  renderMarkdown: (e, t) => `~~${t.renderChildren(e)}~~`,
+  addCommands() {
+    return {
+      setStrike: () => ({ commands: e }) => e.setMark(this.name),
+      toggleStrike: () => ({ commands: e }) => e.toggleMark(this.name),
+      unsetStrike: () => ({ commands: e }) => e.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-s": () => this.editor.commands.toggleStrike()
+    };
+  },
+  addInputRules() {
+    return [
+      D({
+        find: Lt,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      B({
+        find: Tt,
+        type: this.type
+      })
+    ];
+  }
+}), xt = b.create({
+  name: "text",
+  group: "inline",
+  parseMarkdown: (e) => ({
+    type: "text",
+    text: e.text || ""
+  }),
+  renderMarkdown: (e) => e.text || ""
+}), It = K.create({
+  name: "underline",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "u"
+      },
+      {
+        style: "text-decoration",
+        consuming: !1,
+        getAttrs: (e) => e.includes("underline") ? {} : !1
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: e }) {
+    return ["u", y(this.options.HTMLAttributes, e), 0];
+  },
+  parseMarkdown(e, t) {
+    return t.applyMark(this.name || "underline", t.parseInline(e.tokens || []));
+  },
+  renderMarkdown(e, t) {
+    return `++${t.renderChildren(e)}++`;
+  },
+  markdownTokenizer: {
+    name: "underline",
+    level: "inline",
+    start(e) {
+      return e.indexOf("++");
+    },
+    tokenize(e, t, n) {
+      const r = /^(\+\+)([\s\S]+?)(\+\+)/.exec(e);
+      if (!r)
+        return;
+      const i = r[2].trim();
+      return {
+        type: "underline",
+        raw: r[0],
+        text: i,
+        tokens: n.inlineTokens(i)
+      };
+    }
+  },
+  addCommands() {
+    return {
+      setUnderline: () => ({ commands: e }) => e.setMark(this.name),
+      toggleUnderline: () => ({ commands: e }) => e.toggleMark(this.name),
+      unsetUnderline: () => ({ commands: e }) => e.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-u": () => this.editor.commands.toggleUnderline(),
+      "Mod-U": () => this.editor.commands.toggleUnderline()
+    };
+  }
+});
+function At(e = {}) {
+  return new C({
+    view(t) {
+      return new St(t, e);
+    }
+  });
+}
+class St {
+  constructor(t, n) {
+    var s;
+    this.editorView = t, this.cursorPos = null, this.element = null, this.timeout = -1, this.width = (s = n.width) !== null && s !== void 0 ? s : 1, this.color = n.color === !1 ? void 0 : n.color || "black", this.class = n.class, this.handlers = ["dragover", "dragend", "drop", "dragleave"].map((r) => {
+      let i = (o) => {
+        this[r](o);
+      };
+      return t.dom.addEventListener(r, i), { name: r, handler: i };
+    });
+  }
+  destroy() {
+    this.handlers.forEach(({ name: t, handler: n }) => this.editorView.dom.removeEventListener(t, n));
+  }
+  update(t, n) {
+    this.cursorPos != null && n.doc != t.state.doc && (this.cursorPos > t.state.doc.content.size ? this.setCursor(null) : this.updateOverlay());
+  }
+  setCursor(t) {
+    t != this.cursorPos && (this.cursorPos = t, t == null ? (this.element.parentNode.removeChild(this.element), this.element = null) : this.updateOverlay());
+  }
+  updateOverlay() {
+    let t = this.editorView.state.doc.resolve(this.cursorPos), n = !t.parent.inlineContent, s, r = this.editorView.dom, i = r.getBoundingClientRect(), o = i.width / r.offsetWidth, a = i.height / r.offsetHeight;
+    if (n) {
+      let d = t.nodeBefore, c = t.nodeAfter;
+      if (d || c) {
+        let h = this.editorView.nodeDOM(this.cursorPos - (d ? d.nodeSize : 0));
+        if (h) {
+          let f = h.getBoundingClientRect(), m = d ? f.bottom : f.top;
+          d && c && (m = (m + this.editorView.nodeDOM(this.cursorPos).getBoundingClientRect().top) / 2);
+          let k = this.width / 2 * a;
+          s = { left: f.left, right: f.right, top: m - k, bottom: m + k };
+        }
+      }
+    }
+    if (!s) {
+      let d = this.editorView.coordsAtPos(this.cursorPos), c = this.width / 2 * o;
+      s = { left: d.left - c, right: d.left + c, top: d.top, bottom: d.bottom };
+    }
+    let l = this.editorView.dom.offsetParent;
+    this.element || (this.element = l.appendChild(document.createElement("div")), this.class && (this.element.className = this.class), this.element.style.cssText = "position: absolute; z-index: 50; pointer-events: none;", this.color && (this.element.style.backgroundColor = this.color)), this.element.classList.toggle("prosemirror-dropcursor-block", n), this.element.classList.toggle("prosemirror-dropcursor-inline", !n);
+    let u, p;
+    if (!l || l == document.body && getComputedStyle(l).position == "static")
+      u = -pageXOffset, p = -pageYOffset;
+    else {
+      let d = l.getBoundingClientRect(), c = d.width / l.offsetWidth, h = d.height / l.offsetHeight;
+      u = d.left - l.scrollLeft * c, p = d.top - l.scrollTop * h;
+    }
+    this.element.style.left = (s.left - u) / o + "px", this.element.style.top = (s.top - p) / a + "px", this.element.style.width = (s.right - s.left) / o + "px", this.element.style.height = (s.bottom - s.top) / a + "px";
+  }
+  scheduleRemoval(t) {
+    clearTimeout(this.timeout), this.timeout = setTimeout(() => this.setCursor(null), t);
+  }
+  dragover(t) {
+    if (!this.editorView.editable)
+      return;
+    let n = this.editorView.posAtCoords({ left: t.clientX, top: t.clientY }), s = n && n.inside >= 0 && this.editorView.state.doc.nodeAt(n.inside), r = s && s.type.spec.disableDropCursor, i = typeof r == "function" ? r(this.editorView, n, t) : r;
+    if (n && !i) {
+      let o = n.pos;
+      if (this.editorView.dragging && this.editorView.dragging.slice) {
+        let a = Be(this.editorView.state.doc, o, this.editorView.dragging.slice);
+        a != null && (o = a);
+      }
+      this.setCursor(o), this.scheduleRemoval(5e3);
+    }
+  }
+  dragend() {
+    this.scheduleRemoval(20);
+  }
+  drop() {
+    this.scheduleRemoval(20);
+  }
+  dragleave(t) {
+    this.editorView.dom.contains(t.relatedTarget) || this.setCursor(null);
+  }
+}
+class g extends H {
+  /**
+  Create a gap cursor.
+  */
+  constructor(t) {
+    super(t, t);
+  }
+  map(t, n) {
+    let s = t.resolve(n.map(this.head));
+    return g.valid(s) ? new g(s) : H.near(s);
+  }
+  content() {
+    return ge.empty;
+  }
+  eq(t) {
+    return t instanceof g && t.head == this.head;
+  }
+  toJSON() {
+    return { type: "gapcursor", pos: this.head };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(t, n) {
+    if (typeof n.pos != "number")
+      throw new RangeError("Invalid input for GapCursor.fromJSON");
+    return new g(t.resolve(n.pos));
+  }
+  /**
+  @internal
+  */
+  getBookmark() {
+    return new Q(this.anchor);
+  }
+  /**
+  @internal
+  */
+  static valid(t) {
+    let n = t.parent;
+    if (n.isTextblock || !Et(t) || !Pt(t))
+      return !1;
+    let s = n.type.spec.allowGapCursor;
+    if (s != null)
+      return s;
+    let r = n.contentMatchAt(t.index()).defaultType;
+    return r && r.isTextblock;
+  }
+  /**
+  @internal
+  */
+  static findGapCursorFrom(t, n, s = !1) {
+    e: for (; ; ) {
+      if (!s && g.valid(t))
+        return t;
+      let r = t.pos, i = null;
+      for (let o = t.depth; ; o--) {
+        let a = t.node(o);
+        if (n > 0 ? t.indexAfter(o) < a.childCount : t.index(o) > 0) {
+          i = a.child(n > 0 ? t.indexAfter(o) : t.index(o) - 1);
+          break;
+        } else if (o == 0)
+          return null;
+        r += n;
+        let l = t.doc.resolve(r);
+        if (g.valid(l))
+          return l;
+      }
+      for (; ; ) {
+        let o = n > 0 ? i.firstChild : i.lastChild;
+        if (!o) {
+          if (i.isAtom && !i.isText && !J.isSelectable(i)) {
+            t = t.doc.resolve(r + i.nodeSize * n), s = !1;
+            continue e;
+          }
+          break;
+        }
+        i = o, r += n;
+        let a = t.doc.resolve(r);
+        if (g.valid(a))
+          return a;
+      }
+      return null;
+    }
+  }
+}
+g.prototype.visible = !1;
+g.findFrom = g.findGapCursorFrom;
+H.jsonID("gapcursor", g);
+class Q {
+  constructor(t) {
+    this.pos = t;
+  }
+  map(t) {
+    return new Q(t.map(this.pos));
+  }
+  resolve(t) {
+    let n = t.resolve(this.pos);
+    return g.valid(n) ? new g(n) : H.near(n);
+  }
+}
+function Et(e) {
+  for (let t = e.depth; t >= 0; t--) {
+    let n = e.index(t), s = e.node(t);
+    if (n == 0) {
+      if (s.type.spec.isolating)
+        return !0;
+      continue;
+    }
+    for (let r = s.child(n - 1); ; r = r.lastChild) {
+      if (r.childCount == 0 && !r.inlineContent || r.isAtom || r.type.spec.isolating)
+        return !0;
+      if (r.inlineContent)
+        return !1;
+    }
+  }
+  return !0;
+}
+function Pt(e) {
+  for (let t = e.depth; t >= 0; t--) {
+    let n = e.indexAfter(t), s = e.node(t);
+    if (n == s.childCount) {
+      if (s.type.spec.isolating)
+        return !0;
+      continue;
+    }
+    for (let r = s.child(n); ; r = r.firstChild) {
+      if (r.childCount == 0 && !r.inlineContent || r.isAtom || r.type.spec.isolating)
+        return !0;
+      if (r.inlineContent)
+        return !1;
+    }
+  }
+  return !0;
+}
+function Ht() {
+  return new C({
+    props: {
+      decorations: _t,
+      createSelectionBetween(e, t, n) {
+        return t.pos == n.pos && g.valid(n) ? new g(n) : null;
+      },
+      handleClick: Ot,
+      handleKeyDown: Nt,
+      handleDOMEvents: { beforeinput: Rt }
+    }
+  });
+}
+const Nt = De({
+  ArrowLeft: _("horiz", -1),
+  ArrowRight: _("horiz", 1),
+  ArrowUp: _("vert", -1),
+  ArrowDown: _("vert", 1)
+});
+function _(e, t) {
+  const n = e == "vert" ? t > 0 ? "down" : "up" : t > 0 ? "right" : "left";
+  return function(s, r, i) {
+    let o = s.selection, a = t > 0 ? o.$to : o.$from, l = o.empty;
+    if (o instanceof A) {
+      if (!i.endOfTextblock(n) || a.depth == 0)
+        return !1;
+      l = !1, a = s.doc.resolve(t > 0 ? a.after() : a.before());
+    }
+    let u = g.findGapCursorFrom(a, t, l);
+    return u ? (r && r(s.tr.setSelection(new g(u))), !0) : !1;
+  };
+}
+function Ot(e, t, n) {
+  if (!e || !e.editable)
+    return !1;
+  let s = e.state.doc.resolve(t);
+  if (!g.valid(s))
+    return !1;
+  let r = e.posAtCoords({ left: n.clientX, top: n.clientY });
+  return r && r.inside > -1 && J.isSelectable(e.state.doc.nodeAt(r.inside)) ? !1 : (e.dispatch(e.state.tr.setSelection(new g(s))), !0);
+}
+function Rt(e, t) {
+  if (t.inputType != "insertCompositionText" || !(e.state.selection instanceof g))
+    return !1;
+  let { $from: n } = e.state.selection, s = n.parent.contentMatchAt(n.index()).findWrapping(e.state.schema.nodes.text);
+  if (!s)
+    return !1;
+  let r = te.empty;
+  for (let o = s.length - 1; o >= 0; o--)
+    r = te.from(s[o].createAndFill(null, r));
+  let i = e.state.tr.replace(n.pos, n.pos, new ge(r, 0, 0));
+  return i.setSelection(A.near(i.doc.resolve(n.pos + 1))), e.dispatch(i), !1;
+}
+function _t(e) {
+  if (!(e.selection instanceof g))
+    return null;
+  let t = document.createElement("div");
+  return t.className = "ProseMirror-gapcursor", N.create(e.doc, [j.widget(e.selection.head, t, { key: "gapcursor" })]);
+}
+var z = 200, v = function() {
+};
+v.prototype.append = function(t) {
+  return t.length ? (t = v.from(t), !this.length && t || t.length < z && this.leafAppend(t) || this.length < z && t.leafPrepend(this) || this.appendInner(t)) : this;
+};
+v.prototype.prepend = function(t) {
+  return t.length ? v.from(t).append(this) : this;
+};
+v.prototype.appendInner = function(t) {
+  return new $t(this, t);
+};
+v.prototype.slice = function(t, n) {
+  return t === void 0 && (t = 0), n === void 0 && (n = this.length), t >= n ? v.empty : this.sliceInner(Math.max(0, t), Math.min(this.length, n));
+};
+v.prototype.get = function(t) {
+  if (!(t < 0 || t >= this.length))
+    return this.getInner(t);
+};
+v.prototype.forEach = function(t, n, s) {
+  n === void 0 && (n = 0), s === void 0 && (s = this.length), n <= s ? this.forEachInner(t, n, s, 0) : this.forEachInvertedInner(t, n, s, 0);
+};
+v.prototype.map = function(t, n, s) {
+  n === void 0 && (n = 0), s === void 0 && (s = this.length);
+  var r = [];
+  return this.forEach(function(i, o) {
+    return r.push(t(i, o));
+  }, n, s), r;
+};
+v.from = function(t) {
+  return t instanceof v ? t : t && t.length ? new Ie(t) : v.empty;
+};
+var Ie = /* @__PURE__ */ (function(e) {
+  function t(s) {
+    e.call(this), this.values = s;
+  }
+  e && (t.__proto__ = e), t.prototype = Object.create(e && e.prototype), t.prototype.constructor = t;
+  var n = { length: { configurable: !0 }, depth: { configurable: !0 } };
+  return t.prototype.flatten = function() {
+    return this.values;
+  }, t.prototype.sliceInner = function(r, i) {
+    return r == 0 && i == this.length ? this : new t(this.values.slice(r, i));
+  }, t.prototype.getInner = function(r) {
+    return this.values[r];
+  }, t.prototype.forEachInner = function(r, i, o, a) {
+    for (var l = i; l < o; l++)
+      if (r(this.values[l], a + l) === !1)
+        return !1;
+  }, t.prototype.forEachInvertedInner = function(r, i, o, a) {
+    for (var l = i - 1; l >= o; l--)
+      if (r(this.values[l], a + l) === !1)
+        return !1;
+  }, t.prototype.leafAppend = function(r) {
+    if (this.length + r.length <= z)
+      return new t(this.values.concat(r.flatten()));
+  }, t.prototype.leafPrepend = function(r) {
+    if (this.length + r.length <= z)
+      return new t(r.flatten().concat(this.values));
+  }, n.length.get = function() {
+    return this.values.length;
+  }, n.depth.get = function() {
+    return 0;
+  }, Object.defineProperties(t.prototype, n), t;
+})(v);
+v.empty = new Ie([]);
+var $t = /* @__PURE__ */ (function(e) {
+  function t(n, s) {
+    e.call(this), this.left = n, this.right = s, this.length = n.length + s.length, this.depth = Math.max(n.depth, s.depth) + 1;
+  }
+  return e && (t.__proto__ = e), t.prototype = Object.create(e && e.prototype), t.prototype.constructor = t, t.prototype.flatten = function() {
+    return this.left.flatten().concat(this.right.flatten());
+  }, t.prototype.getInner = function(s) {
+    return s < this.left.length ? this.left.get(s) : this.right.get(s - this.left.length);
+  }, t.prototype.forEachInner = function(s, r, i, o) {
+    var a = this.left.length;
+    if (r < a && this.left.forEachInner(s, r, Math.min(i, a), o) === !1 || i > a && this.right.forEachInner(s, Math.max(r - a, 0), Math.min(this.length, i) - a, o + a) === !1)
+      return !1;
+  }, t.prototype.forEachInvertedInner = function(s, r, i, o) {
+    var a = this.left.length;
+    if (r > a && this.right.forEachInvertedInner(s, r - a, Math.max(i, a) - a, o + a) === !1 || i < a && this.left.forEachInvertedInner(s, Math.min(r, a), i, o) === !1)
+      return !1;
+  }, t.prototype.sliceInner = function(s, r) {
+    if (s == 0 && r == this.length)
+      return this;
+    var i = this.left.length;
+    return r <= i ? this.left.slice(s, r) : s >= i ? this.right.slice(s - i, r - i) : this.left.slice(s, i).append(this.right.slice(0, r - i));
+  }, t.prototype.leafAppend = function(s) {
+    var r = this.right.leafAppend(s);
+    if (r)
+      return new t(this.left, r);
+  }, t.prototype.leafPrepend = function(s) {
+    var r = this.left.leafPrepend(s);
+    if (r)
+      return new t(r, this.right);
+  }, t.prototype.appendInner = function(s) {
+    return this.left.depth >= Math.max(this.right.depth, s.depth) + 1 ? new t(this.left, new t(this.right, s)) : new t(this, s);
+  }, t;
+})(v);
+const Bt = 500;
+class M {
+  constructor(t, n) {
+    this.items = t, this.eventCount = n;
+  }
+  // Pop the latest event off the branch's history and apply it
+  // to a document transform.
+  popEvent(t, n) {
+    if (this.eventCount == 0)
+      return null;
+    let s = this.items.length;
+    for (; ; s--)
+      if (this.items.get(s - 1).selection) {
+        --s;
+        break;
+      }
+    let r, i;
+    n && (r = this.remapping(s, this.items.length), i = r.maps.length);
+    let o = t.tr, a, l, u = [], p = [];
+    return this.items.forEach((d, c) => {
+      if (!d.step) {
+        r || (r = this.remapping(s, c + 1), i = r.maps.length), i--, p.push(d);
+        return;
+      }
+      if (r) {
+        p.push(new L(d.map));
+        let h = d.step.map(r.slice(i)), f;
+        h && o.maybeStep(h).doc && (f = o.mapping.maps[o.mapping.maps.length - 1], u.push(new L(f, void 0, void 0, u.length + p.length))), i--, f && r.appendMap(f, i);
+      } else
+        o.maybeStep(d.step);
+      if (d.selection)
+        return a = r ? d.selection.map(r.slice(i)) : d.selection, l = new M(this.items.slice(0, s).append(p.reverse().concat(u)), this.eventCount - 1), !1;
+    }, this.items.length, 0), { remaining: l, transform: o, selection: a };
+  }
+  // Create a new branch with the given transform added.
+  addTransform(t, n, s, r) {
+    let i = [], o = this.eventCount, a = this.items, l = !r && a.length ? a.get(a.length - 1) : null;
+    for (let p = 0; p < t.steps.length; p++) {
+      let d = t.steps[p].invert(t.docs[p]), c = new L(t.mapping.maps[p], d, n), h;
+      (h = l && l.merge(c)) && (c = h, p ? i.pop() : a = a.slice(0, a.length - 1)), i.push(c), n && (o++, n = void 0), r || (l = c);
+    }
+    let u = o - s.depth;
+    return u > zt && (a = Dt(a, u), o -= u), new M(a.append(i), o);
+  }
+  remapping(t, n) {
+    let s = new ze();
+    return this.items.forEach((r, i) => {
+      let o = r.mirrorOffset != null && i - r.mirrorOffset >= t ? s.maps.length - r.mirrorOffset : void 0;
+      s.appendMap(r.map, o);
+    }, t, n), s;
+  }
+  addMaps(t) {
+    return this.eventCount == 0 ? this : new M(this.items.append(t.map((n) => new L(n))), this.eventCount);
+  }
+  // When the collab module receives remote changes, the history has
+  // to know about those, so that it can adjust the steps that were
+  // rebased on top of the remote changes, and include the position
+  // maps for the remote changes in its array of items.
+  rebased(t, n) {
+    if (!this.eventCount)
+      return this;
+    let s = [], r = Math.max(0, this.items.length - n), i = t.mapping, o = t.steps.length, a = this.eventCount;
+    this.items.forEach((c) => {
+      c.selection && a--;
+    }, r);
+    let l = n;
+    this.items.forEach((c) => {
+      let h = i.getMirror(--l);
+      if (h == null)
+        return;
+      o = Math.min(o, h);
+      let f = i.maps[h];
+      if (c.step) {
+        let m = t.steps[h].invert(t.docs[h]), k = c.selection && c.selection.map(i.slice(l + 1, h));
+        k && a++, s.push(new L(f, m, k));
+      } else
+        s.push(new L(f));
+    }, r);
+    let u = [];
+    for (let c = n; c < o; c++)
+      u.push(new L(i.maps[c]));
+    let p = this.items.slice(0, r).append(u).append(s), d = new M(p, a);
+    return d.emptyItemCount() > Bt && (d = d.compress(this.items.length - s.length)), d;
+  }
+  emptyItemCount() {
+    let t = 0;
+    return this.items.forEach((n) => {
+      n.step || t++;
+    }), t;
+  }
+  // Compressing a branch means rewriting it to push the air (map-only
+  // items) out. During collaboration, these naturally accumulate
+  // because each remote change adds one. The `upto` argument is used
+  // to ensure that only the items below a given level are compressed,
+  // because `rebased` relies on a clean, untouched set of items in
+  // order to associate old items with rebased steps.
+  compress(t = this.items.length) {
+    let n = this.remapping(0, t), s = n.maps.length, r = [], i = 0;
+    return this.items.forEach((o, a) => {
+      if (a >= t)
+        r.push(o), o.selection && i++;
+      else if (o.step) {
+        let l = o.step.map(n.slice(s)), u = l && l.getMap();
+        if (s--, u && n.appendMap(u, s), l) {
+          let p = o.selection && o.selection.map(n.slice(s));
+          p && i++;
+          let d = new L(u.invert(), l, p), c, h = r.length - 1;
+          (c = r.length && r[h].merge(d)) ? r[h] = c : r.push(d);
+        }
+      } else o.map && s--;
+    }, this.items.length, 0), new M(v.from(r.reverse()), i);
+  }
+}
+M.empty = new M(v.empty, 0);
+function Dt(e, t) {
+  let n;
+  return e.forEach((s, r) => {
+    if (s.selection && t-- == 0)
+      return n = r, !1;
+  }), e.slice(n);
+}
+class L {
+  constructor(t, n, s, r) {
+    this.map = t, this.step = n, this.selection = s, this.mirrorOffset = r;
+  }
+  merge(t) {
+    if (this.step && t.step && !t.selection) {
+      let n = t.step.merge(this.step);
+      if (n)
+        return new L(n.getMap().invert(), n, this.selection);
+    }
+  }
+}
+class x {
+  constructor(t, n, s, r, i) {
+    this.done = t, this.undone = n, this.prevRanges = s, this.prevTime = r, this.prevComposition = i;
+  }
+}
+const zt = 20;
+function Kt(e, t, n, s) {
+  let r = n.getMeta(S), i;
+  if (r)
+    return r.historyState;
+  n.getMeta(Wt) && (e = new x(e.done, e.undone, null, 0, -1));
+  let o = n.getMeta("appendedTransaction");
+  if (n.steps.length == 0)
+    return e;
+  if (o && o.getMeta(S))
+    return o.getMeta(S).redo ? new x(e.done.addTransform(n, void 0, s, $(t)), e.undone, de(n.mapping.maps), e.prevTime, e.prevComposition) : new x(e.done, e.undone.addTransform(n, void 0, s, $(t)), null, e.prevTime, e.prevComposition);
+  if (n.getMeta("addToHistory") !== !1 && !(o && o.getMeta("addToHistory") === !1)) {
+    let a = n.getMeta("composition"), l = e.prevTime == 0 || !o && e.prevComposition != a && (e.prevTime < (n.time || 0) - s.newGroupDelay || !jt(n, e.prevRanges)), u = o ? F(e.prevRanges, n.mapping) : de(n.mapping.maps);
+    return new x(e.done.addTransform(n, l ? t.selection.getBookmark() : void 0, s, $(t)), M.empty, u, n.time, a ?? e.prevComposition);
+  } else return (i = n.getMeta("rebased")) ? new x(e.done.rebased(n, i), e.undone.rebased(n, i), F(e.prevRanges, n.mapping), e.prevTime, e.prevComposition) : new x(e.done.addMaps(n.mapping.maps), e.undone.addMaps(n.mapping.maps), F(e.prevRanges, n.mapping), e.prevTime, e.prevComposition);
+}
+function jt(e, t) {
+  if (!t)
+    return !1;
+  if (!e.docChanged)
+    return !0;
+  let n = !1;
+  return e.mapping.maps[0].forEach((s, r) => {
+    for (let i = 0; i < t.length; i += 2)
+      s <= t[i + 1] && r >= t[i] && (n = !0);
+  }), n;
+}
+function de(e) {
+  let t = [];
+  for (let n = e.length - 1; n >= 0 && t.length == 0; n--)
+    e[n].forEach((s, r, i, o) => t.push(i, o));
+  return t;
+}
+function F(e, t) {
+  if (!e)
+    return null;
+  let n = [];
+  for (let s = 0; s < e.length; s += 2) {
+    let r = t.map(e[s], 1), i = t.map(e[s + 1], -1);
+    r <= i && n.push(r, i);
+  }
+  return n;
+}
+function Vt(e, t, n) {
+  let s = $(t), r = S.get(t).spec.config, i = (n ? e.undone : e.done).popEvent(t, s);
+  if (!i)
+    return null;
+  let o = i.selection.resolve(i.transform.doc), a = (n ? e.done : e.undone).addTransform(i.transform, t.selection.getBookmark(), r, s), l = new x(n ? a : i.remaining, n ? i.remaining : a, null, 0, -1);
+  return i.transform.setSelection(o).setMeta(S, { redo: n, historyState: l });
+}
+let U = !1, ue = null;
+function $(e) {
+  let t = e.plugins;
+  if (ue != t) {
+    U = !1, ue = t;
+    for (let n = 0; n < t.length; n++)
+      if (t[n].spec.historyPreserveItems) {
+        U = !0;
+        break;
+      }
+  }
+  return U;
+}
+const S = new I("history"), Wt = new I("closeHistory");
+function Ft(e = {}) {
+  return e = {
+    depth: e.depth || 100,
+    newGroupDelay: e.newGroupDelay || 500
+  }, new C({
+    key: S,
+    state: {
+      init() {
+        return new x(M.empty, M.empty, null, 0, -1);
+      },
+      apply(t, n, s) {
+        return Kt(n, s, t, e);
+      }
+    },
+    config: e,
+    props: {
+      handleDOMEvents: {
+        beforeinput(t, n) {
+          let s = n.inputType, r = s == "historyUndo" ? Se : s == "historyRedo" ? Ee : null;
+          return r ? (n.preventDefault(), r(t.state, t.dispatch)) : !1;
+        }
+      }
+    }
+  });
+}
+function Ae(e, t) {
+  return (n, s) => {
+    let r = S.getState(n);
+    if (!r || (e ? r.undone : r.done).eventCount == 0)
+      return !1;
+    if (s) {
+      let i = Vt(r, n, e);
+      i && s(t ? i.scrollIntoView() : i);
+    }
+    return !0;
+  };
+}
+const Se = Ae(!1, !0), Ee = Ae(!0, !0);
+w.create({
+  name: "characterCount",
+  addOptions() {
+    return {
+      limit: null,
+      mode: "textSize",
+      textCounter: (e) => e.length,
+      wordCounter: (e) => e.split(" ").filter((t) => t !== "").length
+    };
+  },
+  addStorage() {
+    return {
+      characters: () => 0,
+      words: () => 0
+    };
+  },
+  onBeforeCreate() {
+    this.storage.characters = (e) => {
+      const t = e?.node || this.editor.state.doc;
+      if ((e?.mode || this.options.mode) === "textSize") {
+        const s = t.textBetween(0, t.content.size, void 0, " ");
+        return this.options.textCounter(s);
+      }
+      return t.nodeSize;
+    }, this.storage.words = (e) => {
+      const t = e?.node || this.editor.state.doc, n = t.textBetween(0, t.content.size, " ", " ");
+      return this.options.wordCounter(n);
+    };
+  },
+  addProseMirrorPlugins() {
+    let e = !1;
+    return [
+      new C({
+        key: new I("characterCount"),
+        appendTransaction: (t, n, s) => {
+          if (e)
+            return;
+          const r = this.options.limit;
+          if (r == null || r === 0) {
+            e = !0;
+            return;
+          }
+          const i = this.storage.characters({ node: s.doc });
+          if (i > r) {
+            const o = i - r, a = 0, l = o;
+            console.warn(
+              `[CharacterCount] Initial content exceeded limit of ${r} characters. Content was automatically trimmed.`
+            );
+            const u = s.tr.deleteRange(a, l);
+            return e = !0, u;
+          }
+          e = !0;
+        },
+        filterTransaction: (t, n) => {
+          const s = this.options.limit;
+          if (!t.docChanged || s === 0 || s === null || s === void 0)
+            return !0;
+          const r = this.storage.characters({ node: n.doc }), i = this.storage.characters({ node: t.doc });
+          if (i <= s || r > s && i > s && i <= r)
+            return !0;
+          if (r > s && i > s && i > r || !t.getMeta("paste"))
+            return !1;
+          const a = t.selection.$head.pos, l = i - s, u = a - l, p = a;
+          return t.deleteRange(u, p), !(this.storage.characters({ node: t.doc }) > s);
+        }
+      })
+    ];
+  }
+});
+var Ut = w.create({
+  name: "dropCursor",
+  addOptions() {
+    return {
+      color: "currentColor",
+      width: 1,
+      class: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    return [At(this.options)];
+  }
+});
+w.create({
+  name: "focus",
+  addOptions() {
+    return {
+      className: "has-focus",
+      mode: "all"
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new C({
+        key: new I("focus"),
+        props: {
+          decorations: ({ doc: e, selection: t }) => {
+            const { isEditable: n, isFocused: s } = this.editor, { anchor: r } = t, i = [];
+            if (!n || !s)
+              return N.create(e, []);
+            let o = 0;
+            this.options.mode === "deepest" && e.descendants((l, u) => {
+              if (l.isText)
+                return;
+              if (!(r >= u && r <= u + l.nodeSize - 1))
+                return !1;
+              o += 1;
+            });
+            let a = 0;
+            return e.descendants((l, u) => {
+              if (l.isText || !(r >= u && r <= u + l.nodeSize - 1))
+                return !1;
+              if (a += 1, this.options.mode === "deepest" && o - a > 0 || this.options.mode === "shallowest" && a > 1)
+                return this.options.mode === "deepest";
+              i.push(
+                j.node(u, u + l.nodeSize, {
+                  class: this.options.className
+                })
+              );
+            }), N.create(e, i);
+          }
+        }
+      })
+    ];
+  }
+});
+var Gt = w.create({
+  name: "gapCursor",
+  addProseMirrorPlugins() {
+    return [Ht()];
+  },
+  extendNodeSchema(e) {
+    var t;
+    const n = {
+      name: e.name,
+      options: e.options,
+      storage: e.storage
+    };
+    return {
+      allowGapCursor: (t = Ke(je(e, "allowGapCursor", n))) != null ? t : null
+    };
+  }
+}), ce = "placeholder";
+function Xt(e) {
+  return e.replace(/\s+/g, "-").replace(/[^a-zA-Z0-9-]/g, "").replace(/^[0-9-]+/, "").replace(/^-+/, "").toLowerCase();
+}
+w.create({
+  name: "placeholder",
+  addOptions() {
+    return {
+      emptyEditorClass: "is-editor-empty",
+      emptyNodeClass: "is-empty",
+      dataAttribute: ce,
+      placeholder: "Write something …",
+      showOnlyWhenEditable: !0,
+      showOnlyCurrent: !0,
+      includeChildren: !1
+    };
+  },
+  addProseMirrorPlugins() {
+    const e = this.options.dataAttribute ? `data-${Xt(this.options.dataAttribute)}` : `data-${ce}`;
+    return [
+      new C({
+        key: new I("placeholder"),
+        props: {
+          decorations: ({ doc: t, selection: n }) => {
+            const s = this.editor.isEditable || !this.options.showOnlyWhenEditable, { anchor: r } = n, i = [];
+            if (!s)
+              return null;
+            const o = this.editor.isEmpty;
+            return t.descendants((a, l) => {
+              const u = r >= l && r <= l + a.nodeSize, p = !a.isLeaf && Ve(a);
+              if ((u || !this.options.showOnlyCurrent) && p) {
+                const d = [this.options.emptyNodeClass];
+                o && d.push(this.options.emptyEditorClass);
+                const c = j.node(l, l + a.nodeSize, {
+                  class: d.join(" "),
+                  [e]: typeof this.options.placeholder == "function" ? this.options.placeholder({
+                    editor: this.editor,
+                    node: a,
+                    pos: l,
+                    hasAnchor: u
+                  }) : this.options.placeholder
+                });
+                i.push(c);
+              }
+              return this.options.includeChildren;
+            }), N.create(t, i);
+          }
+        }
+      })
+    ];
+  }
+});
+w.create({
+  name: "selection",
+  addOptions() {
+    return {
+      className: "selection"
+    };
+  },
+  addProseMirrorPlugins() {
+    const { editor: e, options: t } = this;
+    return [
+      new C({
+        key: new I("selection"),
+        props: {
+          decorations(n) {
+            return n.selection.empty || e.isFocused || !e.isEditable || he(n.selection) || e.view.dragging ? null : N.create(n.doc, [
+              j.inline(n.selection.from, n.selection.to, {
+                class: t.className
+              })
+            ]);
+          }
+        }
+      })
+    ];
+  }
+});
+function pe({ types: e, node: t }) {
+  return t && Array.isArray(e) && e.includes(t.type) || t?.type === e;
+}
+var qt = w.create({
+  name: "trailingNode",
+  addOptions() {
+    return {
+      node: void 0,
+      notAfter: []
+    };
+  },
+  addProseMirrorPlugins() {
+    var e;
+    const t = new I(this.name), n = this.options.node || ((e = this.editor.schema.topNodeType.contentMatch.defaultType) == null ? void 0 : e.name) || "paragraph", s = Object.entries(this.editor.schema.nodes).map(([, r]) => r).filter((r) => (this.options.notAfter || []).concat(n).includes(r.name));
+    return [
+      new C({
+        key: t,
+        appendTransaction: (r, i, o) => {
+          const { doc: a, tr: l, schema: u } = o, p = t.getState(o), d = a.content.size, c = u.nodes[n];
+          if (p)
+            return l.insert(d, c.create());
+        },
+        state: {
+          init: (r, i) => {
+            const o = i.tr.doc.lastChild;
+            return !pe({ node: o, types: s });
+          },
+          apply: (r, i) => {
+            if (!r.docChanged || r.getMeta("__uniqueIDTransaction"))
+              return i;
+            const o = r.doc.lastChild;
+            return !pe({ node: o, types: s });
+          }
+        }
+      })
+    ];
+  }
+}), Yt = w.create({
+  name: "undoRedo",
+  addOptions() {
+    return {
+      depth: 100,
+      newGroupDelay: 500
+    };
+  },
+  addCommands() {
+    return {
+      undo: () => ({ state: e, dispatch: t }) => Se(e, t),
+      redo: () => ({ state: e, dispatch: t }) => Ee(e, t)
+    };
+  },
+  addProseMirrorPlugins() {
+    return [Ft(this.options)];
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-z": () => this.editor.commands.undo(),
+      "Shift-Mod-z": () => this.editor.commands.redo(),
+      "Mod-y": () => this.editor.commands.redo(),
+      // Russian keyboard layouts
+      "Mod-я": () => this.editor.commands.undo(),
+      "Shift-Mod-я": () => this.editor.commands.redo()
+    };
+  }
+}), Jt = w.create({
+  name: "starterKit",
+  addExtensions() {
+    var e, t, n, s;
+    const r = [];
+    return this.options.bold !== !1 && r.push(We.configure(this.options.bold)), this.options.blockquote !== !1 && r.push(Ge.configure(this.options.blockquote)), this.options.bulletList !== !1 && r.push(ke.configure(this.options.bulletList)), this.options.code !== !1 && r.push(Ye.configure(this.options.code)), this.options.codeBlock !== !1 && r.push(Qe.configure(this.options.codeBlock)), this.options.document !== !1 && r.push(et.configure(this.options.document)), this.options.dropcursor !== !1 && r.push(Ut.configure(this.options.dropcursor)), this.options.gapcursor !== !1 && r.push(Gt.configure(this.options.gapcursor)), this.options.hardBreak !== !1 && r.push(tt.configure(this.options.hardBreak)), this.options.heading !== !1 && r.push(nt.configure(this.options.heading)), this.options.undoRedo !== !1 && r.push(Yt.configure(this.options.undoRedo)), this.options.horizontalRule !== !1 && r.push(rt.configure(this.options.horizontalRule)), this.options.italic !== !1 && r.push(lt.configure(this.options.italic)), this.options.listItem !== !1 && r.push(ve.configure(this.options.listItem)), this.options.listKeymap !== !1 && r.push(Te.configure((e = this.options) == null ? void 0 : e.listKeymap)), this.options.link !== !1 && r.push(Fe.configure((t = this.options) == null ? void 0 : t.link)), this.options.orderedList !== !1 && r.push(xe.configure(this.options.orderedList)), this.options.paragraph !== !1 && r.push(wt.configure(this.options.paragraph)), this.options.strike !== !1 && r.push(Ct.configure(this.options.strike)), this.options.text !== !1 && r.push(xt.configure(this.options.text)), this.options.underline !== !1 && r.push(It.configure((n = this.options) == null ? void 0 : n.underline)), this.options.trailingNode !== !1 && r.push(qt.configure((s = this.options) == null ? void 0 : s.trailingNode)), r;
+  }
+}), nn = Jt;
+export {
+  Jt as StarterKit,
+  nn as default
+};