@dooherceg/tiptap-controlled-editor-with-table 0.0.1

package/dist/components/tiptap-templates/simple/simple-editor.js

@@ -0,0 +1,1956 @@
+import { jsx as p, jsxs as w, Fragment as at } from "react/jsx-runtime";
+import { useEditor as Ct, EditorContext as Lt, EditorContent as wt } from "@tiptap/react";
+import { useState as vt, useRef as q, useEffect as D } from "react";
+import { Mark as Q, markPasteRule as Mt, markInputRule as xt, mergeAttributes as k, Node as L, nodeInputRule as At, ResizableNodeView as It, wrappingInputRule as S, renderNestedMarkdownContent as lt, Extension as C, parseIndentedBlocks as F, isNodeActive as _, isAtStartOfNode as St, isAtEndOfNode as Ht, getNodeType as ut, getNodeAtPosition as Et, textInputRule as y, callOrReturn as dt, getExtensionField as ct, isNodeEmpty as $t, isNodeSelection as Nt, findParentNodeClosestToPos as Rt } from "@tiptap/core";
+import { Plugin as H, PluginKey as E, TextSelection as Pt } from "prosemirror-state";
+import { dropCursor as Bt } from "prosemirror-dropcursor";
+import { DecorationSet as B, Decoration as K } from "prosemirror-view";
+import { gapCursor as Ot } from "prosemirror-gapcursor";
+import { history as Dt, redo as _t, undo as zt } from "prosemirror-history";
+import { StarterKit as Wt } from "@tiptap/starter-kit";
+import { HorizontalRule as jt } from "../../tiptap-node/horizontal-rule-node/horizontal-rule-node-extension.js";
+import { ImageUploadNode as Qt } from "../../tiptap-node/image-upload-node/image-upload-node-extension.js";
+import { ArrowLeftIcon as Kt } from "../../tiptap-icons/arrow-left-icon.js";
+import { HighlighterIcon as Vt } from "../../tiptap-icons/highlighter-icon.js";
+import { LinkIcon as qt } from "../../tiptap-icons/link-icon.js";
+import { useCursorVisibility as Ft } from "../../../hooks/use-cursor-visibility.js";
+import { useIsMobile as Ut } from "../../../hooks/use-mobile.js";
+import { useWindowSize as Gt } from "../../../hooks/use-window-size.js";
+import { handleImageUpload as Xt, MAX_FILE_SIZE as Yt } from "../../../lib/tiptap-utils.js";
+import { InsertTableButton as Zt } from "../../tiptap-ui/insert-table-button/insert-table-button.js";
+import Jt from "../../tiptap-ui/table-actions-toolbar/table-actions-toolbar.js";
+import { useTiptapEditor as te } from "../../../hooks/use-tiptap-editor.js";
+import { columnResizing as ee, tableEditing as re, CellSelection as pt, fixTables as ne, goToNextCell as U, setCellAttr as se, mergeCells as G, splitCell as X, toggleHeaderCell as ie, toggleHeader as Y, deleteTable as oe, deleteRow as ae, addRowAfter as le, addRowBefore as ue, deleteColumn as de, addColumnAfter as ce, addColumnBefore as pe } from "prosemirror-tables";
+import { Toolbar as he, ToolbarGroup as x, ToolbarSeparator as A } from "../../tiptap-ui-primitive/toolbar/toolbar.js";
+import { UndoRedoButton as Z } from "../../tiptap-ui/undo-redo-button/undo-redo-button.js";
+import { HeadingDropdownMenu as fe } from "../../tiptap-ui/heading-dropdown-menu/heading-dropdown-menu.js";
+import { ListDropdownMenu as me } from "../../tiptap-ui/list-dropdown-menu/list-dropdown-menu.js";
+import { BlockquoteButton as ge } from "../../tiptap-ui/blockquote-button/blockquote-button.js";
+import { CodeBlockButton as be } from "../../tiptap-ui/code-block-button/code-block-button.js";
+import { MarkButton as M } from "../../tiptap-ui/mark-button/mark-button.js";
+import { ColorHighlightPopover as ye, ColorHighlightPopoverButton as ke, ColorHighlightPopoverContent as Te } from "../../tiptap-ui/color-highlight-popover/color-highlight-popover.js";
+import { LinkPopover as Ce, LinkButton as Le, LinkContent as we } from "../../tiptap-ui/link-popover/link-popover.js";
+import { TextAlignButton as R } from "../../tiptap-ui/text-align-button/text-align-button.js";
+import { Button as ve } from "../../tiptap-ui-primitive/button/button.js";
+import '../../../assets/simple-editor.css';var Me = /(?:^|\s)(==(?!\s+==)((?:[^=]+))==(?!\s+==))$/, xe = /(?:^|\s)(==(?!\s+==)((?:[^=]+))==(?!\s+==))/g, Ae = Q.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", k(this.options.HTMLAttributes, t), 0];
+  },
+  renderMarkdown: (t, e) => `==${e.renderChildren(t)}==`,
+  parseMarkdown: (t, e) => e.applyMark("highlight", e.parseInline(t.tokens || [])),
+  markdownTokenizer: {
+    name: "highlight",
+    level: "inline",
+    start: (t) => t.indexOf("=="),
+    tokenize(t, e, r) {
+      const s = /^(==)([^=]+)(==)/.exec(t);
+      if (s) {
+        const i = s[2].trim(), a = r.inlineTokens(i);
+        return {
+          type: "highlight",
+          raw: s[0],
+          text: i,
+          tokens: a
+        };
+      }
+    }
+  },
+  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 [
+      xt({
+        find: Me,
+        type: this.type
+      })
+    ];
+  },
+  addPasteRules() {
+    return [
+      Mt({
+        find: xe,
+        type: this.type
+      })
+    ];
+  }
+}), Ie = /(?:^|\s)(!\[(.+|:?)]\((\S+)(?:(?:\s+)["'](\S+)["'])?\))$/, Se = L.create({
+  name: "image",
+  addOptions() {
+    return {
+      inline: !1,
+      allowBase64: !1,
+      HTMLAttributes: {},
+      resize: !1
+    };
+  },
+  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
+      },
+      width: {
+        default: null
+      },
+      height: {
+        default: null
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: this.options.allowBase64 ? "img[src]" : 'img[src]:not([src^="data:"])'
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["img", k(this.options.HTMLAttributes, t)];
+  },
+  parseMarkdown: (t, e) => e.createNode("image", {
+    src: t.href,
+    title: t.title,
+    alt: t.text
+  }),
+  renderMarkdown: (t) => {
+    var e, r, n, s, i, a;
+    const o = (r = (e = t.attrs) == null ? void 0 : e.src) != null ? r : "", c = (s = (n = t.attrs) == null ? void 0 : n.alt) != null ? s : "", l = (a = (i = t.attrs) == null ? void 0 : i.title) != null ? a : "";
+    return l ? `![${c}](${o} "${l}")` : `![${c}](${o})`;
+  },
+  addNodeView() {
+    if (!this.options.resize || !this.options.resize.enabled || typeof document > "u" || !this.editor.isEditable)
+      return null;
+    const { directions: t, minWidth: e, minHeight: r, alwaysPreserveAspectRatio: n } = this.options.resize;
+    return ({ node: s, getPos: i, HTMLAttributes: a }) => {
+      const o = document.createElement("img");
+      Object.entries(a).forEach(([d, u]) => {
+        if (u != null)
+          switch (d) {
+            case "width":
+            case "height":
+              break;
+            default:
+              o.setAttribute(d, u);
+              break;
+          }
+      }), o.src = a.src;
+      const c = new It({
+        element: o,
+        node: s,
+        getPos: i,
+        onResize: (d, u) => {
+          o.style.width = `${d}px`, o.style.height = `${u}px`;
+        },
+        onCommit: (d, u) => {
+          const h = i();
+          h !== void 0 && this.editor.chain().setNodeSelection(h).updateAttributes(this.name, {
+            width: d,
+            height: u
+          }).run();
+        },
+        onUpdate: (d, u, h) => d.type === s.type,
+        options: {
+          directions: t,
+          min: {
+            width: e,
+            height: r
+          },
+          preserveAspectRatio: n === !0
+        }
+      }), l = c.dom;
+      return l.style.visibility = "hidden", l.style.pointerEvents = "none", o.onload = () => {
+        l.style.visibility = "", l.style.pointerEvents = "";
+      }, c;
+    };
+  },
+  addCommands() {
+    return {
+      setImage: (t) => ({ commands: e }) => e.insertContent({
+        type: this.name,
+        attrs: t
+      })
+    };
+  },
+  addInputRules() {
+    return [
+      At({
+        find: Ie,
+        type: this.type,
+        getAttributes: (t) => {
+          const [, , e, r, n] = t;
+          return { src: r, alt: e, title: n };
+        }
+      })
+    ];
+  }
+}), He = Object.defineProperty, Ee = (t, e) => {
+  for (var r in e)
+    He(t, r, { get: e[r], enumerable: !0 });
+}, $e = "listItem", J = "textStyle", tt = /^\s*([-+*])\s$/, Ne = L.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", k(this.options.HTMLAttributes, t), 0];
+  },
+  markdownTokenName: "list",
+  parseMarkdown: (t, e) => t.type !== "list" || t.ordered ? [] : {
+    type: "bulletList",
+    content: t.items ? e.parseChildren(t.items) : []
+  },
+  renderMarkdown: (t, e) => t.content ? e.renderChildren(t.content, `
+`) : "",
+  markdownOptions: {
+    indentsContent: !0
+  },
+  addCommands() {
+    return {
+      toggleBulletList: () => ({ commands: t, chain: e }) => this.options.keepAttributes ? e().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes($e, this.editor.getAttributes(J)).run() : t.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-8": () => this.editor.commands.toggleBulletList()
+    };
+  },
+  addInputRules() {
+    let t = S({
+      find: tt,
+      type: this.type
+    });
+    return (this.options.keepMarks || this.options.keepAttributes) && (t = S({
+      find: tt,
+      type: this.type,
+      keepMarks: this.options.keepMarks,
+      keepAttributes: this.options.keepAttributes,
+      getAttributes: () => this.editor.getAttributes(J),
+      editor: this.editor
+    })), [t];
+  }
+}), Re = L.create({
+  name: "listItem",
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      bulletListTypeName: "bulletList",
+      orderedListTypeName: "orderedList"
+    };
+  },
+  content: "paragraph block*",
+  defining: !0,
+  parseHTML() {
+    return [
+      {
+        tag: "li"
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["li", k(this.options.HTMLAttributes, t), 0];
+  },
+  markdownTokenName: "list_item",
+  parseMarkdown: (t, e) => {
+    if (t.type !== "list_item")
+      return [];
+    let r = [];
+    if (t.tokens && t.tokens.length > 0)
+      if (t.tokens.some((s) => s.type === "paragraph"))
+        r = e.parseChildren(t.tokens);
+      else {
+        const s = t.tokens[0];
+        if (s && s.type === "text" && s.tokens && s.tokens.length > 0) {
+          if (r = [
+            {
+              type: "paragraph",
+              content: e.parseInline(s.tokens)
+            }
+          ], t.tokens.length > 1) {
+            const a = t.tokens.slice(1), o = e.parseChildren(a);
+            r.push(...o);
+          }
+        } else
+          r = e.parseChildren(t.tokens);
+      }
+    return r.length === 0 && (r = [
+      {
+        type: "paragraph",
+        content: []
+      }
+    ]), {
+      type: "listItem",
+      content: r
+    };
+  },
+  renderMarkdown: (t, e, r) => lt(
+    t,
+    e,
+    (n) => n.parentType === "bulletList" ? "- " : n.parentType === "orderedList" ? `${n.index + 1}. ` : "- ",
+    r
+  ),
+  addKeyboardShortcuts() {
+    return {
+      Enter: () => this.editor.commands.splitListItem(this.name),
+      Tab: () => this.editor.commands.sinkListItem(this.name),
+      "Shift-Tab": () => this.editor.commands.liftListItem(this.name)
+    };
+  }
+}), Pe = {};
+Ee(Pe, {
+  findListItemPos: () => $,
+  getNextListDepth: () => V,
+  handleBackspace: () => z,
+  handleDelete: () => W,
+  hasListBefore: () => ht,
+  hasListItemAfter: () => Be,
+  hasListItemBefore: () => ft,
+  listItemHasSubList: () => mt,
+  nextListIsDeeper: () => gt,
+  nextListIsHigher: () => bt
+});
+var $ = (t, e) => {
+  const { $from: r } = e.selection, n = ut(t, e.schema);
+  let s = null, i = r.depth, a = r.pos, o = null;
+  for (; i > 0 && o === null; )
+    s = r.node(i), s.type === n ? o = i : (i -= 1, a -= 1);
+  return o === null ? null : { $pos: e.doc.resolve(a), depth: o };
+}, V = (t, e) => {
+  const r = $(t, e);
+  if (!r)
+    return !1;
+  const [, n] = Et(e, t, r.$pos.pos + 4);
+  return n;
+}, ht = (t, e, r) => {
+  const { $anchor: n } = t.selection, s = Math.max(0, n.pos - 2), i = t.doc.resolve(s).node();
+  return !(!i || !r.includes(i.type.name));
+}, ft = (t, e) => {
+  var r;
+  const { $anchor: n } = e.selection, s = e.doc.resolve(n.pos - 2);
+  return !(s.index() === 0 || ((r = s.nodeBefore) == null ? void 0 : r.type.name) !== t);
+}, mt = (t, e, r) => {
+  if (!r)
+    return !1;
+  const n = ut(t, e.schema);
+  let s = !1;
+  return r.descendants((i) => {
+    i.type === n && (s = !0);
+  }), s;
+}, z = (t, e, r) => {
+  if (t.commands.undoInputRule())
+    return !0;
+  if (t.state.selection.from !== t.state.selection.to)
+    return !1;
+  if (!_(t.state, e) && ht(t.state, e, r)) {
+    const { $anchor: o } = t.state.selection, c = t.state.doc.resolve(o.before() - 1), l = [];
+    c.node().descendants((h, b) => {
+      h.type.name === e && l.push({ node: h, pos: b });
+    });
+    const d = l.at(-1);
+    if (!d)
+      return !1;
+    const u = t.state.doc.resolve(c.start() + d.pos + 1);
+    return t.chain().cut({ from: o.start() - 1, to: o.end() + 1 }, u.end()).joinForward().run();
+  }
+  if (!_(t.state, e) || !St(t.state))
+    return !1;
+  const n = $(e, t.state);
+  if (!n)
+    return !1;
+  const i = t.state.doc.resolve(n.$pos.pos - 2).node(n.depth), a = mt(e, t.state, i);
+  return ft(e, t.state) && !a ? t.commands.joinItemBackward() : t.chain().liftListItem(e).run();
+}, gt = (t, e) => {
+  const r = V(t, e), n = $(t, e);
+  return !n || !r ? !1 : r > n.depth;
+}, bt = (t, e) => {
+  const r = V(t, e), n = $(t, e);
+  return !n || !r ? !1 : r < n.depth;
+}, W = (t, e) => {
+  if (!_(t.state, e) || !Ht(t.state, e))
+    return !1;
+  const { selection: r } = t.state, { $from: n, $to: s } = r;
+  return !r.empty && n.sameParent(s) ? !1 : gt(e, t.state) ? t.chain().focus(t.state.selection.from + 4).lift(e).joinBackward().run() : bt(e, t.state) ? t.chain().joinForward().joinBackward().run() : t.commands.joinItemForward();
+}, Be = (t, e) => {
+  var r;
+  const { $anchor: n } = e.selection, s = e.doc.resolve(n.pos - n.parentOffset - 2);
+  return !(s.index() === s.parent.childCount - 1 || ((r = s.nodeAfter) == null ? void 0 : r.type.name) !== t);
+}, Oe = C.create({
+  name: "listKeymap",
+  addOptions() {
+    return {
+      listTypes: [
+        {
+          itemName: "listItem",
+          wrapperNames: ["bulletList", "orderedList"]
+        },
+        {
+          itemName: "taskItem",
+          wrapperNames: ["taskList"]
+        }
+      ]
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      Delete: ({ editor: t }) => {
+        let e = !1;
+        return this.options.listTypes.forEach(({ itemName: r }) => {
+          t.state.schema.nodes[r] !== void 0 && W(t, r) && (e = !0);
+        }), e;
+      },
+      "Mod-Delete": ({ editor: t }) => {
+        let e = !1;
+        return this.options.listTypes.forEach(({ itemName: r }) => {
+          t.state.schema.nodes[r] !== void 0 && W(t, r) && (e = !0);
+        }), e;
+      },
+      Backspace: ({ editor: t }) => {
+        let e = !1;
+        return this.options.listTypes.forEach(({ itemName: r, wrapperNames: n }) => {
+          t.state.schema.nodes[r] !== void 0 && z(t, r, n) && (e = !0);
+        }), e;
+      },
+      "Mod-Backspace": ({ editor: t }) => {
+        let e = !1;
+        return this.options.listTypes.forEach(({ itemName: r, wrapperNames: n }) => {
+          t.state.schema.nodes[r] !== void 0 && z(t, r, n) && (e = !0);
+        }), e;
+      }
+    };
+  }
+}), et = /^(\s*)(\d+)\.\s+(.*)$/, De = /^\s/;
+function _e(t) {
+  const e = [];
+  let r = 0, n = 0;
+  for (; r < t.length; ) {
+    const s = t[r], i = s.match(et);
+    if (!i)
+      break;
+    const [, a, o, c] = i, l = a.length;
+    let d = c, u = r + 1;
+    const h = [s];
+    for (; u < t.length; ) {
+      const b = t[u];
+      if (b.match(et))
+        break;
+      if (b.trim() === "")
+        h.push(b), d += `
+`, u += 1;
+      else if (b.match(De))
+        h.push(b), d += `
+${b.slice(l + 2)}`, u += 1;
+      else
+        break;
+    }
+    e.push({
+      indent: l,
+      number: parseInt(o, 10),
+      content: d.trim(),
+      raw: h.join(`
+`)
+    }), n = u, r = u;
+  }
+  return [e, n];
+}
+function yt(t, e, r) {
+  var n;
+  const s = [];
+  let i = 0;
+  for (; i < t.length; ) {
+    const a = t[i];
+    if (a.indent === e) {
+      const o = a.content.split(`
+`), c = ((n = o[0]) == null ? void 0 : n.trim()) || "", l = [];
+      c && l.push({
+        type: "paragraph",
+        raw: c,
+        tokens: r.inlineTokens(c)
+      });
+      const d = o.slice(1).join(`
+`).trim();
+      if (d) {
+        const b = r.blockTokens(d);
+        l.push(...b);
+      }
+      let u = i + 1;
+      const h = [];
+      for (; u < t.length && t[u].indent > e; )
+        h.push(t[u]), u += 1;
+      if (h.length > 0) {
+        const b = Math.min(...h.map((g) => g.indent)), f = yt(h, b, r);
+        l.push({
+          type: "list",
+          ordered: !0,
+          start: h[0].number,
+          items: f,
+          raw: h.map((g) => g.raw).join(`
+`)
+        });
+      }
+      s.push({
+        type: "list_item",
+        raw: a.raw,
+        tokens: l
+      }), i = u;
+    } else
+      i += 1;
+  }
+  return s;
+}
+function ze(t, e) {
+  return t.map((r) => {
+    if (r.type !== "list_item")
+      return e.parseChildren([r])[0];
+    const n = [];
+    return r.tokens && r.tokens.length > 0 && r.tokens.forEach((s) => {
+      if (s.type === "paragraph" || s.type === "list" || s.type === "blockquote" || s.type === "code")
+        n.push(...e.parseChildren([s]));
+      else if (s.type === "text" && s.tokens) {
+        const i = e.parseChildren([s]);
+        n.push({
+          type: "paragraph",
+          content: i
+        });
+      } else {
+        const i = e.parseChildren([s]);
+        i.length > 0 && n.push(...i);
+      }
+    }), {
+      type: "listItem",
+      content: n
+    };
+  });
+}
+var We = "listItem", rt = "textStyle", nt = /^(\d+)\.\s$/, je = L.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, ...r } = t;
+    return e === 1 ? ["ol", k(this.options.HTMLAttributes, r), 0] : ["ol", k(this.options.HTMLAttributes, t), 0];
+  },
+  markdownTokenName: "list",
+  parseMarkdown: (t, e) => {
+    if (t.type !== "list" || !t.ordered)
+      return [];
+    const r = t.start || 1, n = t.items ? ze(t.items, e) : [];
+    return r !== 1 ? {
+      type: "orderedList",
+      attrs: { start: r },
+      content: n
+    } : {
+      type: "orderedList",
+      content: n
+    };
+  },
+  renderMarkdown: (t, e) => t.content ? e.renderChildren(t.content, `
+`) : "",
+  markdownTokenizer: {
+    name: "orderedList",
+    level: "block",
+    start: (t) => {
+      const e = t.match(/^(\s*)(\d+)\.\s+/), r = e?.index;
+      return r !== void 0 ? r : -1;
+    },
+    tokenize: (t, e, r) => {
+      var n;
+      const s = t.split(`
+`), [i, a] = _e(s);
+      if (i.length === 0)
+        return;
+      const o = yt(i, 0, r);
+      return o.length === 0 ? void 0 : {
+        type: "list",
+        ordered: !0,
+        start: ((n = i[0]) == null ? void 0 : n.number) || 1,
+        items: o,
+        raw: s.slice(0, a).join(`
+`)
+      };
+    }
+  },
+  markdownOptions: {
+    indentsContent: !0
+  },
+  addCommands() {
+    return {
+      toggleOrderedList: () => ({ commands: t, chain: e }) => this.options.keepAttributes ? e().toggleList(this.name, this.options.itemTypeName, this.options.keepMarks).updateAttributes(We, this.editor.getAttributes(rt)).run() : t.toggleList(this.name, this.options.itemTypeName, this.options.keepMarks)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-7": () => this.editor.commands.toggleOrderedList()
+    };
+  },
+  addInputRules() {
+    let t = S({
+      find: nt,
+      type: this.type,
+      getAttributes: (e) => ({ start: +e[1] }),
+      joinPredicate: (e, r) => r.childCount + r.attrs.start === +e[1]
+    });
+    return (this.options.keepMarks || this.options.keepAttributes) && (t = S({
+      find: nt,
+      type: this.type,
+      keepMarks: this.options.keepMarks,
+      keepAttributes: this.options.keepAttributes,
+      getAttributes: (e) => ({ start: +e[1], ...this.editor.getAttributes(rt) }),
+      joinPredicate: (e, r) => r.childCount + r.attrs.start === +e[1],
+      editor: this.editor
+    })), [t];
+  }
+}), Qe = /^\s*(\[([( |x])?\])\s$/, kt = L.create({
+  name: "taskItem",
+  addOptions() {
+    return {
+      nested: !1,
+      HTMLAttributes: {},
+      taskListTypeName: "taskList",
+      a11y: void 0
+    };
+  },
+  content() {
+    return this.options.nested ? "paragraph block*" : "paragraph+";
+  },
+  defining: !0,
+  addAttributes() {
+    return {
+      checked: {
+        default: !1,
+        keepOnSplit: !1,
+        parseHTML: (t) => {
+          const e = t.getAttribute("data-checked");
+          return e === "" || e === "true";
+        },
+        renderHTML: (t) => ({
+          "data-checked": t.checked
+        })
+      }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: `li[data-type="${this.name}"]`,
+        priority: 51
+      }
+    ];
+  },
+  renderHTML({ node: t, HTMLAttributes: e }) {
+    return [
+      "li",
+      k(this.options.HTMLAttributes, e, {
+        "data-type": this.name
+      }),
+      [
+        "label",
+        [
+          "input",
+          {
+            type: "checkbox",
+            checked: t.attrs.checked ? "checked" : null
+          }
+        ],
+        ["span"]
+      ],
+      ["div", 0]
+    ];
+  },
+  parseMarkdown: (t, e) => {
+    const r = [];
+    if (t.tokens && t.tokens.length > 0 ? r.push(e.createNode("paragraph", {}, e.parseInline(t.tokens))) : t.text ? r.push(e.createNode("paragraph", {}, [e.createNode("text", { text: t.text })])) : r.push(e.createNode("paragraph", {}, [])), t.nestedTokens && t.nestedTokens.length > 0) {
+      const n = e.parseChildren(t.nestedTokens);
+      r.push(...n);
+    }
+    return e.createNode("taskItem", { checked: t.checked || !1 }, r);
+  },
+  renderMarkdown: (t, e) => {
+    var r;
+    const s = `- [${(r = t.attrs) != null && r.checked ? "x" : " "}] `;
+    return lt(t, e, s);
+  },
+  addKeyboardShortcuts() {
+    const t = {
+      Enter: () => this.editor.commands.splitListItem(this.name),
+      "Shift-Tab": () => this.editor.commands.liftListItem(this.name)
+    };
+    return this.options.nested ? {
+      ...t,
+      Tab: () => this.editor.commands.sinkListItem(this.name)
+    } : t;
+  },
+  addNodeView() {
+    return ({ node: t, HTMLAttributes: e, getPos: r, editor: n }) => {
+      const s = document.createElement("li"), i = document.createElement("label"), a = document.createElement("span"), o = document.createElement("input"), c = document.createElement("div"), l = (d) => {
+        var u, h;
+        o.ariaLabel = ((h = (u = this.options.a11y) == null ? void 0 : u.checkboxLabel) == null ? void 0 : h.call(u, d, o.checked)) || `Task item checkbox for ${d.textContent || "empty task item"}`;
+      };
+      return l(t), i.contentEditable = "false", o.type = "checkbox", o.addEventListener("mousedown", (d) => d.preventDefault()), o.addEventListener("change", (d) => {
+        if (!n.isEditable && !this.options.onReadOnlyChecked) {
+          o.checked = !o.checked;
+          return;
+        }
+        const { checked: u } = d.target;
+        n.isEditable && typeof r == "function" && n.chain().focus(void 0, { scrollIntoView: !1 }).command(({ tr: h }) => {
+          const b = r();
+          if (typeof b != "number")
+            return !1;
+          const f = h.doc.nodeAt(b);
+          return h.setNodeMarkup(b, void 0, {
+            ...f?.attrs,
+            checked: u
+          }), !0;
+        }).run(), !n.isEditable && this.options.onReadOnlyChecked && (this.options.onReadOnlyChecked(t, u) || (o.checked = !o.checked));
+      }), Object.entries(this.options.HTMLAttributes).forEach(([d, u]) => {
+        s.setAttribute(d, u);
+      }), s.dataset.checked = t.attrs.checked, o.checked = t.attrs.checked, i.append(o, a), s.append(i, c), Object.entries(e).forEach(([d, u]) => {
+        s.setAttribute(d, u);
+      }), {
+        dom: s,
+        contentDOM: c,
+        update: (d) => d.type !== this.type ? !1 : (s.dataset.checked = d.attrs.checked, o.checked = d.attrs.checked, l(d), !0)
+      };
+    };
+  },
+  addInputRules() {
+    return [
+      S({
+        find: Qe,
+        type: this.type,
+        getAttributes: (t) => ({
+          checked: t[t.length - 1] === "x"
+        })
+      })
+    ];
+  }
+}), Tt = L.create({
+  name: "taskList",
+  addOptions() {
+    return {
+      itemTypeName: "taskItem",
+      HTMLAttributes: {}
+    };
+  },
+  group: "block list",
+  content() {
+    return `${this.options.itemTypeName}+`;
+  },
+  parseHTML() {
+    return [
+      {
+        tag: `ul[data-type="${this.name}"]`,
+        priority: 51
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["ul", k(this.options.HTMLAttributes, t, { "data-type": this.name }), 0];
+  },
+  parseMarkdown: (t, e) => e.createNode("taskList", {}, e.parseChildren(t.items || [])),
+  renderMarkdown: (t, e) => t.content ? e.renderChildren(t.content, `
+`) : "",
+  markdownTokenizer: {
+    name: "taskList",
+    level: "block",
+    start(t) {
+      var e;
+      const r = (e = t.match(/^\s*[-+*]\s+\[([ xX])\]\s+/)) == null ? void 0 : e.index;
+      return r !== void 0 ? r : -1;
+    },
+    tokenize(t, e, r) {
+      const n = (i) => {
+        const a = F(
+          i,
+          {
+            itemPattern: /^(\s*)([-+*])\s+\[([ xX])\]\s+(.*)$/,
+            extractItemData: (o) => ({
+              indentLevel: o[1].length,
+              mainContent: o[4],
+              checked: o[3].toLowerCase() === "x"
+            }),
+            createToken: (o, c) => ({
+              type: "taskItem",
+              raw: "",
+              mainContent: o.mainContent,
+              indentLevel: o.indentLevel,
+              checked: o.checked,
+              text: o.mainContent,
+              tokens: r.inlineTokens(o.mainContent),
+              nestedTokens: c
+            }),
+            // Allow recursive nesting
+            customNestedParser: n
+          },
+          r
+        );
+        return a ? [
+          {
+            type: "taskList",
+            raw: a.raw,
+            items: a.items
+          }
+        ] : r.blockTokens(i);
+      }, s = F(
+        t,
+        {
+          itemPattern: /^(\s*)([-+*])\s+\[([ xX])\]\s+(.*)$/,
+          extractItemData: (i) => ({
+            indentLevel: i[1].length,
+            mainContent: i[4],
+            checked: i[3].toLowerCase() === "x"
+          }),
+          createToken: (i, a) => ({
+            type: "taskItem",
+            raw: "",
+            mainContent: i.mainContent,
+            indentLevel: i.indentLevel,
+            checked: i.checked,
+            text: i.mainContent,
+            tokens: r.inlineTokens(i.mainContent),
+            nestedTokens: a
+          }),
+          // Use the recursive parser for nested content
+          customNestedParser: n
+        },
+        r
+      );
+      if (s)
+        return {
+          type: "taskList",
+          raw: s.raw,
+          items: s.items
+        };
+    }
+  },
+  markdownOptions: {
+    indentsContent: !0
+  },
+  addCommands() {
+    return {
+      toggleTaskList: () => ({ commands: t }) => t.toggleList(this.name, this.options.itemTypeName)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-9": () => this.editor.commands.toggleTaskList()
+    };
+  }
+});
+C.create({
+  name: "listKit",
+  addExtensions() {
+    const t = [];
+    return this.options.bulletList !== !1 && t.push(Ne.configure(this.options.bulletList)), this.options.listItem !== !1 && t.push(Re.configure(this.options.listItem)), this.options.listKeymap !== !1 && t.push(Oe.configure(this.options.listKeymap)), this.options.orderedList !== !1 && t.push(je.configure(this.options.orderedList)), this.options.taskItem !== !1 && t.push(kt.configure(this.options.taskItem)), this.options.taskList !== !1 && t.push(Tt.configure(this.options.taskList)), t;
+  }
+});
+var Ke = Q.create({
+  name: "subscript",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "sub"
+      },
+      {
+        style: "vertical-align",
+        getAttrs(t) {
+          return t !== "sub" ? !1 : null;
+        }
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["sub", k(this.options.HTMLAttributes, t), 0];
+  },
+  addCommands() {
+    return {
+      setSubscript: () => ({ commands: t }) => t.setMark(this.name),
+      toggleSubscript: () => ({ commands: t }) => t.toggleMark(this.name),
+      unsetSubscript: () => ({ commands: t }) => t.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-,": () => this.editor.commands.toggleSubscript()
+    };
+  }
+}), Ve = Q.create({
+  name: "superscript",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "sup"
+      },
+      {
+        style: "vertical-align",
+        getAttrs(t) {
+          return t !== "super" ? !1 : null;
+        }
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["sup", k(this.options.HTMLAttributes, t), 0];
+  },
+  addCommands() {
+    return {
+      setSuperscript: () => ({ commands: t }) => t.setMark(this.name),
+      toggleSuperscript: () => ({ commands: t }) => t.toggleMark(this.name),
+      unsetSuperscript: () => ({ commands: t }) => t.unsetMark(this.name)
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-.": () => this.editor.commands.toggleSuperscript()
+    };
+  }
+}), qe = C.create({
+  name: "textAlign",
+  addOptions() {
+    return {
+      types: [],
+      alignments: ["left", "center", "right", "justify"],
+      defaultAlignment: null
+    };
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          textAlign: {
+            default: this.options.defaultAlignment,
+            parseHTML: (t) => {
+              const e = t.style.textAlign;
+              return this.options.alignments.includes(e) ? e : this.options.defaultAlignment;
+            },
+            renderHTML: (t) => t.textAlign ? { style: `text-align: ${t.textAlign}` } : {}
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    return {
+      setTextAlign: (t) => ({ commands: e }) => this.options.alignments.includes(t) ? this.options.types.map((r) => e.updateAttributes(r, { textAlign: t })).every((r) => r) : !1,
+      unsetTextAlign: () => ({ commands: t }) => this.options.types.map((e) => t.resetAttributes(e, "textAlign")).every((e) => e),
+      toggleTextAlign: (t) => ({ editor: e, commands: r }) => this.options.alignments.includes(t) ? e.isActive({ textAlign: t }) ? r.unsetTextAlign() : r.setTextAlign(t) : !1
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      "Mod-Shift-l": () => this.editor.commands.setTextAlign("left"),
+      "Mod-Shift-e": () => this.editor.commands.setTextAlign("center"),
+      "Mod-Shift-r": () => this.editor.commands.setTextAlign("right"),
+      "Mod-Shift-j": () => this.editor.commands.setTextAlign("justify")
+    };
+  }
+}), Fe = (t) => y({
+  find: /--$/,
+  replace: t ?? "—"
+}), Ue = (t) => y({
+  find: /\.\.\.$/,
+  replace: t ?? "…"
+}), Ge = (t) => y({
+  find: /(?:^|[\s{[(<'"\u2018\u201C])(")$/,
+  replace: t ?? "“"
+}), Xe = (t) => y({
+  find: /"$/,
+  replace: t ?? "”"
+}), Ye = (t) => y({
+  find: /(?:^|[\s{[(<'"\u2018\u201C])(')$/,
+  replace: t ?? "‘"
+}), Ze = (t) => y({
+  find: /'$/,
+  replace: t ?? "’"
+}), Je = (t) => y({
+  find: /<-$/,
+  replace: t ?? "←"
+}), tr = (t) => y({
+  find: /->$/,
+  replace: t ?? "→"
+}), er = (t) => y({
+  find: /\(c\)$/,
+  replace: t ?? "©"
+}), rr = (t) => y({
+  find: /\(tm\)$/,
+  replace: t ?? "™"
+}), nr = (t) => y({
+  find: /\(sm\)$/,
+  replace: t ?? "℠"
+}), sr = (t) => y({
+  find: /\(r\)$/,
+  replace: t ?? "®"
+}), ir = (t) => y({
+  find: /(?:^|\s)(1\/2)\s$/,
+  replace: t ?? "½"
+}), or = (t) => y({
+  find: /\+\/-$/,
+  replace: t ?? "±"
+}), ar = (t) => y({
+  find: /!=$/,
+  replace: t ?? "≠"
+}), lr = (t) => y({
+  find: /<<$/,
+  replace: t ?? "«"
+}), ur = (t) => y({
+  find: />>$/,
+  replace: t ?? "»"
+}), dr = (t) => y({
+  find: /\d+\s?([*x])\s?\d+$/,
+  replace: t ?? "×"
+}), cr = (t) => y({
+  find: /\^2$/,
+  replace: t ?? "²"
+}), pr = (t) => y({
+  find: /\^3$/,
+  replace: t ?? "³"
+}), hr = (t) => y({
+  find: /(?:^|\s)(1\/4)\s$/,
+  replace: t ?? "¼"
+}), fr = (t) => y({
+  find: /(?:^|\s)(3\/4)\s$/,
+  replace: t ?? "¾"
+}), mr = C.create({
+  name: "typography",
+  addOptions() {
+    return {
+      closeDoubleQuote: "”",
+      closeSingleQuote: "’",
+      copyright: "©",
+      ellipsis: "…",
+      emDash: "—",
+      laquo: "«",
+      leftArrow: "←",
+      multiplication: "×",
+      notEqual: "≠",
+      oneHalf: "½",
+      oneQuarter: "¼",
+      openDoubleQuote: "“",
+      openSingleQuote: "‘",
+      plusMinus: "±",
+      raquo: "»",
+      registeredTrademark: "®",
+      rightArrow: "→",
+      servicemark: "℠",
+      superscriptThree: "³",
+      superscriptTwo: "²",
+      threeQuarters: "¾",
+      trademark: "™"
+    };
+  },
+  addInputRules() {
+    const t = [];
+    return this.options.emDash !== !1 && t.push(Fe(this.options.emDash)), this.options.ellipsis !== !1 && t.push(Ue(this.options.ellipsis)), this.options.openDoubleQuote !== !1 && t.push(Ge(this.options.openDoubleQuote)), this.options.closeDoubleQuote !== !1 && t.push(Xe(this.options.closeDoubleQuote)), this.options.openSingleQuote !== !1 && t.push(Ye(this.options.openSingleQuote)), this.options.closeSingleQuote !== !1 && t.push(Ze(this.options.closeSingleQuote)), this.options.leftArrow !== !1 && t.push(Je(this.options.leftArrow)), this.options.rightArrow !== !1 && t.push(tr(this.options.rightArrow)), this.options.copyright !== !1 && t.push(er(this.options.copyright)), this.options.trademark !== !1 && t.push(rr(this.options.trademark)), this.options.servicemark !== !1 && t.push(nr(this.options.servicemark)), this.options.registeredTrademark !== !1 && t.push(sr(this.options.registeredTrademark)), this.options.oneHalf !== !1 && t.push(ir(this.options.oneHalf)), this.options.plusMinus !== !1 && t.push(or(this.options.plusMinus)), this.options.notEqual !== !1 && t.push(ar(this.options.notEqual)), this.options.laquo !== !1 && t.push(lr(this.options.laquo)), this.options.raquo !== !1 && t.push(ur(this.options.raquo)), this.options.multiplication !== !1 && t.push(dr(this.options.multiplication)), this.options.superscriptTwo !== !1 && t.push(cr(this.options.superscriptTwo)), this.options.superscriptThree !== !1 && t.push(pr(this.options.superscriptThree)), this.options.oneQuarter !== !1 && t.push(hr(this.options.oneQuarter)), this.options.threeQuarters !== !1 && t.push(fr(this.options.threeQuarters)), t;
+  }
+});
+C.create({
+  name: "characterCount",
+  addOptions() {
+    return {
+      limit: null,
+      mode: "textSize",
+      textCounter: (t) => t.length,
+      wordCounter: (t) => t.split(" ").filter((e) => e !== "").length
+    };
+  },
+  addStorage() {
+    return {
+      characters: () => 0,
+      words: () => 0
+    };
+  },
+  onBeforeCreate() {
+    this.storage.characters = (t) => {
+      const e = t?.node || this.editor.state.doc;
+      if ((t?.mode || this.options.mode) === "textSize") {
+        const n = e.textBetween(0, e.content.size, void 0, " ");
+        return this.options.textCounter(n);
+      }
+      return e.nodeSize;
+    }, this.storage.words = (t) => {
+      const e = t?.node || this.editor.state.doc, r = e.textBetween(0, e.content.size, " ", " ");
+      return this.options.wordCounter(r);
+    };
+  },
+  addProseMirrorPlugins() {
+    let t = !1;
+    return [
+      new H({
+        key: new E("characterCount"),
+        appendTransaction: (e, r, n) => {
+          if (t)
+            return;
+          const s = this.options.limit;
+          if (s == null || s === 0) {
+            t = !0;
+            return;
+          }
+          const i = this.storage.characters({ node: n.doc });
+          if (i > s) {
+            const a = i - s, o = 0, c = a;
+            console.warn(
+              `[CharacterCount] Initial content exceeded limit of ${s} characters. Content was automatically trimmed.`
+            );
+            const l = n.tr.deleteRange(o, c);
+            return t = !0, l;
+          }
+          t = !0;
+        },
+        filterTransaction: (e, r) => {
+          const n = this.options.limit;
+          if (!e.docChanged || n === 0 || n === null || n === void 0)
+            return !0;
+          const s = this.storage.characters({ node: r.doc }), i = this.storage.characters({ node: e.doc });
+          if (i <= n || s > n && i > n && i <= s)
+            return !0;
+          if (s > n && i > n && i > s || !e.getMeta("paste"))
+            return !1;
+          const o = e.selection.$head.pos, c = i - n, l = o - c, d = o;
+          return e.deleteRange(l, d), !(this.storage.characters({ node: e.doc }) > n);
+        }
+      })
+    ];
+  }
+});
+C.create({
+  name: "dropCursor",
+  addOptions() {
+    return {
+      color: "currentColor",
+      width: 1,
+      class: void 0
+    };
+  },
+  addProseMirrorPlugins() {
+    return [Bt(this.options)];
+  }
+});
+C.create({
+  name: "focus",
+  addOptions() {
+    return {
+      className: "has-focus",
+      mode: "all"
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      new H({
+        key: new E("focus"),
+        props: {
+          decorations: ({ doc: t, selection: e }) => {
+            const { isEditable: r, isFocused: n } = this.editor, { anchor: s } = e, i = [];
+            if (!r || !n)
+              return B.create(t, []);
+            let a = 0;
+            this.options.mode === "deepest" && t.descendants((c, l) => {
+              if (c.isText)
+                return;
+              if (!(s >= l && s <= l + c.nodeSize - 1))
+                return !1;
+              a += 1;
+            });
+            let o = 0;
+            return t.descendants((c, l) => {
+              if (c.isText || !(s >= l && s <= l + c.nodeSize - 1))
+                return !1;
+              if (o += 1, this.options.mode === "deepest" && a - o > 0 || this.options.mode === "shallowest" && o > 1)
+                return this.options.mode === "deepest";
+              i.push(
+                K.node(l, l + c.nodeSize, {
+                  class: this.options.className
+                })
+              );
+            }), B.create(t, i);
+          }
+        }
+      })
+    ];
+  }
+});
+C.create({
+  name: "gapCursor",
+  addProseMirrorPlugins() {
+    return [Ot()];
+  },
+  extendNodeSchema(t) {
+    var e;
+    const r = {
+      name: t.name,
+      options: t.options,
+      storage: t.storage
+    };
+    return {
+      allowGapCursor: (e = dt(ct(t, "allowGapCursor", r))) != null ? e : null
+    };
+  }
+});
+C.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 E("placeholder"),
+        props: {
+          decorations: ({ doc: t, selection: e }) => {
+            const r = this.editor.isEditable || !this.options.showOnlyWhenEditable, { anchor: n } = e, s = [];
+            if (!r)
+              return null;
+            const i = this.editor.isEmpty;
+            return t.descendants((a, o) => {
+              const c = n >= o && n <= o + a.nodeSize, l = !a.isLeaf && $t(a);
+              if ((c || !this.options.showOnlyCurrent) && l) {
+                const d = [this.options.emptyNodeClass];
+                i && d.push(this.options.emptyEditorClass);
+                const u = K.node(o, o + a.nodeSize, {
+                  class: d.join(" "),
+                  "data-placeholder": typeof this.options.placeholder == "function" ? this.options.placeholder({
+                    editor: this.editor,
+                    node: a,
+                    pos: o,
+                    hasAnchor: c
+                  }) : this.options.placeholder
+                });
+                s.push(u);
+              }
+              return this.options.includeChildren;
+            }), B.create(t, s);
+          }
+        }
+      })
+    ];
+  }
+});
+var gr = C.create({
+  name: "selection",
+  addOptions() {
+    return {
+      className: "selection"
+    };
+  },
+  addProseMirrorPlugins() {
+    const { editor: t, options: e } = this;
+    return [
+      new H({
+        key: new E("selection"),
+        props: {
+          decorations(r) {
+            return r.selection.empty || t.isFocused || !t.isEditable || Nt(r.selection) || t.view.dragging ? null : B.create(r.doc, [
+              K.inline(r.selection.from, r.selection.to, {
+                class: e.className
+              })
+            ]);
+          }
+        }
+      })
+    ];
+  }
+});
+function st({ types: t, node: e }) {
+  return e && Array.isArray(t) && t.includes(e.type) || e?.type === t;
+}
+C.create({
+  name: "trailingNode",
+  addOptions() {
+    return {
+      node: void 0,
+      notAfter: []
+    };
+  },
+  addProseMirrorPlugins() {
+    var t;
+    const e = new E(this.name), r = ((t = this.editor.schema.topNodeType.contentMatch.defaultType) == null ? void 0 : t.name) || this.options.node || "paragraph", n = Object.entries(this.editor.schema.nodes).map(([, s]) => s).filter((s) => (this.options.notAfter || []).concat(r).includes(s.name));
+    return [
+      new H({
+        key: e,
+        appendTransaction: (s, i, a) => {
+          const { doc: o, tr: c, schema: l } = a, d = e.getState(a), u = o.content.size, h = l.nodes[r];
+          if (d)
+            return c.insert(u, h.create());
+        },
+        state: {
+          init: (s, i) => {
+            const a = i.tr.doc.lastChild;
+            return !st({ node: a, types: n });
+          },
+          apply: (s, i) => {
+            if (!s.docChanged)
+              return i;
+            const a = s.doc.lastChild;
+            return !st({ node: a, types: n });
+          }
+        }
+      })
+    ];
+  }
+});
+C.create({
+  name: "undoRedo",
+  addOptions() {
+    return {
+      depth: 100,
+      newGroupDelay: 500
+    };
+  },
+  addCommands() {
+    return {
+      undo: () => ({ state: t, dispatch: e }) => zt(t, e),
+      redo: () => ({ state: t, dispatch: e }) => _t(t, e)
+    };
+  },
+  addProseMirrorPlugins() {
+    return [Dt(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()
+    };
+  }
+});
+var br = L.create({
+  name: "tableCell",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  content: "block+",
+  addAttributes() {
+    return {
+      colspan: {
+        default: 1
+      },
+      rowspan: {
+        default: 1
+      },
+      colwidth: {
+        default: null,
+        parseHTML: (t) => {
+          var e, r;
+          const n = t.getAttribute("colwidth"), s = n ? n.split(",").map((i) => parseInt(i, 10)) : null;
+          if (!s) {
+            const i = (e = t.closest("table")) == null ? void 0 : e.querySelectorAll("colgroup > col"), a = Array.from(((r = t.parentElement) == null ? void 0 : r.children) || []).indexOf(t);
+            if (a && a > -1 && i && i[a]) {
+              const o = i[a].getAttribute("width");
+              return o ? [parseInt(o, 10)] : null;
+            }
+          }
+          return s;
+        }
+      }
+    };
+  },
+  tableRole: "cell",
+  isolating: !0,
+  parseHTML() {
+    return [{ tag: "td" }];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["td", k(this.options.HTMLAttributes, t), 0];
+  }
+}), yr = L.create({
+  name: "tableHeader",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  content: "block+",
+  addAttributes() {
+    return {
+      colspan: {
+        default: 1
+      },
+      rowspan: {
+        default: 1
+      },
+      colwidth: {
+        default: null,
+        parseHTML: (t) => {
+          const e = t.getAttribute("colwidth");
+          return e ? e.split(",").map((n) => parseInt(n, 10)) : null;
+        }
+      }
+    };
+  },
+  tableRole: "header_cell",
+  isolating: !0,
+  parseHTML() {
+    return [{ tag: "th" }];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["th", k(this.options.HTMLAttributes, t), 0];
+  }
+}), kr = L.create({
+  name: "tableRow",
+  addOptions() {
+    return {
+      HTMLAttributes: {}
+    };
+  },
+  content: "(tableCell | tableHeader)*",
+  tableRole: "row",
+  parseHTML() {
+    return [{ tag: "tr" }];
+  },
+  renderHTML({ HTMLAttributes: t }) {
+    return ["tr", k(this.options.HTMLAttributes, t), 0];
+  }
+});
+function j(t, e) {
+  return e ? ["width", `${Math.max(e, t)}px`] : ["min-width", `${t}px`];
+}
+function it(t, e, r, n, s, i) {
+  var a;
+  let o = 0, c = !0, l = e.firstChild;
+  const d = t.firstChild;
+  if (d !== null)
+    for (let h = 0, b = 0; h < d.childCount; h += 1) {
+      const { colspan: f, colwidth: g } = d.child(h).attrs;
+      for (let m = 0; m < f; m += 1, b += 1) {
+        const T = s === b ? i : g && g[m], v = T ? `${T}px` : "";
+        if (o += T || n, T || (c = !1), l) {
+          if (l.style.width !== v) {
+            const [I, N] = j(n, T);
+            l.style.setProperty(I, N);
+          }
+          l = l.nextSibling;
+        } else {
+          const I = document.createElement("col"), [N, O] = j(n, T);
+          I.style.setProperty(N, O), e.appendChild(I);
+        }
+      }
+    }
+  for (; l; ) {
+    const h = l.nextSibling;
+    (a = l.parentNode) == null || a.removeChild(l), l = h;
+  }
+  const u = t.attrs.style && typeof t.attrs.style == "string" && /\bwidth\s*:/i.test(t.attrs.style);
+  c && !u ? (r.style.width = `${o}px`, r.style.minWidth = "") : (r.style.width = "", r.style.minWidth = `${o}px`);
+}
+var Tr = class {
+  constructor(t, e) {
+    this.node = t, this.cellMinWidth = e, this.dom = document.createElement("div"), this.dom.className = "tableWrapper", this.table = this.dom.appendChild(document.createElement("table")), t.attrs.style && (this.table.style.cssText = t.attrs.style), this.colgroup = this.table.appendChild(document.createElement("colgroup")), it(t, this.colgroup, this.table, e), this.contentDOM = this.table.appendChild(document.createElement("tbody"));
+  }
+  update(t) {
+    return t.type !== this.node.type ? !1 : (this.node = t, it(t, this.colgroup, this.table, this.cellMinWidth), !0);
+  }
+  ignoreMutation(t) {
+    const e = t.target, r = this.dom.contains(e), n = this.contentDOM.contains(e);
+    return !!(r && !n && (t.type === "attributes" || t.type === "childList" || t.type === "characterData"));
+  }
+};
+function Cr(t, e, r, n) {
+  let s = 0, i = !0;
+  const a = [], o = t.firstChild;
+  if (!o)
+    return {};
+  for (let u = 0, h = 0; u < o.childCount; u += 1) {
+    const { colspan: b, colwidth: f } = o.child(u).attrs;
+    for (let g = 0; g < b; g += 1, h += 1) {
+      const m = r === h ? n : f && f[g];
+      s += m || e, m || (i = !1);
+      const [T, v] = j(e, m);
+      a.push(["col", { style: `${T}: ${v}` }]);
+    }
+  }
+  const c = i ? `${s}px` : "", l = i ? "" : `${s}px`;
+  return { colgroup: ["colgroup", {}, ...a], tableWidth: c, tableMinWidth: l };
+}
+function ot(t, e) {
+  return t.createAndFill();
+}
+function Lr(t) {
+  if (t.cached.tableNodeTypes)
+    return t.cached.tableNodeTypes;
+  const e = {};
+  return Object.keys(t.nodes).forEach((r) => {
+    const n = t.nodes[r];
+    n.spec.tableRole && (e[n.spec.tableRole] = n);
+  }), t.cached.tableNodeTypes = e, e;
+}
+function wr(t, e, r, n, s) {
+  const i = Lr(t), a = [], o = [];
+  for (let l = 0; l < r; l += 1) {
+    const d = ot(i.cell);
+    if (d && o.push(d), n) {
+      const u = ot(i.header_cell);
+      u && a.push(u);
+    }
+  }
+  const c = [];
+  for (let l = 0; l < e; l += 1)
+    c.push(i.row.createChecked(null, n && l === 0 ? a : o));
+  return i.table.createChecked(null, c);
+}
+function vr(t) {
+  return t instanceof pt;
+}
+var P = ({ editor: t }) => {
+  const { selection: e } = t.state;
+  if (!vr(e))
+    return !1;
+  let r = 0;
+  const n = Rt(e.ranges[0].$from, (i) => i.type.name === "table");
+  return n?.node.descendants((i) => {
+    if (i.type.name === "table")
+      return !1;
+    ["tableCell", "tableHeader"].includes(i.type.name) && (r += 1);
+  }), r === e.ranges.length ? (t.commands.deleteTable(), !0) : !1;
+}, Mr = "";
+function xr(t) {
+  return (t || "").replace(/\s+/g, " ").trim();
+}
+function Ar(t, e, r = {}) {
+  var n;
+  const s = (n = r.cellLineSeparator) != null ? n : Mr;
+  if (!t || !t.content || t.content.length === 0)
+    return "";
+  const i = [];
+  t.content.forEach((f) => {
+    const g = [];
+    f.content && f.content.forEach((m) => {
+      let T = "";
+      m.content && Array.isArray(m.content) && m.content.length > 1 ? T = m.content.map((O) => e.renderChildren(O)).join(s) : T = m.content ? e.renderChildren(m.content) : "";
+      const v = xr(T), I = m.type === "tableHeader";
+      g.push({ text: v, isHeader: I });
+    }), i.push(g);
+  });
+  const a = i.reduce((f, g) => Math.max(f, g.length), 0);
+  if (a === 0)
+    return "";
+  const o = new Array(a).fill(0);
+  i.forEach((f) => {
+    var g;
+    for (let m = 0; m < a; m += 1) {
+      const v = (((g = f[m]) == null ? void 0 : g.text) || "").length;
+      v > o[m] && (o[m] = v), o[m] < 3 && (o[m] = 3);
+    }
+  });
+  const c = (f, g) => f + " ".repeat(Math.max(0, g - f.length)), l = i[0], d = l.some((f) => f.isHeader);
+  let u = `
+`;
+  const h = new Array(a).fill(0).map((f, g) => d && l[g] && l[g].text || "");
+  return u += `| ${h.map((f, g) => c(f, o[g])).join(" | ")} |
+`, u += `| ${o.map((f) => "-".repeat(Math.max(3, f))).join(" | ")} |
+`, (d ? i.slice(1) : i).forEach((f) => {
+    u += `| ${new Array(a).fill(0).map((g, m) => c(f[m] && f[m].text || "", o[m])).join(" | ")} |
+`;
+  }), u;
+}
+var Ir = Ar, Sr = L.create({
+  name: "table",
+  // @ts-ignore
+  addOptions() {
+    return {
+      HTMLAttributes: {},
+      resizable: !1,
+      renderWrapper: !1,
+      handleWidth: 5,
+      cellMinWidth: 25,
+      // TODO: fix
+      View: Tr,
+      lastColumnResizable: !0,
+      allowTableNodeSelection: !1
+    };
+  },
+  content: "tableRow+",
+  tableRole: "table",
+  isolating: !0,
+  group: "block",
+  parseHTML() {
+    return [{ tag: "table" }];
+  },
+  renderHTML({ node: t, HTMLAttributes: e }) {
+    const { colgroup: r, tableWidth: n, tableMinWidth: s } = Cr(t, this.options.cellMinWidth), i = e.style;
+    function a() {
+      return i || (n ? `width: ${n}` : `min-width: ${s}`);
+    }
+    const o = [
+      "table",
+      k(this.options.HTMLAttributes, e, {
+        style: a()
+      }),
+      r,
+      ["tbody", 0]
+    ];
+    return this.options.renderWrapper ? ["div", { class: "tableWrapper" }, o] : o;
+  },
+  parseMarkdown: (t, e) => {
+    const r = [];
+    if (t.header) {
+      const n = [];
+      t.header.forEach((s) => {
+        n.push(e.createNode("tableHeader", {}, [{ type: "paragraph", content: e.parseInline(s.tokens) }]));
+      }), r.push(e.createNode("tableRow", {}, n));
+    }
+    return t.rows && t.rows.forEach((n) => {
+      const s = [];
+      n.forEach((i) => {
+        s.push(e.createNode("tableCell", {}, [{ type: "paragraph", content: e.parseInline(i.tokens) }]));
+      }), r.push(e.createNode("tableRow", {}, s));
+    }), e.createNode("table", void 0, r);
+  },
+  renderMarkdown: (t, e) => Ir(t, e),
+  addCommands() {
+    return {
+      insertTable: ({ rows: t = 3, cols: e = 3, withHeaderRow: r = !0 } = {}) => ({ tr: n, dispatch: s, editor: i }) => {
+        const a = wr(i.schema, t, e, r);
+        if (s) {
+          const o = n.selection.from + 1;
+          n.replaceSelectionWith(a).scrollIntoView().setSelection(Pt.near(n.doc.resolve(o)));
+        }
+        return !0;
+      },
+      addColumnBefore: () => ({ state: t, dispatch: e }) => pe(t, e),
+      addColumnAfter: () => ({ state: t, dispatch: e }) => ce(t, e),
+      deleteColumn: () => ({ state: t, dispatch: e }) => de(t, e),
+      addRowBefore: () => ({ state: t, dispatch: e }) => ue(t, e),
+      addRowAfter: () => ({ state: t, dispatch: e }) => le(t, e),
+      deleteRow: () => ({ state: t, dispatch: e }) => ae(t, e),
+      deleteTable: () => ({ state: t, dispatch: e }) => oe(t, e),
+      mergeCells: () => ({ state: t, dispatch: e }) => G(t, e),
+      splitCell: () => ({ state: t, dispatch: e }) => X(t, e),
+      toggleHeaderColumn: () => ({ state: t, dispatch: e }) => Y("column")(t, e),
+      toggleHeaderRow: () => ({ state: t, dispatch: e }) => Y("row")(t, e),
+      toggleHeaderCell: () => ({ state: t, dispatch: e }) => ie(t, e),
+      mergeOrSplit: () => ({ state: t, dispatch: e }) => G(t, e) ? !0 : X(t, e),
+      setCellAttribute: (t, e) => ({ state: r, dispatch: n }) => se(t, e)(r, n),
+      goToNextCell: () => ({ state: t, dispatch: e }) => U(1)(t, e),
+      goToPreviousCell: () => ({ state: t, dispatch: e }) => U(-1)(t, e),
+      fixTables: () => ({ state: t, dispatch: e }) => (e && ne(t), !0),
+      setCellSelection: (t) => ({ tr: e, dispatch: r }) => {
+        if (r) {
+          const n = pt.create(e.doc, t.anchorCell, t.headCell);
+          e.setSelection(n);
+        }
+        return !0;
+      }
+    };
+  },
+  addKeyboardShortcuts() {
+    return {
+      Tab: () => this.editor.commands.goToNextCell() ? !0 : this.editor.can().addRowAfter() ? this.editor.chain().addRowAfter().goToNextCell().run() : !1,
+      "Shift-Tab": () => this.editor.commands.goToPreviousCell(),
+      Backspace: P,
+      "Mod-Backspace": P,
+      Delete: P,
+      "Mod-Delete": P
+    };
+  },
+  addProseMirrorPlugins() {
+    return [
+      ...this.options.resizable && this.editor.isEditable ? [
+        ee({
+          handleWidth: this.options.handleWidth,
+          cellMinWidth: this.options.cellMinWidth,
+          defaultCellMinWidth: this.options.cellMinWidth,
+          View: this.options.View,
+          lastColumnResizable: this.options.lastColumnResizable
+        })
+      ] : [],
+      re({
+        allowTableNodeSelection: this.options.allowTableNodeSelection
+      })
+    ];
+  },
+  extendNodeSchema(t) {
+    const e = {
+      name: t.name,
+      options: t.options,
+      storage: t.storage
+    };
+    return {
+      tableRole: dt(ct(t, "tableRole", e))
+    };
+  }
+}), Hr = C.create({
+  name: "tableKit",
+  addExtensions() {
+    const t = [];
+    return this.options.table !== !1 && t.push(Sr.configure(this.options.table)), this.options.tableCell !== !1 && t.push(br.configure(this.options.tableCell)), this.options.tableHeader !== !1 && t.push(yr.configure(this.options.tableHeader)), this.options.tableRow !== !1 && t.push(kr.configure(this.options.tableRow)), t;
+  }
+});
+const Er = ({
+  onHighlighterClick: t,
+  onLinkClick: e,
+  isMobile: r
+}) => {
+  const { editor: n } = te();
+  return /* @__PURE__ */ w(at, { children: [
+    /* @__PURE__ */ w(x, { children: [
+      /* @__PURE__ */ p(Z, { action: "undo" }),
+      /* @__PURE__ */ p(Z, { action: "redo" })
+    ] }),
+    /* @__PURE__ */ p(A, {}),
+    /* @__PURE__ */ w(x, { children: [
+      /* @__PURE__ */ p(fe, { levels: [1, 2, 3, 4], portal: r }),
+      /* @__PURE__ */ p(
+        me,
+        {
+          types: ["bulletList", "orderedList", "taskList"],
+          portal: r
+        }
+      ),
+      /* @__PURE__ */ p(ge, {}),
+      /* @__PURE__ */ p(be, {})
+    ] }),
+    /* @__PURE__ */ p(A, {}),
+    /* @__PURE__ */ w(x, { children: [
+      /* @__PURE__ */ p(M, { type: "bold" }),
+      /* @__PURE__ */ p(M, { type: "italic" }),
+      /* @__PURE__ */ p(M, { type: "strike" }),
+      /* @__PURE__ */ p(M, { type: "code" }),
+      /* @__PURE__ */ p(M, { type: "underline" }),
+      r ? /* @__PURE__ */ p(ke, { onClick: t }) : /* @__PURE__ */ p(ye, {}),
+      r ? /* @__PURE__ */ p(Le, { onClick: e }) : /* @__PURE__ */ p(Ce, {})
+    ] }),
+    /* @__PURE__ */ p(A, {}),
+    /* @__PURE__ */ w(x, { children: [
+      /* @__PURE__ */ p(M, { type: "superscript" }),
+      /* @__PURE__ */ p(M, { type: "subscript" })
+    ] }),
+    /* @__PURE__ */ p(A, {}),
+    /* @__PURE__ */ w(x, { children: [
+      /* @__PURE__ */ p(R, { align: "left" }),
+      /* @__PURE__ */ p(R, { align: "center" }),
+      /* @__PURE__ */ p(R, { align: "right" }),
+      /* @__PURE__ */ p(R, { align: "justify" })
+    ] }),
+    /* @__PURE__ */ p(A, {}),
+    /* @__PURE__ */ p(x, { children: /* @__PURE__ */ p(Zt, { onClick: () => {
+      n && n.chain().focus().insertTable({ rows: 3, cols: 3 }).run();
+    } }) }),
+    r && /* @__PURE__ */ p(A, {})
+  ] });
+}, $r = ({
+  type: t,
+  onBack: e
+}) => /* @__PURE__ */ w(at, { children: [
+  /* @__PURE__ */ p(x, { children: /* @__PURE__ */ w(ve, { "data-style": "ghost", onClick: e, children: [
+    /* @__PURE__ */ p(Kt, { className: "tiptap-button-icon" }),
+    t === "highlighter" ? /* @__PURE__ */ p(Vt, { className: "tiptap-button-icon" }) : /* @__PURE__ */ p(qt, { className: "tiptap-button-icon" })
+  ] }) }),
+  /* @__PURE__ */ p(A, {}),
+  t === "highlighter" ? /* @__PURE__ */ p(Te, {}) : /* @__PURE__ */ p(we, {})
+] });
+function fn({
+  themeMode: t,
+  content: e,
+  onContentChange: r
+}) {
+  const n = Ut(), { height: s } = Gt(), [i, a] = vt(
+    "main"
+  ), o = q(null), c = q(!1), l = Ct({
+    immediatelyRender: !1,
+    shouldRerenderOnTransaction: !1,
+    editorProps: {
+      attributes: {
+        autocomplete: "off",
+        autocorrect: "off",
+        autocapitalize: "off",
+        "aria-label": "Main content area, start typing to enter text.",
+        class: "simple-editor"
+      }
+    },
+    extensions: [
+      Wt.configure({
+        horizontalRule: !1,
+        link: {
+          openOnClick: !1,
+          enableClickSelection: !0
+        }
+      }),
+      jt,
+      qe.configure({ types: ["heading", "paragraph"] }),
+      Tt,
+      kt.configure({ nested: !0 }),
+      Ae.configure({ multicolor: !0 }),
+      Se,
+      mr,
+      Ve,
+      Ke,
+      gr,
+      Qt.configure({
+        accept: "image/*",
+        maxSize: Yt,
+        limit: 3,
+        upload: Xt,
+        onError: (u) => console.error("Upload failed:", u)
+      }),
+      Hr.configure({
+        table: {
+          resizable: !0
+        }
+      })
+    ],
+    content: e,
+    onUpdate: ({ editor: u }) => {
+      if (!c.current && r) {
+        const h = u.getHTML();
+        r(h);
+      }
+    }
+  }), d = Ft({
+    editor: l,
+    overlayHeight: o.current?.getBoundingClientRect().height ?? 0
+  });
+  return D(() => {
+    !n && i !== "main" && a("main");
+  }, [n, i]), D(() => {
+    l && e !== void 0 && l.getHTML() !== e && (c.current = !0, l.commands.setContent(e, { emitUpdate: !1 }), c.current = !1);
+  }, [e, l]), D(() => {
+    document.documentElement.classList.toggle("dark", t === "dark");
+  }, [t]), l ? /* @__PURE__ */ p("div", { className: "simple-editor-wrapper", children: /* @__PURE__ */ w(Lt.Provider, { value: { editor: l }, children: [
+    /* @__PURE__ */ p(
+      he,
+      {
+        ref: o,
+        style: {
+          ...n ? {
+            bottom: `calc(100% - ${s - d.y}px)`
+          } : {}
+        },
+        children: i === "main" ? /* @__PURE__ */ p(
+          Er,
+          {
+            onHighlighterClick: () => a("highlighter"),
+            onLinkClick: () => a("link"),
+            isMobile: n
+          }
+        ) : /* @__PURE__ */ p(
+          $r,
+          {
+            type: i === "highlighter" ? "highlighter" : "link",
+            onBack: () => a("main")
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ p(Jt, {}),
+    /* @__PURE__ */ p(
+      wt,
+      {
+        editor: l,
+        role: "presentation",
+        className: "simple-editor-content"
+      }
+    )
+  ] }) }) : null;
+}
+export {
+  fn as SimpleEditor
+};