tuikit-atomicx-vue3 4.5.1 → 4.5.2

package/dist/index-CTthrJb2.js

@@ -0,0 +1,1461 @@
+import { E, P, a as N, i as ie, b as U, D as Z, N as M, w as H, m as v, M as B, d as I, f as x, T as L, t as z, S, g as oe, k as ae, F, h as Q, j as K, l as le, o as de, p as ue, n as pe, q as ce, r as he } from "./index-DuAffztD.js";
+const ft = E.create({
+  name: "placeholder",
+  addOptions() {
+    return {
+      emptyEditorClass: "is-editor-empty",
+      emptyNodeClass: "is-empty",
+      placeholder: "Write something …",
+      showOnlyWhenEditable: !0,
+      showOnlyCurrent: !0,
+      includeChildren: !1
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new P({
+        key: new N("placeholder"),
+        props: {
+          decorations: ({ doc: t, selection: e }) => {
+            const n = this.editor.isEditable || !this.options.showOnlyWhenEditable, { anchor: s } = e, r = [];
+            if (!n)
+              return null;
+            const i = this.editor.isEmpty;
+            return t.descendants((o, a) => {
+              const l = s >= a && s <= a + o.nodeSize, u = !o.isLeaf && ie(o);
+              if ((l || !this.options.showOnlyCurrent) && u) {
+                const c = [this.options.emptyNodeClass];
+                i && c.push(this.options.emptyEditorClass);
+                const d = U.node(a, a + o.nodeSize, {
+                  class: c.join(" "),
+                  "data-placeholder": typeof this.options.placeholder == "function" ? this.options.placeholder({
+                    editor: this.editor,
+                    node: o,
+                    pos: a,
+                    hasAnchor: l
+                  }) : this.options.placeholder
+                });
+                r.push(d);
+              }
+              return this.options.includeChildren;
+            }), Z.create(t, r);
+          }
+        }
+      })
+    ];
+  }
+}), fe = /^\s*>\s$/, me = M.create({
+  name: "blockquote",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  content: "block+",
+  group: "block",
+  defining: !0,
+  parseHTML() {
+    return [
+      { tag: "blockquote" }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["blockquote", v(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 [
+      H({
+        find: fe,
+        type: this.type
+      })
+    ];
+  }
+}), ge = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))$/, ye = /(?:^|\s)(\*\*(?!\s+\*\*)((?:[^*]+))\*\*(?!\s+\*\*))/g, ve = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))$/, be = /(?:^|\s)(__(?!\s+__)((?:[^_]+))__(?!\s+__))/g, Me = B.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", v(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 [
+      x({
+        find: ge,
+        type: this.type
+      }),
+      x({
+        find: ve,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      I({
+        find: ye,
+        type: this.type
+      }),
+      I({
+        find: be,
+        type: this.type
+      })
+    ];
+  }
+}), ke = "listItem", G = "textStyle", j = /^\s*([-+*])\s$/, we = M.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", v(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(ke, this.editor.getAttributes(G)).run() : t.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-8": () => this.editor.commands.toggleBulletList()
+    };
+  },
+  addInputRules() {
+    let t = H({
+      find: j,
+      type: this.type
+    });
+    return (this.options.keepMarks || this.options.keepAttributes) && (t = H({
+      find: j,
+      type: this.type,
+      keepMarks: this.options.keepMarks,
+      keepAttributes: this.options.keepAttributes,
+      getAttributes: () => this.editor.getAttributes(G),
+      editor: this.editor
+    })), [
+      t
+    ];
+  }
+}), Ae = /(^|[^`])`([^`]+)`(?!`)/, Te = /(^|[^`])`([^`]+)`(?!`)/g, Ce = B.create({
+  name: "code",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  excludes: "_",
+  code: !0,
+  exitable: !0,
+  parseHTML() {
+    return [
+      { tag: "code" }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["code", v(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 [
+      x({
+        find: Ae,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      I({
+        find: Te,
+        type: this.type
+      })
+    ];
+  }
+}), Le = /^```([a-z]+)?[\s\n]$/, Ie = /^~~~([a-z]+)?[\s\n]$/, xe = M.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",
+      v(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: 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 : t.chain().command(({ tr: a }) => (a.delete(s.pos - 2, s.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: s } = e, { $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) ? t.commands.command(({ tr: u }) => (u.setSelection(S.near(s.resolve(a))), !0)) : t.commands.exitCode();
+      }
+    };
+  },
+  addInputRules() {
+    return [
+      z({
+        find: Le,
+        type: this.type,
+        getAttributes: (t) => ({
+          language: t[1]
+        })
+      }),
+      z({
+        find: Ie,
+        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 P({
+        key: new N("codeBlockVSCodeHandler"),
+        props: {
+          handlePaste: (t, e) => {
+            if (!e.clipboardData || this.editor.isActive(this.type.name))
+              return !1;
+            const n = e.clipboardData.getData("text/plain"), s = e.clipboardData.getData("vscode-editor-data"), r = s ? JSON.parse(s) : void 0, i = r == null ? void 0 : r.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(L.near(o.doc.resolve(Math.max(0, o.selection.from - 2)))), o.setMeta("paste", !0), t.dispatch(o), !0;
+          }
+        }
+      })
+    ];
+  }
+}), He = M.create({
+  name: "doc",
+  topNode: !0,
+  content: "block+"
+});
+function Se(t = {}) {
+  return new P({
+    view(e) {
+      return new Ee(e, t);
+    }
+  });
+}
+class Ee {
+  constructor(e, n) {
+    var s;
+    this.editorView = e, 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 e.dom.addEventListener(r, i), { name: r, 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, s, r = this.editorView.dom, i = r.getBoundingClientRect(), o = i.width / r.offsetWidth, a = i.height / r.offsetHeight;
+    if (n) {
+      let d = e.nodeBefore, p = e.nodeAfter;
+      if (d || p) {
+        let h = this.editorView.nodeDOM(this.cursorPos - (d ? d.nodeSize : 0));
+        if (h) {
+          let y = h.getBoundingClientRect(), k = d ? y.bottom : y.top;
+          d && p && (k = (k + this.editorView.nodeDOM(this.cursorPos).getBoundingClientRect().top) / 2);
+          let A = this.width / 2 * a;
+          s = { left: y.left, right: y.right, top: k - A, bottom: k + A };
+        }
+      }
+    }
+    if (!s) {
+      let d = this.editorView.coordsAtPos(this.cursorPos), p = this.width / 2 * o;
+      s = { left: d.left - p, right: d.left + p, 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, c;
+    if (!l || l == document.body && getComputedStyle(l).position == "static")
+      u = -pageXOffset, c = -pageYOffset;
+    else {
+      let d = l.getBoundingClientRect(), p = d.width / l.offsetWidth, h = d.height / l.offsetHeight;
+      u = d.left - l.scrollLeft * p, c = d.top - l.scrollTop * h;
+    }
+    this.element.style.left = (s.left - u) / o + "px", this.element.style.top = (s.top - c) / a + "px", this.element.style.width = (s.right - s.left) / o + "px", this.element.style.height = (s.bottom - s.top) / a + "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 }), 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, e) : r;
+    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) {
+    this.editorView.dom.contains(e.relatedTarget) || this.setCursor(null);
+  }
+}
+const Pe = E.create({
+  name: "dropCursor",
+  addOptions() {
+    return {
+      color: "currentColor",
+      width: 1,
+      class: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      Se(this.options)
+    ];
+  }
+});
+class f extends S {
+  /**
+  Create a gap cursor.
+  */
+  constructor(e) {
+    super(e, e);
+  }
+  map(e, n) {
+    let s = e.resolve(n.map(this.head));
+    return f.valid(s) ? new f(s) : S.near(s);
+  }
+  content() {
+    return Q.empty;
+  }
+  eq(e) {
+    return e instanceof f && 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 f(e.resolve(n.pos));
+  }
+  /**
+  @internal
+  */
+  getBookmark() {
+    return new W(this.anchor);
+  }
+  /**
+  @internal
+  */
+  static valid(e) {
+    let n = e.parent;
+    if (n.isTextblock || !Oe(e) || !Re(e))
+      return !1;
+    let s = n.type.spec.allowGapCursor;
+    if (s != null)
+      return s;
+    let r = n.contentMatchAt(e.index()).defaultType;
+    return r && r.isTextblock;
+  }
+  /**
+  @internal
+  */
+  static findGapCursorFrom(e, n, s = !1) {
+    e: for (; ; ) {
+      if (!s && f.valid(e))
+        return e;
+      let r = 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;
+        r += n;
+        let l = e.doc.resolve(r);
+        if (f.valid(l))
+          return l;
+      }
+      for (; ; ) {
+        let o = n > 0 ? i.firstChild : i.lastChild;
+        if (!o) {
+          if (i.isAtom && !i.isText && !K.isSelectable(i)) {
+            e = e.doc.resolve(r + i.nodeSize * n), s = !1;
+            continue e;
+          }
+          break;
+        }
+        i = o, r += n;
+        let a = e.doc.resolve(r);
+        if (f.valid(a))
+          return a;
+      }
+      return null;
+    }
+  }
+}
+f.prototype.visible = !1;
+f.findFrom = f.findGapCursorFrom;
+S.jsonID("gapcursor", f);
+class W {
+  constructor(e) {
+    this.pos = e;
+  }
+  map(e) {
+    return new W(e.map(this.pos));
+  }
+  resolve(e) {
+    let n = e.resolve(this.pos);
+    return f.valid(n) ? new f(n) : S.near(n);
+  }
+}
+function ee(t) {
+  return t.isAtom || t.spec.isolating || t.spec.createGapCursor;
+}
+function Oe(t) {
+  for (let e = t.depth; e >= 0; e--) {
+    let n = t.index(e), s = t.node(e);
+    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 || ee(r.type))
+        return !0;
+      if (r.inlineContent)
+        return !1;
+    }
+  }
+  return !0;
+}
+function Re(t) {
+  for (let e = t.depth; e >= 0; e--) {
+    let n = t.indexAfter(e), s = t.node(e);
+    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 || ee(r.type))
+        return !0;
+      if (r.inlineContent)
+        return !1;
+    }
+  }
+  return !0;
+}
+function _e() {
+  return new P({
+    props: {
+      decorations: $e,
+      createSelectionBetween(t, e, n) {
+        return e.pos == n.pos && f.valid(n) ? new f(n) : null;
+      },
+      handleClick: Be,
+      handleKeyDown: Ne,
+      handleDOMEvents: { beforeinput: De }
+    }
+  });
+}
+const Ne = ae({
+  ArrowLeft: O("horiz", -1),
+  ArrowRight: O("horiz", 1),
+  ArrowUp: O("vert", -1),
+  ArrowDown: O("vert", 1)
+});
+function O(t, e) {
+  const n = t == "vert" ? e > 0 ? "down" : "up" : e > 0 ? "right" : "left";
+  return function(s, r, i) {
+    let o = s.selection, a = e > 0 ? o.$to : o.$from, l = o.empty;
+    if (o instanceof L) {
+      if (!i.endOfTextblock(n) || a.depth == 0)
+        return !1;
+      l = !1, a = s.doc.resolve(e > 0 ? a.after() : a.before());
+    }
+    let u = f.findGapCursorFrom(a, e, l);
+    return u ? (r && r(s.tr.setSelection(new f(u))), !0) : !1;
+  };
+}
+function Be(t, e, n) {
+  if (!t || !t.editable)
+    return !1;
+  let s = t.state.doc.resolve(e);
+  if (!f.valid(s))
+    return !1;
+  let r = t.posAtCoords({ left: n.clientX, top: n.clientY });
+  return r && r.inside > -1 && K.isSelectable(t.state.doc.nodeAt(r.inside)) ? !1 : (t.dispatch(t.state.tr.setSelection(new f(s))), !0);
+}
+function De(t, e) {
+  if (e.inputType != "insertCompositionText" || !(t.state.selection instanceof f))
+    return !1;
+  let { $from: n } = t.state.selection, s = n.parent.contentMatchAt(n.index()).findWrapping(t.state.schema.nodes.text);
+  if (!s)
+    return !1;
+  let r = F.empty;
+  for (let o = s.length - 1; o >= 0; o--)
+    r = F.from(s[o].createAndFill(null, r));
+  let i = t.state.tr.replace(n.pos, n.pos, new Q(r, 0, 0));
+  return i.setSelection(L.near(i.doc.resolve(n.pos + 1))), t.dispatch(i), !1;
+}
+function $e(t) {
+  if (!(t.selection instanceof f))
+    return null;
+  let e = document.createElement("div");
+  return e.className = "ProseMirror-gapcursor", Z.create(t.doc, [U.widget(t.selection.head, e, { key: "gapcursor" })]);
+}
+const Ve = E.create({
+  name: "gapCursor",
+  addProseMirrorPlugins() {
+    return [
+      _e()
+    ];
+  },
+  extendNodeSchema(t) {
+    var e;
+    const n = {
+      name: t.name,
+      options: t.options,
+      storage: t.storage
+    };
+    return {
+      allowGapCursor: (e = le(de(t, "allowGapCursor", n))) !== null && e !== void 0 ? e : null
+    };
+  }
+}), ze = M.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", v(this.options.HTMLAttributes, t)];
+  },
+  renderText() {
+    return `
+`;
+  },
+  addCommands() {
+    return {
+      setHardBreak: () => ({ commands: t, chain: e, state: n, editor: s }) => t.first([
+        () => t.exitCode(),
+        () => t.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 e().insertContent({ type: this.name }).command(({ tr: u, dispatch: c }) => {
+            if (c && l && o) {
+              const d = l.filter((p) => a.includes(p.type.name));
+              u.ensureMarks(d);
+            }
+            return !0;
+          }).run();
+        })
+      ])
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Enter": () => this.editor.commands.setHardBreak(),
+      "Shift-Enter": () => this.editor.commands.setHardBreak()
+    };
+  }
+}), Ke = M.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]}`, v(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) => z({
+      find: new RegExp(`^(#{${Math.min(...this.options.levels)},${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 We(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, s) {
+  n === void 0 && (n = 0), s === void 0 && (s = this.length), n <= s ? this.forEachInner(e, n, s, 0) : this.forEachInvertedInner(e, n, s, 0);
+};
+g.prototype.map = function(e, n, s) {
+  n === void 0 && (n = 0), s === void 0 && (s = this.length);
+  var r = [];
+  return this.forEach(function(i, o) {
+    return r.push(e(i, o));
+  }, n, s), r;
+};
+g.from = function(e) {
+  return e instanceof g ? e : e && e.length ? new te(e) : g.empty;
+};
+var te = /* @__PURE__ */ function(t) {
+  function e(s) {
+    t.call(this), this.values = s;
+  }
+  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(r, i) {
+    return r == 0 && i == this.length ? this : new e(this.values.slice(r, i));
+  }, e.prototype.getInner = function(r) {
+    return this.values[r];
+  }, e.prototype.forEachInner = function(r, i, o, a) {
+    for (var l = i; l < o; l++)
+      if (r(this.values[l], a + l) === !1)
+        return !1;
+  }, e.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;
+  }, e.prototype.leafAppend = function(r) {
+    if (this.length + r.length <= _)
+      return new e(this.values.concat(r.flatten()));
+  }, e.prototype.leafPrepend = function(r) {
+    if (this.length + r.length <= _)
+      return new e(r.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 We = /* @__PURE__ */ function(t) {
+  function e(n, s) {
+    t.call(this), this.left = n, this.right = s, this.length = n.length + s.length, this.depth = Math.max(n.depth, s.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(s) {
+    return s < this.left.length ? this.left.get(s) : this.right.get(s - this.left.length);
+  }, e.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;
+  }, e.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;
+  }, e.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));
+  }, e.prototype.leafAppend = function(s) {
+    var r = this.right.leafAppend(s);
+    if (r)
+      return new e(this.left, r);
+  }, e.prototype.leafPrepend = function(s) {
+    var r = this.left.leafPrepend(s);
+    if (r)
+      return new e(r, this.right);
+  }, e.prototype.appendInner = function(s) {
+    return this.left.depth >= Math.max(this.right.depth, s.depth) + 1 ? new e(this.left, new e(this.right, s)) : new e(this, s);
+  }, e;
+}(g);
+const Fe = 500;
+class b {
+  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 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 = e.tr, a, l, u = [], c = [];
+    return this.items.forEach((d, p) => {
+      if (!d.step) {
+        r || (r = this.remapping(s, p + 1), i = r.maps.length), i--, c.push(d);
+        return;
+      }
+      if (r) {
+        c.push(new w(d.map));
+        let h = d.step.map(r.slice(i)), y;
+        h && o.maybeStep(h).doc && (y = o.mapping.maps[o.mapping.maps.length - 1], u.push(new w(y, void 0, void 0, u.length + c.length))), i--, y && r.appendMap(y, i);
+      } else
+        o.maybeStep(d.step);
+      if (d.selection)
+        return a = r ? d.selection.map(r.slice(i)) : d.selection, l = new b(this.items.slice(0, s).append(c.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, s, r) {
+    let i = [], o = this.eventCount, a = this.items, l = !r && a.length ? a.get(a.length - 1) : null;
+    for (let c = 0; c < e.steps.length; c++) {
+      let d = e.steps[c].invert(e.docs[c]), p = new w(e.mapping.maps[c], d, n), h;
+      (h = l && l.merge(p)) && (p = h, c ? i.pop() : a = a.slice(0, a.length - 1)), i.push(p), n && (o++, n = void 0), r || (l = p);
+    }
+    let u = o - s.depth;
+    return u > je && (a = Ge(a, u), o -= u), new b(a.append(i), o);
+  }
+  remapping(e, n) {
+    let s = new ue();
+    return this.items.forEach((r, i) => {
+      let o = r.mirrorOffset != null && i - r.mirrorOffset >= e ? s.maps.length - r.mirrorOffset : void 0;
+      s.appendMap(r.map, o);
+    }, e, n), s;
+  }
+  addMaps(e) {
+    return this.eventCount == 0 ? this : new b(this.items.append(e.map((n) => new w(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 s = [], r = Math.max(0, this.items.length - n), i = e.mapping, o = e.steps.length, a = this.eventCount;
+    this.items.forEach((p) => {
+      p.selection && a--;
+    }, r);
+    let l = n;
+    this.items.forEach((p) => {
+      let h = i.getMirror(--l);
+      if (h == null)
+        return;
+      o = Math.min(o, h);
+      let y = i.maps[h];
+      if (p.step) {
+        let k = e.steps[h].invert(e.docs[h]), A = p.selection && p.selection.map(i.slice(l + 1, h));
+        A && a++, s.push(new w(y, k, A));
+      } else
+        s.push(new w(y));
+    }, r);
+    let u = [];
+    for (let p = n; p < o; p++)
+      u.push(new w(i.maps[p]));
+    let c = this.items.slice(0, r).append(u).append(s), d = new b(c, a);
+    return d.emptyItemCount() > Fe && (d = d.compress(this.items.length - s.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), s = n.maps.length, r = [], i = 0;
+    return this.items.forEach((o, a) => {
+      if (a >= e)
+        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 c = o.selection && o.selection.map(n.slice(s));
+          c && i++;
+          let d = new w(u.invert(), l, c), p, h = r.length - 1;
+          (p = r.length && r[h].merge(d)) ? r[h] = p : r.push(d);
+        }
+      } else o.map && s--;
+    }, this.items.length, 0), new b(g.from(r.reverse()), i);
+  }
+}
+b.empty = new b(g.empty, 0);
+function Ge(t, e) {
+  let n;
+  return t.forEach((s, r) => {
+    if (s.selection && e-- == 0)
+      return n = r, !1;
+  }), t.slice(n);
+}
+class w {
+  constructor(e, n, s, r) {
+    this.map = e, this.step = n, this.selection = s, this.mirrorOffset = r;
+  }
+  merge(e) {
+    if (this.step && e.step && !e.selection) {
+      let n = e.step.merge(this.step);
+      if (n)
+        return new w(n.getMap().invert(), n, this.selection);
+    }
+  }
+}
+class T {
+  constructor(e, n, s, r, i) {
+    this.done = e, this.undone = n, this.prevRanges = s, this.prevTime = r, this.prevComposition = i;
+  }
+}
+const je = 20;
+function qe(t, e, n, s) {
+  let r = n.getMeta(C), i;
+  if (r)
+    return r.historyState;
+  n.getMeta(Je) && (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(C))
+    return o.getMeta(C).redo ? new T(t.done.addTransform(n, void 0, s, R(e)), t.undone, q(n.mapping.maps), t.prevTime, t.prevComposition) : new T(t.done, t.undone.addTransform(n, void 0, s, R(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) - s.newGroupDelay || !Xe(n, t.prevRanges)), u = o ? $(t.prevRanges, n.mapping) : q(n.mapping.maps);
+    return new T(t.done.addTransform(n, l ? e.selection.getBookmark() : void 0, s, R(e)), b.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), $(t.prevRanges, n.mapping), t.prevTime, t.prevComposition) : new T(t.done.addMaps(n.mapping.maps), t.undone.addMaps(n.mapping.maps), $(t.prevRanges, n.mapping), t.prevTime, t.prevComposition);
+}
+function Xe(t, e) {
+  if (!e)
+    return !1;
+  if (!t.docChanged)
+    return !0;
+  let n = !1;
+  return t.mapping.maps[0].forEach((s, r) => {
+    for (let i = 0; i < e.length; i += 2)
+      s <= e[i + 1] && r >= e[i] && (n = !0);
+  }), n;
+}
+function q(t) {
+  let e = [];
+  for (let n = t.length - 1; n >= 0 && e.length == 0; n--)
+    t[n].forEach((s, r, i, o) => e.push(i, o));
+  return e;
+}
+function $(t, e) {
+  if (!t)
+    return null;
+  let n = [];
+  for (let s = 0; s < t.length; s += 2) {
+    let r = e.map(t[s], 1), i = e.map(t[s + 1], -1);
+    r <= i && n.push(r, i);
+  }
+  return n;
+}
+function Ye(t, e, n) {
+  let s = R(e), r = C.get(e).spec.config, i = (n ? t.undone : t.done).popEvent(e, s);
+  if (!i)
+    return null;
+  let o = i.selection.resolve(i.transform.doc), a = (n ? t.done : t.undone).addTransform(i.transform, e.selection.getBookmark(), r, s), l = new T(n ? a : i.remaining, n ? i.remaining : a, null, 0, -1);
+  return i.transform.setSelection(o).setMeta(C, { redo: n, historyState: l });
+}
+let V = !1, X = null;
+function R(t) {
+  let e = t.plugins;
+  if (X != e) {
+    V = !1, X = e;
+    for (let n = 0; n < e.length; n++)
+      if (e[n].spec.historyPreserveItems) {
+        V = !0;
+        break;
+      }
+  }
+  return V;
+}
+const C = new N("history"), Je = new N("closeHistory");
+function Ue(t = {}) {
+  return t = {
+    depth: t.depth || 100,
+    newGroupDelay: t.newGroupDelay || 500
+  }, new P({
+    key: C,
+    state: {
+      init() {
+        return new T(b.empty, b.empty, null, 0, -1);
+      },
+      apply(e, n, s) {
+        return qe(n, s, e, t);
+      }
+    },
+    config: t,
+    props: {
+      handleDOMEvents: {
+        beforeinput(e, n) {
+          let s = n.inputType, r = s == "historyUndo" ? se : s == "historyRedo" ? re : null;
+          return !r || !e.editable ? !1 : (n.preventDefault(), r(e.state, e.dispatch));
+        }
+      }
+    }
+  });
+}
+function ne(t, e) {
+  return (n, s) => {
+    let r = C.getState(n);
+    if (!r || (t ? r.undone : r.done).eventCount == 0)
+      return !1;
+    if (s) {
+      let i = Ye(r, n, t);
+      i && s(e ? i.scrollIntoView() : i);
+    }
+    return !0;
+  };
+}
+const se = ne(!1, !0), re = ne(!0, !0), Ze = E.create({
+  name: "history",
+  addOptions() {
+    return {
+      depth: 100,
+      newGroupDelay: 500
+    };
+  },
+  addCommands() {
+    return {
+      undo: () => ({ state: t, dispatch: e }) => se(t, e),
+      redo: () => ({ state: t, dispatch: e }) => re(t, e)
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      Ue(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()
+    };
+  }
+}), Qe = M.create({
+  name: "horizontalRule",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  group: "block",
+  parseHTML() {
+    return [{ tag: "hr" }];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["hr", v(this.options.HTMLAttributes, t)];
+  },
+  addCommands() {
+    return {
+      setHorizontalRule: () => ({ chain: t, state: e }) => {
+        if (!ce(e, e.schema.nodes[this.name]))
+          return !1;
+        const { selection: n } = e, { $from: s, $to: r } = n, i = t();
+        return s.parentOffset === 0 ? i.insertContentAt({
+          from: Math.max(s.pos - 1, 0),
+          to: r.pos
+        }, {
+          type: this.name
+        }) : he(n) ? i.insertContentAt(r.pos, {
+          type: this.name
+        }) : i.insertContent({ type: this.name }), i.command(({ tr: o, dispatch: a }) => {
+          var l;
+          if (a) {
+            const { $to: u } = o.selection, c = u.end();
+            if (u.nodeAfter)
+              u.nodeAfter.isTextblock ? o.setSelection(L.create(o.doc, u.pos + 1)) : u.nodeAfter.isBlock ? o.setSelection(K.create(o.doc, u.pos)) : o.setSelection(L.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(c, d), o.setSelection(L.create(o.doc, c + 1)));
+            }
+            o.scrollIntoView();
+          }
+          return !0;
+        }).run();
+      }
+    };
+  },
+  addInputRules() {
+    return [
+      pe({
+        find: /^(?:---|—-|___\s|\*\*\*\s)$/,
+        type: this.type
+      })
+    ];
+  }
+}), et = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))$/, tt = /(?:^|\s)(\*(?!\s+\*)((?:[^*]+))\*(?!\s+\*))/g, nt = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))$/, st = /(?:^|\s)(_(?!\s+_)((?:[^_]+))_(?!\s+_))/g, rt = B.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", v(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 [
+      x({
+        find: et,
+        type: this.type
+      }),
+      x({
+        find: nt,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      I({
+        find: tt,
+        type: this.type
+      }),
+      I({
+        find: st,
+        type: this.type
+      })
+    ];
+  }
+}), it = M.create({
+  name: "listItem",
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      bulletListTypeName: "bulletList",
+      orderedListTypeName: "orderedList"
+    };
+  },
+  content: "paragraph block*",
+  defining: !0,
+  parseHTML() {
+    return [
+      {
+        tag: "li"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["li", v(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)
+    };
+  }
+}), ot = "listItem", Y = "textStyle", J = /^(\d+)\.\s$/, at = M.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: null,
+        parseHTML: (t) => t.getAttribute("type")
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "ol"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    const { start: e, ...n } = t;
+    return e === 1 ? ["ol", v(this.options.HTMLAttributes, n), 0] : ["ol", v(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(ot, 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 = H({
+      find: J,
+      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 = H({
+      find: J,
+      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
+    ];
+  }
+}), lt = M.create({
+  name: "paragraph",
+  priority: 1e3,
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  group: "block",
+  content: "inline*",
+  parseHTML() {
+    return [
+      { tag: "p" }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["p", v(this.options.HTMLAttributes, t), 0];
+  },
+  addCommands() {
+    return {
+      setParagraph: () => ({ commands: t }) => t.setNode(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Alt-0": () => this.editor.commands.setParagraph()
+    };
+  }
+}), dt = /(?:^|\s)(~~(?!\s+~~)((?:[^~]+))~~(?!\s+~~))$/, ut = /(?:^|\s)(~~(?!\s+~~)((?:[^~]+))~~(?!\s+~~))/g, pt = B.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", v(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 [
+      x({
+        find: dt,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      I({
+        find: ut,
+        type: this.type
+      })
+    ];
+  }
+}), ct = M.create({
+  name: "text",
+  group: "inline"
+}), mt = E.create({
+  name: "starterKit",
+  addExtensions() {
+    var t, e, n, s, r, i, o, a, l, u, c, d, p, h, y, k, A, D;
+    const m = [];
+    return this.options.bold !== !1 && m.push(Me.configure((t = this.options) === null || t === void 0 ? void 0 : t.bold)), this.options.blockquote !== !1 && m.push(me.configure((e = this.options) === null || e === void 0 ? void 0 : e.blockquote)), this.options.bulletList !== !1 && m.push(we.configure((n = this.options) === null || n === void 0 ? void 0 : n.bulletList)), this.options.code !== !1 && m.push(Ce.configure((s = this.options) === null || s === void 0 ? void 0 : s.code)), this.options.codeBlock !== !1 && m.push(xe.configure((r = this.options) === null || r === void 0 ? void 0 : r.codeBlock)), this.options.document !== !1 && m.push(He.configure((i = this.options) === null || i === void 0 ? void 0 : i.document)), this.options.dropcursor !== !1 && m.push(Pe.configure((o = this.options) === null || o === void 0 ? void 0 : o.dropcursor)), this.options.gapcursor !== !1 && m.push(Ve.configure((a = this.options) === null || a === void 0 ? void 0 : a.gapcursor)), this.options.hardBreak !== !1 && m.push(ze.configure((l = this.options) === null || l === void 0 ? void 0 : l.hardBreak)), this.options.heading !== !1 && m.push(Ke.configure((u = this.options) === null || u === void 0 ? void 0 : u.heading)), this.options.history !== !1 && m.push(Ze.configure((c = this.options) === null || c === void 0 ? void 0 : c.history)), this.options.horizontalRule !== !1 && m.push(Qe.configure((d = this.options) === null || d === void 0 ? void 0 : d.horizontalRule)), this.options.italic !== !1 && m.push(rt.configure((p = this.options) === null || p === void 0 ? void 0 : p.italic)), this.options.listItem !== !1 && m.push(it.configure((h = this.options) === null || h === void 0 ? void 0 : h.listItem)), this.options.orderedList !== !1 && m.push(at.configure((y = this.options) === null || y === void 0 ? void 0 : y.orderedList)), this.options.paragraph !== !1 && m.push(lt.configure((k = this.options) === null || k === void 0 ? void 0 : k.paragraph)), this.options.strike !== !1 && m.push(pt.configure((A = this.options) === null || A === void 0 ? void 0 : A.strike)), this.options.text !== !1 && m.push(ct.configure((D = this.options) === null || D === void 0 ? void 0 : D.text)), m;
+  }
+});
+export {
+  ft as P,
+  mt as S
+};