@clevertask/scribe 0.0.0

package/dist/components/Scribe/extension/index.js

@@ -0,0 +1,1647 @@
+import { E as x, a as H, P, j as ie, b as F, D as B, N as v, m as y, w as E, M as R, k as A, c as C, S as O, t as V, T as I, l as oe, n as ae, o as W, F as G, p as Q, q as le, r as ue, s as de, u as pe, v as ee } from "../../../index-CzwFCNeI.js";
+import { SlashCommand as ce } from "./slashCommand/index.js";
+import { getSuggestionItems as he } from "./slashCommand/items.js";
+import fe from "./slashCommand/renderItems.js";
+import me from "./extension-selectedText.js";
+import ge from "./extension-link.js";
+const ye = x.create({
+  name: "placeholder",
+  addOptions() {
+    return {
+      emptyEditorClass: "is-editor-empty",
+      emptyNodeClass: "is-empty",
+      placeholder: "Write something …",
+      showOnlyWhenEditable: !0,
+      showOnlyCurrent: !0,
+      includeChildren: !1
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new H({
+        key: new P("placeholder"),
+        props: {
+          decorations: ({ doc: t, selection: e }) => {
+            const n = this.editor.isEditable || !this.options.showOnlyWhenEditable, { anchor: r } = e, s = [];
+            if (!n)
+              return null;
+            const i = this.editor.isEmpty;
+            return t.descendants((o, a) => {
+              const l = r >= a && r <= a + o.nodeSize, u = !o.isLeaf && ie(o);
+              if ((l || !this.options.showOnlyCurrent) && u) {
+                const p = [this.options.emptyNodeClass];
+                i && p.push(this.options.emptyEditorClass);
+                const d = F.node(a, a + o.nodeSize, {
+                  class: p.join(" "),
+                  "data-placeholder": typeof this.options.placeholder == "function" ? this.options.placeholder({
+                    editor: this.editor,
+                    node: o,
+                    pos: a,
+                    hasAnchor: l
+                  }) : this.options.placeholder
+                });
+                s.push(d);
+              }
+              return this.options.includeChildren;
+            }), B.create(t, s);
+          }
+        }
+      })
+    ];
+  }
+}), ve = /^\s*>\s$/, be = v.create({
+  name: "blockquote",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  content: "block+",
+  group: "block",
+  defining: !0,
+  parseHTML() {
+    return [
+      { tag: "blockquote" }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["blockquote", y(this.options.HTMLAttributes, t), 0];
+  },
+  addCommands() {
+    return {
+      setBlockquote: () => ({ commands: t }) => t.wrapIn(this.name),
+      toggleBlockquote: () => ({ commands: t }) => t.toggleWrap(this.name),
+      unsetBlockquote: () => ({ commands: t }) => t.lift(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-b": () => this.editor.commands.toggleBlockquote()
+    };
+  },
+  addInputRules() {
+    return [
+      E({
+        find: ve,
+        type: this.type
+      })
+    ];
+  }
+}), Me = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))$/, ke = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))/g, Te = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))$/, we = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))/g, Ae = R.create({
+  name: "bold",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "strong"
+      },
+      {
+        tag: "b",
+        getAttrs: (t) => t.style.fontWeight !== "normal" && null
+      },
+      {
+        style: "font-weight=400",
+        clearMark: (t) => t.type.name === this.name
+      },
+      {
+        style: "font-weight",
+        getAttrs: (t) => /^(bold(er)?|[5-9]\d{2,})$/.test(t) && null
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["strong", y(this.options.HTMLAttributes, t), 0];
+  },
+  addCommands() {
+    return {
+      setBold: () => ({ commands: t }) => t.setMark(this.name),
+      toggleBold: () => ({ commands: t }) => t.toggleMark(this.name),
+      unsetBold: () => ({ commands: t }) => t.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-b": () => this.editor.commands.toggleBold(),
+      "Mod-B": () => this.editor.commands.toggleBold()
+    };
+  },
+  addInputRules() {
+    return [
+      A({
+        find: Me,
+        type: this.type
+      }),
+      A({
+        find: Te,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      C({
+        find: ke,
+        type: this.type
+      }),
+      C({
+        find: we,
+        type: this.type
+      })
+    ];
+  }
+}), Ce = "listItem", q = "textStyle", J = /^\s*([-+*])\s$/, Le = v.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: t }) {
+    return ["ul", y(this.options.HTMLAttributes, t), 0];
+  },
+  addCommands() {
+    return {
+      toggleBulletList: () => ({ commands: t, chain: e }) => this.options.keepAttributes ? e().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(Ce, this.editor.getAttributes(q)).run() : t.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-8": () => this.editor.commands.toggleBulletList()
+    };
+  },
+  addInputRules() {
+    let t = E({
+      find: J,
+      type: this.type
+    });
+    return (this.options.keepMarks || this.options.keepAttributes) && (t = E({
+      find: J,
+      type: this.type,
+      keepMarks: this.options.keepMarks,
+      keepAttributes: this.options.keepAttributes,
+      getAttributes: () => this.editor.getAttributes(q),
+      editor: this.editor
+    })), [
+      t
+    ];
+  }
+}), Ie = new RegExp("(?<!`)`([^`]+)`(?!`)"), xe = new RegExp("(?<!`)`([^`]+)`(?!`)", "g"), He = R.create({
+  name: "code",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  excludes: "_",
+  code: !0,
+  exitable: !0,
+  parseHTML() {
+    return [
+      { tag: "code" }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["code", y(this.options.HTMLAttributes, t), 0];
+  },
+  addCommands() {
+    return {
+      setCode: () => ({ commands: t }) => t.setMark(this.name),
+      toggleCode: () => ({ commands: t }) => t.toggleMark(this.name),
+      unsetCode: () => ({ commands: t }) => t.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-e": () => this.editor.commands.toggleCode()
+    };
+  },
+  addInputRules() {
+    return [
+      A({
+        find: Ie,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      C({
+        find: xe,
+        type: this.type
+      })
+    ];
+  }
+}), Se = /^```([a-z]+)?[\s\n]$/, Ee = /^~~~([a-z]+)?[\s\n]$/, Oe = v.create({
+  name: "codeBlock",
+  addOptions() {
+    return {
+      languageClassPrefix: "language-",
+      exitOnTripleEnter: !0,
+      exitOnArrowDown: !0,
+      defaultLanguage: null,
+      HTMLAttributes: {}
+    };
+  },
+  content: "text*",
+  marks: "",
+  group: "block",
+  code: !0,
+  defining: !0,
+  addAttributes() {
+    return {
+      language: {
+        default: this.options.defaultLanguage,
+        parseHTML: (t) => {
+          var e;
+          const { languageClassPrefix: n } = this.options, i = [...((e = t.firstElementChild) === null || e === void 0 ? void 0 : e.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: t, HTMLAttributes: e }) {
+    return [
+      "pre",
+      y(this.options.HTMLAttributes, e),
+      [
+        "code",
+        {
+          class: t.attrs.language ? this.options.languageClassPrefix + t.attrs.language : null
+        },
+        0
+      ]
+    ];
+  },
+  addCommands() {
+    return {
+      setCodeBlock: (t) => ({ commands: e }) => e.setNode(this.name, t),
+      toggleCodeBlock: (t) => ({ commands: e }) => e.toggleNode(this.name, "paragraph", t)
+    };
+  },
+  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: t, $anchor: e } = this.editor.state.selection, n = e.pos === 1;
+        return !t || e.parent.type.name !== this.name ? !1 : n || !e.parent.textContent.length ? this.editor.commands.clearNodes() : !1;
+      },
+      // exit node on triple enter
+      Enter: ({ editor: t }) => {
+        if (!this.options.exitOnTripleEnter)
+          return !1;
+        const { state: e } = t, { selection: n } = e, { $from: r, empty: s } = n;
+        if (!s || r.parent.type !== this.type)
+          return !1;
+        const i = r.parentOffset === r.parent.nodeSize - 2, o = r.parent.textContent.endsWith(`
+
+`);
+        return !i || !o ? !1 : t.chain().command(({ tr: a }) => (a.delete(r.pos - 2, r.pos), !0)).exitCode().run();
+      },
+      // exit node on arrow down
+      ArrowDown: ({ editor: t }) => {
+        if (!this.options.exitOnArrowDown)
+          return !1;
+        const { state: e } = t, { selection: n, doc: r } = e, { $from: s, empty: i } = n;
+        if (!i || s.parent.type !== this.type || !(s.parentOffset === s.parent.nodeSize - 2))
+          return !1;
+        const a = s.after();
+        return a === void 0 ? !1 : r.nodeAt(a) ? t.commands.command(({ tr: u }) => (u.setSelection(O.near(r.resolve(a))), !0)) : t.commands.exitCode();
+      }
+    };
+  },
+  addInputRules() {
+    return [
+      V({
+        find: Se,
+        type: this.type,
+        getAttributes: (t) => ({
+          language: t[1]
+        })
+      }),
+      V({
+        find: Ee,
+        type: this.type,
+        getAttributes: (t) => ({
+          language: t[1]
+        })
+      })
+    ];
+  },
+  addProseMirrorPlugins() {
+    return [
+      // this plugin creates a code block for pasted content from VS Code
+      // we can also detect the copied code language
+      new H({
+        key: new P("codeBlockVSCodeHandler"),
+        props: {
+          handlePaste: (t, e) => {
+            if (!e.clipboardData || this.editor.isActive(this.type.name))
+              return !1;
+            const n = e.clipboardData.getData("text/plain"), r = e.clipboardData.getData("vscode-editor-data"), s = r ? JSON.parse(r) : void 0, i = s == null ? void 0 : s.mode;
+            if (!n || !i)
+              return !1;
+            const { tr: o, schema: a } = t.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(I.near(o.doc.resolve(Math.max(0, o.selection.from - 2)))), o.setMeta("paste", !0), t.dispatch(o), !0;
+          }
+        }
+      })
+    ];
+  }
+}), Pe = v.create({
+  name: "doc",
+  topNode: !0,
+  content: "block+"
+});
+function Re(t = {}) {
+  return new H({
+    view(e) {
+      return new _e(e, t);
+    }
+  });
+}
+class _e {
+  constructor(e, n) {
+    var r;
+    this.editorView = e, this.cursorPos = null, this.element = null, this.timeout = -1, this.width = (r = n.width) !== null && r !== void 0 ? r : 1, this.color = n.color === !1 ? void 0 : n.color || "black", this.class = n.class, this.handlers = ["dragover", "dragend", "drop", "dragleave"].map((s) => {
+      let i = (o) => {
+        this[s](o);
+      };
+      return e.dom.addEventListener(s, i), { name: s, handler: i };
+    });
+  }
+  destroy() {
+    this.handlers.forEach(({ name: e, handler: n }) => this.editorView.dom.removeEventListener(e, n));
+  }
+  update(e, n) {
+    this.cursorPos != null && n.doc != e.state.doc && (this.cursorPos > e.state.doc.content.size ? this.setCursor(null) : this.updateOverlay());
+  }
+  setCursor(e) {
+    e != this.cursorPos && (this.cursorPos = e, e == null ? (this.element.parentNode.removeChild(this.element), this.element = null) : this.updateOverlay());
+  }
+  updateOverlay() {
+    let e = this.editorView.state.doc.resolve(this.cursorPos), n = !e.parent.inlineContent, r;
+    if (n) {
+      let a = e.nodeBefore, l = e.nodeAfter;
+      if (a || l) {
+        let u = this.editorView.nodeDOM(this.cursorPos - (a ? a.nodeSize : 0));
+        if (u) {
+          let p = u.getBoundingClientRect(), d = a ? p.bottom : p.top;
+          a && l && (d = (d + this.editorView.nodeDOM(this.cursorPos).getBoundingClientRect().top) / 2), r = { left: p.left, right: p.right, top: d - this.width / 2, bottom: d + this.width / 2 };
+        }
+      }
+    }
+    if (!r) {
+      let a = this.editorView.coordsAtPos(this.cursorPos);
+      r = { left: a.left - this.width / 2, right: a.left + this.width / 2, top: a.top, bottom: a.bottom };
+    }
+    let s = this.editorView.dom.offsetParent;
+    this.element || (this.element = s.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 i, o;
+    if (!s || s == document.body && getComputedStyle(s).position == "static")
+      i = -pageXOffset, o = -pageYOffset;
+    else {
+      let a = s.getBoundingClientRect();
+      i = a.left - s.scrollLeft, o = a.top - s.scrollTop;
+    }
+    this.element.style.left = r.left - i + "px", this.element.style.top = r.top - o + "px", this.element.style.width = r.right - r.left + "px", this.element.style.height = r.bottom - r.top + "px";
+  }
+  scheduleRemoval(e) {
+    clearTimeout(this.timeout), this.timeout = setTimeout(() => this.setCursor(null), e);
+  }
+  dragover(e) {
+    if (!this.editorView.editable)
+      return;
+    let n = this.editorView.posAtCoords({ left: e.clientX, top: e.clientY }), r = n && n.inside >= 0 && this.editorView.state.doc.nodeAt(n.inside), s = r && r.type.spec.disableDropCursor, i = typeof s == "function" ? s(this.editorView, n, e) : s;
+    if (n && !i) {
+      let o = n.pos;
+      if (this.editorView.dragging && this.editorView.dragging.slice) {
+        let a = oe(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(e) {
+    (e.target == this.editorView.dom || !this.editorView.dom.contains(e.relatedTarget)) && this.setCursor(null);
+  }
+}
+const Ne = x.create({
+  name: "dropCursor",
+  addOptions() {
+    return {
+      color: "currentColor",
+      width: 1,
+      class: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      Re(this.options)
+    ];
+  }
+});
+class h extends O {
+  /**
+  Create a gap cursor.
+  */
+  constructor(e) {
+    super(e, e);
+  }
+  map(e, n) {
+    let r = e.resolve(n.map(this.head));
+    return h.valid(r) ? new h(r) : O.near(r);
+  }
+  content() {
+    return Q.empty;
+  }
+  eq(e) {
+    return e instanceof h && e.head == this.head;
+  }
+  toJSON() {
+    return { type: "gapcursor", pos: this.head };
+  }
+  /**
+  @internal
+  */
+  static fromJSON(e, n) {
+    if (typeof n.pos != "number")
+      throw new RangeError("Invalid input for GapCursor.fromJSON");
+    return new h(e.resolve(n.pos));
+  }
+  /**
+  @internal
+  */
+  getBookmark() {
+    return new j(this.anchor);
+  }
+  /**
+  @internal
+  */
+  static valid(e) {
+    let n = e.parent;
+    if (n.isTextblock || !Be(e) || !$e(e))
+      return !1;
+    let r = n.type.spec.allowGapCursor;
+    if (r != null)
+      return r;
+    let s = n.contentMatchAt(e.index()).defaultType;
+    return s && s.isTextblock;
+  }
+  /**
+  @internal
+  */
+  static findGapCursorFrom(e, n, r = !1) {
+    e: for (; ; ) {
+      if (!r && h.valid(e))
+        return e;
+      let s = e.pos, i = null;
+      for (let o = e.depth; ; o--) {
+        let a = e.node(o);
+        if (n > 0 ? e.indexAfter(o) < a.childCount : e.index(o) > 0) {
+          i = a.child(n > 0 ? e.indexAfter(o) : e.index(o) - 1);
+          break;
+        } else if (o == 0)
+          return null;
+        s += n;
+        let l = e.doc.resolve(s);
+        if (h.valid(l))
+          return l;
+      }
+      for (; ; ) {
+        let o = n > 0 ? i.firstChild : i.lastChild;
+        if (!o) {
+          if (i.isAtom && !i.isText && !W.isSelectable(i)) {
+            e = e.doc.resolve(s + i.nodeSize * n), r = !1;
+            continue e;
+          }
+          break;
+        }
+        i = o, s += n;
+        let a = e.doc.resolve(s);
+        if (h.valid(a))
+          return a;
+      }
+      return null;
+    }
+  }
+}
+h.prototype.visible = !1;
+h.findFrom = h.findGapCursorFrom;
+O.jsonID("gapcursor", h);
+class j {
+  constructor(e) {
+    this.pos = e;
+  }
+  map(e) {
+    return new j(e.map(this.pos));
+  }
+  resolve(e) {
+    let n = e.resolve(this.pos);
+    return h.valid(n) ? new h(n) : O.near(n);
+  }
+}
+function Be(t) {
+  for (let e = t.depth; e >= 0; e--) {
+    let n = t.index(e), r = t.node(e);
+    if (n == 0) {
+      if (r.type.spec.isolating)
+        return !0;
+      continue;
+    }
+    for (let s = r.child(n - 1); ; s = s.lastChild) {
+      if (s.childCount == 0 && !s.inlineContent || s.isAtom || s.type.spec.isolating)
+        return !0;
+      if (s.inlineContent)
+        return !1;
+    }
+  }
+  return !0;
+}
+function $e(t) {
+  for (let e = t.depth; e >= 0; e--) {
+    let n = t.indexAfter(e), r = t.node(e);
+    if (n == r.childCount) {
+      if (r.type.spec.isolating)
+        return !0;
+      continue;
+    }
+    for (let s = r.child(n); ; s = s.firstChild) {
+      if (s.childCount == 0 && !s.inlineContent || s.isAtom || s.type.spec.isolating)
+        return !0;
+      if (s.inlineContent)
+        return !1;
+    }
+  }
+  return !0;
+}
+function De() {
+  return new H({
+    props: {
+      decorations: Fe,
+      createSelectionBetween(t, e, n) {
+        return e.pos == n.pos && h.valid(n) ? new h(n) : null;
+      },
+      handleClick: Ke,
+      handleKeyDown: ze,
+      handleDOMEvents: { beforeinput: Ve }
+    }
+  });
+}
+const ze = ae({
+  ArrowLeft: _("horiz", -1),
+  ArrowRight: _("horiz", 1),
+  ArrowUp: _("vert", -1),
+  ArrowDown: _("vert", 1)
+});
+function _(t, e) {
+  const n = t == "vert" ? e > 0 ? "down" : "up" : e > 0 ? "right" : "left";
+  return function(r, s, i) {
+    let o = r.selection, a = e > 0 ? o.$to : o.$from, l = o.empty;
+    if (o instanceof I) {
+      if (!i.endOfTextblock(n) || a.depth == 0)
+        return !1;
+      l = !1, a = r.doc.resolve(e > 0 ? a.after() : a.before());
+    }
+    let u = h.findGapCursorFrom(a, e, l);
+    return u ? (s && s(r.tr.setSelection(new h(u))), !0) : !1;
+  };
+}
+function Ke(t, e, n) {
+  if (!t || !t.editable)
+    return !1;
+  let r = t.state.doc.resolve(e);
+  if (!h.valid(r))
+    return !1;
+  let s = t.posAtCoords({ left: n.clientX, top: n.clientY });
+  return s && s.inside > -1 && W.isSelectable(t.state.doc.nodeAt(s.inside)) ? !1 : (t.dispatch(t.state.tr.setSelection(new h(r))), !0);
+}
+function Ve(t, e) {
+  if (e.inputType != "insertCompositionText" || !(t.state.selection instanceof h))
+    return !1;
+  let { $from: n } = t.state.selection, r = n.parent.contentMatchAt(n.index()).findWrapping(t.state.schema.nodes.text);
+  if (!r)
+    return !1;
+  let s = G.empty;
+  for (let o = r.length - 1; o >= 0; o--)
+    s = G.from(r[o].createAndFill(null, s));
+  let i = t.state.tr.replace(n.pos, n.pos, new Q(s, 0, 0));
+  return i.setSelection(I.near(i.doc.resolve(n.pos + 1))), t.dispatch(i), !1;
+}
+function Fe(t) {
+  if (!(t.selection instanceof h))
+    return null;
+  let e = document.createElement("div");
+  return e.className = "ProseMirror-gapcursor", B.create(t.doc, [F.widget(t.selection.head, e, { key: "gapcursor" })]);
+}
+const We = x.create({
+  name: "gapCursor",
+  addProseMirrorPlugins() {
+    return [
+      De()
+    ];
+  },
+  extendNodeSchema(t) {
+    var e;
+    const n = {
+      name: t.name,
+      options: t.options,
+      storage: t.storage
+    };
+    return {
+      allowGapCursor: (e = le(ue(t, "allowGapCursor", n))) !== null && e !== void 0 ? e : null
+    };
+  }
+}), je = v.create({
+  name: "hardBreak",
+  addOptions() {
+    return {
+      keepMarks: !0,
+      HTMLAttributes: {}
+    };
+  },
+  inline: !0,
+  group: "inline",
+  selectable: !1,
+  linebreakReplacement: !0,
+  parseHTML() {
+    return [
+      { tag: "br" }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["br", y(this.options.HTMLAttributes, t)];
+  },
+  renderText() {
+    return `
+`;
+  },
+  addCommands() {
+    return {
+      setHardBreak: () => ({ commands: t, chain: e, state: n, editor: r }) => t.first([
+        () => t.exitCode(),
+        () => t.command(() => {
+          const { selection: s, storedMarks: i } = n;
+          if (s.$from.parent.type.spec.isolating)
+            return !1;
+          const { keepMarks: o } = this.options, { splittableMarks: a } = r.extensionManager, l = i || s.$to.parentOffset && s.$from.marks();
+          return e().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()
+    };
+  }
+}), Ge = v.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((t) => ({
+      tag: `h${t}`,
+      attrs: { level: t }
+    }));
+  },
+  renderHTML({ node: t, HTMLAttributes: e }) {
+    return [`h${this.options.levels.includes(t.attrs.level) ? t.attrs.level : this.options.levels[0]}`, y(this.options.HTMLAttributes, e), 0];
+  },
+  addCommands() {
+    return {
+      setHeading: (t) => ({ commands: e }) => this.options.levels.includes(t.level) ? e.setNode(this.name, t) : !1,
+      toggleHeading: (t) => ({ commands: e }) => this.options.levels.includes(t.level) ? e.toggleNode(this.name, "paragraph", t) : !1
+    };
+  },
+  addKeyboardShortcuts() {
+    return this.options.levels.reduce((t, e) => ({
+      ...t,
+      [`Mod-Alt-${e}`]: () => this.editor.commands.toggleHeading({ level: e })
+    }), {});
+  },
+  addInputRules() {
+    return this.options.levels.map((t) => V({
+      find: new RegExp(`^(#{1,${t}})\\s$`),
+      type: this.type,
+      getAttributes: {
+        level: t
+      }
+    }));
+  }
+});
+var $ = 200, g = function() {
+};
+g.prototype.append = function(e) {
+  return e.length ? (e = g.from(e), !this.length && e || e.length < $ && this.leafAppend(e) || this.length < $ && e.leafPrepend(this) || this.appendInner(e)) : this;
+};
+g.prototype.prepend = function(e) {
+  return e.length ? g.from(e).append(this) : this;
+};
+g.prototype.appendInner = function(e) {
+  return new qe(this, e);
+};
+g.prototype.slice = function(e, n) {
+  return e === void 0 && (e = 0), n === void 0 && (n = this.length), e >= n ? g.empty : this.sliceInner(Math.max(0, e), Math.min(this.length, n));
+};
+g.prototype.get = function(e) {
+  if (!(e < 0 || e >= this.length))
+    return this.getInner(e);
+};
+g.prototype.forEach = function(e, n, r) {
+  n === void 0 && (n = 0), r === void 0 && (r = this.length), n <= r ? this.forEachInner(e, n, r, 0) : this.forEachInvertedInner(e, n, r, 0);
+};
+g.prototype.map = function(e, n, r) {
+  n === void 0 && (n = 0), r === void 0 && (r = this.length);
+  var s = [];
+  return this.forEach(function(i, o) {
+    return s.push(e(i, o));
+  }, n, r), s;
+};
+g.from = function(e) {
+  return e instanceof g ? e : e && e.length ? new te(e) : g.empty;
+};
+var te = /* @__PURE__ */ function(t) {
+  function e(r) {
+    t.call(this), this.values = r;
+  }
+  t && (e.__proto__ = t), e.prototype = Object.create(t && t.prototype), e.prototype.constructor = e;
+  var n = { length: { configurable: !0 }, depth: { configurable: !0 } };
+  return e.prototype.flatten = function() {
+    return this.values;
+  }, e.prototype.sliceInner = function(s, i) {
+    return s == 0 && i == this.length ? this : new e(this.values.slice(s, i));
+  }, e.prototype.getInner = function(s) {
+    return this.values[s];
+  }, e.prototype.forEachInner = function(s, i, o, a) {
+    for (var l = i; l < o; l++)
+      if (s(this.values[l], a + l) === !1)
+        return !1;
+  }, e.prototype.forEachInvertedInner = function(s, i, o, a) {
+    for (var l = i - 1; l >= o; l--)
+      if (s(this.values[l], a + l) === !1)
+        return !1;
+  }, e.prototype.leafAppend = function(s) {
+    if (this.length + s.length <= $)
+      return new e(this.values.concat(s.flatten()));
+  }, e.prototype.leafPrepend = function(s) {
+    if (this.length + s.length <= $)
+      return new e(s.flatten().concat(this.values));
+  }, n.length.get = function() {
+    return this.values.length;
+  }, n.depth.get = function() {
+    return 0;
+  }, Object.defineProperties(e.prototype, n), e;
+}(g);
+g.empty = new te([]);
+var qe = /* @__PURE__ */ function(t) {
+  function e(n, r) {
+    t.call(this), this.left = n, this.right = r, this.length = n.length + r.length, this.depth = Math.max(n.depth, r.depth) + 1;
+  }
+  return t && (e.__proto__ = t), e.prototype = Object.create(t && t.prototype), e.prototype.constructor = e, e.prototype.flatten = function() {
+    return this.left.flatten().concat(this.right.flatten());
+  }, e.prototype.getInner = function(r) {
+    return r < this.left.length ? this.left.get(r) : this.right.get(r - this.left.length);
+  }, e.prototype.forEachInner = function(r, s, i, o) {
+    var a = this.left.length;
+    if (s < a && this.left.forEachInner(r, s, Math.min(i, a), o) === !1 || i > a && this.right.forEachInner(r, Math.max(s - a, 0), Math.min(this.length, i) - a, o + a) === !1)
+      return !1;
+  }, e.prototype.forEachInvertedInner = function(r, s, i, o) {
+    var a = this.left.length;
+    if (s > a && this.right.forEachInvertedInner(r, s - a, Math.max(i, a) - a, o + a) === !1 || i < a && this.left.forEachInvertedInner(r, Math.min(s, a), i, o) === !1)
+      return !1;
+  }, e.prototype.sliceInner = function(r, s) {
+    if (r == 0 && s == this.length)
+      return this;
+    var i = this.left.length;
+    return s <= i ? this.left.slice(r, s) : r >= i ? this.right.slice(r - i, s - i) : this.left.slice(r, i).append(this.right.slice(0, s - i));
+  }, e.prototype.leafAppend = function(r) {
+    var s = this.right.leafAppend(r);
+    if (s)
+      return new e(this.left, s);
+  }, e.prototype.leafPrepend = function(r) {
+    var s = this.left.leafPrepend(r);
+    if (s)
+      return new e(s, this.right);
+  }, e.prototype.appendInner = function(r) {
+    return this.left.depth >= Math.max(this.right.depth, r.depth) + 1 ? new e(this.left, new e(this.right, r)) : new e(this, r);
+  }, e;
+}(g);
+const Je = 500;
+class M {
+  constructor(e, n) {
+    this.items = e, this.eventCount = n;
+  }
+  // Pop the latest event off the branch's history and apply it
+  // to a document transform.
+  popEvent(e, n) {
+    if (this.eventCount == 0)
+      return null;
+    let r = this.items.length;
+    for (; ; r--)
+      if (this.items.get(r - 1).selection) {
+        --r;
+        break;
+      }
+    let s, i;
+    n && (s = this.remapping(r, this.items.length), i = s.maps.length);
+    let o = e.tr, a, l, u = [], p = [];
+    return this.items.forEach((d, c) => {
+      if (!d.step) {
+        s || (s = this.remapping(r, c + 1), i = s.maps.length), i--, p.push(d);
+        return;
+      }
+      if (s) {
+        p.push(new k(d.map));
+        let f = d.step.map(s.slice(i)), b;
+        f && o.maybeStep(f).doc && (b = o.mapping.maps[o.mapping.maps.length - 1], u.push(new k(b, void 0, void 0, u.length + p.length))), i--, b && s.appendMap(b, i);
+      } else
+        o.maybeStep(d.step);
+      if (d.selection)
+        return a = s ? d.selection.map(s.slice(i)) : d.selection, l = new M(this.items.slice(0, r).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(e, n, r, s) {
+    let i = [], o = this.eventCount, a = this.items, l = !s && a.length ? a.get(a.length - 1) : null;
+    for (let p = 0; p < e.steps.length; p++) {
+      let d = e.steps[p].invert(e.docs[p]), c = new k(e.mapping.maps[p], d, n), f;
+      (f = l && l.merge(c)) && (c = f, p ? i.pop() : a = a.slice(0, a.length - 1)), i.push(c), n && (o++, n = void 0), s || (l = c);
+    }
+    let u = o - r.depth;
+    return u > Xe && (a = Ue(a, u), o -= u), new M(a.append(i), o);
+  }
+  remapping(e, n) {
+    let r = new de();
+    return this.items.forEach((s, i) => {
+      let o = s.mirrorOffset != null && i - s.mirrorOffset >= e ? r.maps.length - s.mirrorOffset : void 0;
+      r.appendMap(s.map, o);
+    }, e, n), r;
+  }
+  addMaps(e) {
+    return this.eventCount == 0 ? this : new M(this.items.append(e.map((n) => new k(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(e, n) {
+    if (!this.eventCount)
+      return this;
+    let r = [], s = Math.max(0, this.items.length - n), i = e.mapping, o = e.steps.length, a = this.eventCount;
+    this.items.forEach((c) => {
+      c.selection && a--;
+    }, s);
+    let l = n;
+    this.items.forEach((c) => {
+      let f = i.getMirror(--l);
+      if (f == null)
+        return;
+      o = Math.min(o, f);
+      let b = i.maps[f];
+      if (c.step) {
+        let S = e.steps[f].invert(e.docs[f]), L = c.selection && c.selection.map(i.slice(l + 1, f));
+        L && a++, r.push(new k(b, S, L));
+      } else
+        r.push(new k(b));
+    }, s);
+    let u = [];
+    for (let c = n; c < o; c++)
+      u.push(new k(i.maps[c]));
+    let p = this.items.slice(0, s).append(u).append(r), d = new M(p, a);
+    return d.emptyItemCount() > Je && (d = d.compress(this.items.length - r.length)), d;
+  }
+  emptyItemCount() {
+    let e = 0;
+    return this.items.forEach((n) => {
+      n.step || e++;
+    }), e;
+  }
+  // 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(e = this.items.length) {
+    let n = this.remapping(0, e), r = n.maps.length, s = [], i = 0;
+    return this.items.forEach((o, a) => {
+      if (a >= e)
+        s.push(o), o.selection && i++;
+      else if (o.step) {
+        let l = o.step.map(n.slice(r)), u = l && l.getMap();
+        if (r--, u && n.appendMap(u, r), l) {
+          let p = o.selection && o.selection.map(n.slice(r));
+          p && i++;
+          let d = new k(u.invert(), l, p), c, f = s.length - 1;
+          (c = s.length && s[f].merge(d)) ? s[f] = c : s.push(d);
+        }
+      } else o.map && r--;
+    }, this.items.length, 0), new M(g.from(s.reverse()), i);
+  }
+}
+M.empty = new M(g.empty, 0);
+function Ue(t, e) {
+  let n;
+  return t.forEach((r, s) => {
+    if (r.selection && e-- == 0)
+      return n = s, !1;
+  }), t.slice(n);
+}
+class k {
+  constructor(e, n, r, s) {
+    this.map = e, this.step = n, this.selection = r, this.mirrorOffset = s;
+  }
+  merge(e) {
+    if (this.step && e.step && !e.selection) {
+      let n = e.step.merge(this.step);
+      if (n)
+        return new k(n.getMap().invert(), n, this.selection);
+    }
+  }
+}
+class T {
+  constructor(e, n, r, s, i) {
+    this.done = e, this.undone = n, this.prevRanges = r, this.prevTime = s, this.prevComposition = i;
+  }
+}
+const Xe = 20;
+function Ye(t, e, n, r) {
+  let s = n.getMeta(w), i;
+  if (s)
+    return s.historyState;
+  n.getMeta(et) && (t = new T(t.done, t.undone, null, 0, -1));
+  let o = n.getMeta("appendedTransaction");
+  if (n.steps.length == 0)
+    return t;
+  if (o && o.getMeta(w))
+    return o.getMeta(w).redo ? new T(t.done.addTransform(n, void 0, r, N(e)), t.undone, U(n.mapping.maps), t.prevTime, t.prevComposition) : new T(t.done, t.undone.addTransform(n, void 0, r, N(e)), null, t.prevTime, t.prevComposition);
+  if (n.getMeta("addToHistory") !== !1 && !(o && o.getMeta("addToHistory") === !1)) {
+    let a = n.getMeta("composition"), l = t.prevTime == 0 || !o && t.prevComposition != a && (t.prevTime < (n.time || 0) - r.newGroupDelay || !Ze(n, t.prevRanges)), u = o ? z(t.prevRanges, n.mapping) : U(n.mapping.maps);
+    return new T(t.done.addTransform(n, l ? e.selection.getBookmark() : void 0, r, N(e)), M.empty, u, n.time, a ?? t.prevComposition);
+  } else return (i = n.getMeta("rebased")) ? new T(t.done.rebased(n, i), t.undone.rebased(n, i), z(t.prevRanges, n.mapping), t.prevTime, t.prevComposition) : new T(t.done.addMaps(n.mapping.maps), t.undone.addMaps(n.mapping.maps), z(t.prevRanges, n.mapping), t.prevTime, t.prevComposition);
+}
+function Ze(t, e) {
+  if (!e)
+    return !1;
+  if (!t.docChanged)
+    return !0;
+  let n = !1;
+  return t.mapping.maps[0].forEach((r, s) => {
+    for (let i = 0; i < e.length; i += 2)
+      r <= e[i + 1] && s >= e[i] && (n = !0);
+  }), n;
+}
+function U(t) {
+  let e = [];
+  for (let n = t.length - 1; n >= 0 && e.length == 0; n--)
+    t[n].forEach((r, s, i, o) => e.push(i, o));
+  return e;
+}
+function z(t, e) {
+  if (!t)
+    return null;
+  let n = [];
+  for (let r = 0; r < t.length; r += 2) {
+    let s = e.map(t[r], 1), i = e.map(t[r + 1], -1);
+    s <= i && n.push(s, i);
+  }
+  return n;
+}
+function Qe(t, e, n) {
+  let r = N(e), s = w.get(e).spec.config, i = (n ? t.undone : t.done).popEvent(e, r);
+  if (!i)
+    return null;
+  let o = i.selection.resolve(i.transform.doc), a = (n ? t.done : t.undone).addTransform(i.transform, e.selection.getBookmark(), s, r), l = new T(n ? a : i.remaining, n ? i.remaining : a, null, 0, -1);
+  return i.transform.setSelection(o).setMeta(w, { redo: n, historyState: l });
+}
+let K = !1, X = null;
+function N(t) {
+  let e = t.plugins;
+  if (X != e) {
+    K = !1, X = e;
+    for (let n = 0; n < e.length; n++)
+      if (e[n].spec.historyPreserveItems) {
+        K = !0;
+        break;
+      }
+  }
+  return K;
+}
+const w = new P("history"), et = new P("closeHistory");
+function tt(t = {}) {
+  return t = {
+    depth: t.depth || 100,
+    newGroupDelay: t.newGroupDelay || 500
+  }, new H({
+    key: w,
+    state: {
+      init() {
+        return new T(M.empty, M.empty, null, 0, -1);
+      },
+      apply(e, n, r) {
+        return Ye(n, r, e, t);
+      }
+    },
+    config: t,
+    props: {
+      handleDOMEvents: {
+        beforeinput(e, n) {
+          let r = n.inputType, s = r == "historyUndo" ? re : r == "historyRedo" ? se : null;
+          return s ? (n.preventDefault(), s(e.state, e.dispatch)) : !1;
+        }
+      }
+    }
+  });
+}
+function ne(t, e) {
+  return (n, r) => {
+    let s = w.getState(n);
+    if (!s || (t ? s.undone : s.done).eventCount == 0)
+      return !1;
+    if (r) {
+      let i = Qe(s, n, t);
+      i && r(e ? i.scrollIntoView() : i);
+    }
+    return !0;
+  };
+}
+const re = ne(!1, !0), se = ne(!0, !0), nt = x.create({
+  name: "history",
+  addOptions() {
+    return {
+      depth: 100,
+      newGroupDelay: 500
+    };
+  },
+  addCommands() {
+    return {
+      undo: () => ({ state: t, dispatch: e }) => re(t, e),
+      redo: () => ({ state: t, dispatch: e }) => se(t, e)
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      tt(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()
+    };
+  }
+}), rt = v.create({
+  name: "horizontalRule",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  group: "block",
+  parseHTML() {
+    return [{ tag: "hr" }];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["hr", y(this.options.HTMLAttributes, t)];
+  },
+  addCommands() {
+    return {
+      setHorizontalRule: () => ({ chain: t, state: e }) => {
+        const { selection: n } = e, { $from: r, $to: s } = n, i = t();
+        return r.parentOffset === 0 ? i.insertContentAt({
+          from: Math.max(r.pos - 1, 0),
+          to: s.pos
+        }, {
+          type: this.name
+        }) : pe(n) ? i.insertContentAt(s.pos, {
+          type: this.name
+        }) : i.insertContent({ type: this.name }), i.command(({ tr: o, dispatch: a }) => {
+          var l;
+          if (a) {
+            const { $to: u } = o.selection, p = u.end();
+            if (u.nodeAfter)
+              u.nodeAfter.isTextblock ? o.setSelection(I.create(o.doc, u.pos + 1)) : u.nodeAfter.isBlock ? o.setSelection(W.create(o.doc, u.pos)) : o.setSelection(I.create(o.doc, u.pos));
+            else {
+              const d = (l = u.parent.type.contentMatch.defaultType) === null || l === void 0 ? void 0 : l.create();
+              d && (o.insert(p, d), o.setSelection(I.create(o.doc, p + 1)));
+            }
+            o.scrollIntoView();
+          }
+          return !0;
+        }).run();
+      }
+    };
+  },
+  addInputRules() {
+    return [
+      ee({
+        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 = R.create({
+  name: "italic",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "em"
+      },
+      {
+        tag: "i",
+        getAttrs: (t) => t.style.fontStyle !== "normal" && null
+      },
+      {
+        style: "font-style=normal",
+        clearMark: (t) => t.type.name === this.name
+      },
+      {
+        style: "font-style=italic"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["em", y(this.options.HTMLAttributes, t), 0];
+  },
+  addCommands() {
+    return {
+      setItalic: () => ({ commands: t }) => t.setMark(this.name),
+      toggleItalic: () => ({ commands: t }) => t.toggleMark(this.name),
+      unsetItalic: () => ({ commands: t }) => t.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-i": () => this.editor.commands.toggleItalic(),
+      "Mod-I": () => this.editor.commands.toggleItalic()
+    };
+  },
+  addInputRules() {
+    return [
+      A({
+        find: st,
+        type: this.type
+      }),
+      A({
+        find: ot,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      C({
+        find: it,
+        type: this.type
+      }),
+      C({
+        find: at,
+        type: this.type
+      })
+    ];
+  }
+}), ut = v.create({
+  name: "listItem",
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      bulletListTypeName: "bulletList",
+      orderedListTypeName: "orderedList"
+    };
+  },
+  content: "paragraph block*",
+  defining: !0,
+  parseHTML() {
+    return [
+      {
+        tag: "li"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["li", y(this.options.HTMLAttributes, t), 0];
+  },
+  addKeyboardShortcuts() {
+    return {
+      Enter: () => this.editor.commands.splitListItem(this.name),
+      Tab: () => this.editor.commands.sinkListItem(this.name),
+      "Shift-Tab": () => this.editor.commands.liftListItem(this.name)
+    };
+  }
+}), dt = "listItem", Y = "textStyle", Z = /^(\d+)\.\s$/, pt = v.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: (t) => t.hasAttribute("start") ? parseInt(t.getAttribute("start") || "", 10) : 1
+      },
+      type: {
+        default: void 0,
+        parseHTML: (t) => t.getAttribute("type")
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "ol"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    const { start: e, ...n } = t;
+    return e === 1 ? ["ol", y(this.options.HTMLAttributes, n), 0] : ["ol", y(this.options.HTMLAttributes, t), 0];
+  },
+  addCommands() {
+    return {
+      toggleOrderedList: () => ({ commands: t, chain: e }) => this.options.keepAttributes ? e().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(dt, this.editor.getAttributes(Y)).run() : t.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-7": () => this.editor.commands.toggleOrderedList()
+    };
+  },
+  addInputRules() {
+    let t = E({
+      find: Z,
+      type: this.type,
+      getAttributes: (e) => ({ start: +e[1] }),
+      joinPredicate: (e, n) => n.childCount + n.attrs.start === +e[1]
+    });
+    return (this.options.keepMarks || this.options.keepAttributes) && (t = E({
+      find: Z,
+      type: this.type,
+      keepMarks: this.options.keepMarks,
+      keepAttributes: this.options.keepAttributes,
+      getAttributes: (e) => ({ start: +e[1], ...this.editor.getAttributes(Y) }),
+      joinPredicate: (e, n) => n.childCount + n.attrs.start === +e[1],
+      editor: this.editor
+    })), [
+      t
+    ];
+  }
+}), ct = v.create({
+  name: "paragraph",
+  priority: 1e3,
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  group: "block",
+  content: "inline*",
+  parseHTML() {
+    return [
+      { tag: "p" }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["p", y(this.options.HTMLAttributes, t), 0];
+  },
+  addCommands() {
+    return {
+      setParagraph: () => ({ commands: t }) => t.setNode(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Alt-0": () => this.editor.commands.setParagraph()
+    };
+  }
+}), ht = /(?:^|\s)(~~(?!\s+~~)((?:[^~]+))~~(?!\s+~~))$/, ft = /(?:^|\s)(~~(?!\s+~~)((?:[^~]+))~~(?!\s+~~))/g, mt = R.create({
+  name: "strike",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "s"
+      },
+      {
+        tag: "del"
+      },
+      {
+        tag: "strike"
+      },
+      {
+        style: "text-decoration",
+        consuming: !1,
+        getAttrs: (t) => t.includes("line-through") ? {} : !1
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["s", y(this.options.HTMLAttributes, t), 0];
+  },
+  addCommands() {
+    return {
+      setStrike: () => ({ commands: t }) => t.setMark(this.name),
+      toggleStrike: () => ({ commands: t }) => t.toggleMark(this.name),
+      unsetStrike: () => ({ commands: t }) => t.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-s": () => this.editor.commands.toggleStrike()
+    };
+  },
+  addInputRules() {
+    return [
+      A({
+        find: ht,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      C({
+        find: ft,
+        type: this.type
+      })
+    ];
+  }
+}), gt = v.create({
+  name: "text",
+  group: "inline"
+}), yt = x.create({
+  name: "starterKit",
+  addExtensions() {
+    var t, e, n, r, s, i, o, a, l, u, p, d, c, f, b, S, L, D;
+    const m = [];
+    return this.options.bold !== !1 && m.push(Ae.configure((t = this.options) === null || t === void 0 ? void 0 : t.bold)), this.options.blockquote !== !1 && m.push(be.configure((e = this.options) === null || e === void 0 ? void 0 : e.blockquote)), this.options.bulletList !== !1 && m.push(Le.configure((n = this.options) === null || n === void 0 ? void 0 : n.bulletList)), this.options.code !== !1 && m.push(He.configure((r = this.options) === null || r === void 0 ? void 0 : r.code)), this.options.codeBlock !== !1 && m.push(Oe.configure((s = this.options) === null || s === void 0 ? void 0 : s.codeBlock)), this.options.document !== !1 && m.push(Pe.configure((i = this.options) === null || i === void 0 ? void 0 : i.document)), this.options.dropcursor !== !1 && m.push(Ne.configure((o = this.options) === null || o === void 0 ? void 0 : o.dropcursor)), this.options.gapcursor !== !1 && m.push(We.configure((a = this.options) === null || a === void 0 ? void 0 : a.gapcursor)), this.options.hardBreak !== !1 && m.push(je.configure((l = this.options) === null || l === void 0 ? void 0 : l.hardBreak)), this.options.heading !== !1 && m.push(Ge.configure((u = this.options) === null || u === void 0 ? void 0 : u.heading)), this.options.history !== !1 && m.push(nt.configure((p = this.options) === null || p === void 0 ? void 0 : p.history)), this.options.horizontalRule !== !1 && m.push(rt.configure((d = this.options) === null || d === void 0 ? void 0 : d.horizontalRule)), this.options.italic !== !1 && m.push(lt.configure((c = this.options) === null || c === void 0 ? void 0 : c.italic)), this.options.listItem !== !1 && m.push(ut.configure((f = this.options) === null || f === void 0 ? void 0 : f.listItem)), this.options.orderedList !== !1 && m.push(pt.configure((b = this.options) === null || b === void 0 ? void 0 : b.orderedList)), this.options.paragraph !== !1 && m.push(ct.configure((S = this.options) === null || S === void 0 ? void 0 : S.paragraph)), this.options.strike !== !1 && m.push(mt.configure((L = this.options) === null || L === void 0 ? void 0 : L.strike)), this.options.text !== !1 && m.push(gt.configure((D = this.options) === null || D === void 0 ? void 0 : D.text)), m;
+  }
+}), vt = x.create({
+  name: "focus",
+  addOptions() {
+    return {
+      className: "has-focus",
+      mode: "all"
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new H({
+        key: new P("focus"),
+        props: {
+          decorations: ({ doc: t, selection: e }) => {
+            const { isEditable: n, isFocused: r } = this.editor, { anchor: s } = e, i = [];
+            if (!n || !r)
+              return B.create(t, []);
+            let o = 0;
+            this.options.mode === "deepest" && t.descendants((l, u) => {
+              if (l.isText)
+                return;
+              if (!(s >= u && s <= u + l.nodeSize - 1))
+                return !1;
+              o += 1;
+            });
+            let a = 0;
+            return t.descendants((l, u) => {
+              if (l.isText || !(s >= u && s <= 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(F.node(u, u + l.nodeSize, {
+                class: this.options.className
+              }));
+            }), B.create(t, i);
+          }
+        }
+      })
+    ];
+  }
+}), bt = /(?:^|\s)(==(?!\s+==)((?:[^=]+))==(?!\s+==))$/, Mt = /(?:^|\s)(==(?!\s+==)((?:[^=]+))==(?!\s+==))/g, kt = R.create({
+  name: "highlight",
+  addOptions() {
+    return {
+      multicolor: !1,
+      HTMLAttributes: {}
+    };
+  },
+  addAttributes() {
+    return this.options.multicolor ? {
+      color: {
+        default: null,
+        parseHTML: (t) => t.getAttribute("data-color") || t.style.backgroundColor,
+        renderHTML: (t) => t.color ? {
+          "data-color": t.color,
+          style: `background-color: ${t.color}; color: inherit`
+        } : {}
+      }
+    } : {};
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "mark"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["mark", y(this.options.HTMLAttributes, t), 0];
+  },
+  addCommands() {
+    return {
+      setHighlight: (t) => ({ commands: e }) => e.setMark(this.name, t),
+      toggleHighlight: (t) => ({ commands: e }) => e.toggleMark(this.name, t),
+      unsetHighlight: () => ({ commands: t }) => t.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-h": () => this.editor.commands.toggleHighlight()
+    };
+  },
+  addInputRules() {
+    return [
+      A({
+        find: bt,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      C({
+        find: Mt,
+        type: this.type
+      })
+    ];
+  }
+}), Tt = /(?:^|\s)(!\[(.+|:?)]\((\S+)(?:(?:\s+)["'](\S+)["'])?\))$/, wt = v.create({
+  name: "image",
+  addOptions() {
+    return {
+      inline: !1,
+      allowBase64: !1,
+      HTMLAttributes: {}
+    };
+  },
+  inline() {
+    return this.options.inline;
+  },
+  group() {
+    return this.options.inline ? "inline" : "block";
+  },
+  draggable: !0,
+  addAttributes() {
+    return {
+      src: {
+        default: null
+      },
+      alt: {
+        default: null
+      },
+      title: {
+        default: null
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: this.options.allowBase64 ? "img[src]" : 'img[src]:not([src^="data:"])'
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["img", y(this.options.HTMLAttributes, t)];
+  },
+  addCommands() {
+    return {
+      setImage: (t) => ({ commands: e }) => e.insertContent({
+        type: this.name,
+        attrs: t
+      })
+    };
+  },
+  addInputRules() {
+    return [
+      ee({
+        find: Tt,
+        type: this.type,
+        getAttributes: (t) => {
+          const [, , e, n, r] = t;
+          return { src: n, alt: e, title: r };
+        }
+      })
+    ];
+  }
+}), St = (t) => [
+  yt.configure({
+    dropcursor: {
+      width: 4,
+      color: "#ebf6fe"
+    }
+  }),
+  ye.configure({
+    showOnlyWhenEditable: !0,
+    includeChildren: !0,
+    showOnlyCurrent: !1,
+    emptyEditorClass: "is-editor-empty",
+    emptyNodeClass: "is-node-empty",
+    placeholder: ({ editor: e, node: n }) => e.isDestroyed ? "" : n.type.name === "heading" ? `Heading ${n.attrs.level}` : t.placeholderText || 'Type "/" for commands...'
+  }),
+  vt.configure({ mode: "deepest", className: "has-focus" }),
+  ce.configure({
+    slashSuggestion: {
+      items: he,
+      render: fe
+    }
+  }),
+  kt,
+  me,
+  ge,
+  wt.configure({
+    inline: !0,
+    HTMLAttributes: {
+      class: "scribe-image-node"
+    },
+    allowBase64: !0
+  })
+];
+export {
+  St as initExtensions
+};