@firecms/core 3.4.0-canary.cb27f16 → 3.4.0-canary.ce97da7

package/dist/editor-BSo_aS1I.js

@@ -0,0 +1,4563 @@
+import { jsx, jsxs, Fragment as Fragment$1 } from "react/jsx-runtime";
+import { c } from "react-compiler-runtime";
+import React__default, { createContext, useContext, forwardRef, useRef, useState, useEffect, useLayoutEffect } from "react";
+import { defaultBorderMixin, cls, TextFieldsIcon, CheckBoxIcon, LooksOneIcon, LooksTwoIcon, Looks3Icon, FormatListBulletedIcon, FormatListNumberedIcon, FormatQuoteIcon, CodeIcon, ImageIcon, TableChartIcon, AutoFixHighIcon, TextField, Tooltip, IconButton, CheckIcon, Popover, Button, KeyboardArrowDownIcon, focusedDisabled, DeleteIcon, FormatBoldIcon, FormatItalicIcon, FormatUnderlinedIcon, FormatStrikethroughIcon, useInjectStyles, Separator, TextareaAutosize } from "@firecms/ui";
+import { useTranslation } from "./index.es.js";
+import { autoUpdate, computePosition, offset, flip, shift } from "@floating-ui/dom";
+import { NodeSelection, Plugin, PluginKey, TextSelection, EditorState } from "prosemirror-state";
+import { Slot } from "@radix-ui/react-slot";
+import { Schema, Fragment, DOMParser, DOMSerializer } from "prosemirror-model";
+import { setBlockType, wrapIn, toggleMark, baseKeymap } from "prosemirror-commands";
+import { wrapInList, sinkListItem, liftListItem, splitListItem } from "prosemirror-schema-list";
+import { tableNodes, addRowBefore, addRowAfter, deleteRow, addColumnBefore, addColumnAfter, deleteColumn, deleteTable, goToNextCell, columnResizing, tableEditing } from "prosemirror-tables";
+import { DecorationSet, Decoration, EditorView } from "prosemirror-view";
+import { MarkdownParser, MarkdownSerializer, defaultMarkdownParser, defaultMarkdownSerializer } from "prosemirror-markdown";
+import markdownIt from "markdown-it";
+import markdownItTaskLists from "markdown-it-task-lists";
+import markdownItMark from "markdown-it-mark";
+import markdownItIns from "markdown-it-ins";
+import { keymap } from "prosemirror-keymap";
+import { history, redo, undo } from "prosemirror-history";
+import { dropPoint } from "prosemirror-transform";
+import { gapCursor } from "prosemirror-gapcursor";
+import { inputRules, smartQuotes, ellipsis, emDash, InputRule, wrappingInputRule, textblockTypeInputRule } from "prosemirror-inputrules";
+import { createRoot } from "react-dom/client";
+const ProseMirrorContext = createContext({
+  state: null,
+  view: null
+});
+const useProseMirrorContext = () => {
+  return useContext(ProseMirrorContext);
+};
+const EditorBubble = forwardRef((t0, ref) => {
+  const $ = c(19);
+  const {
+    children,
+    options,
+    className
+  } = t0;
+  const {
+    view,
+    state
+  } = useProseMirrorContext();
+  const menuRef = useRef(null);
+  const [show, setShow] = useState(false);
+  let t1;
+  let t2;
+  if ($[0] !== state || $[1] !== view) {
+    t1 = () => {
+      if (!view || !state) {
+        return;
+      }
+      const timer = setTimeout(() => {
+        const {
+          selection
+        } = state;
+        const {
+          empty
+        } = selection;
+        let isImage;
+        isImage = false;
+        state.doc.nodesBetween(selection.from, selection.to, (node) => {
+          if (node.type.name === "image") {
+            isImage = true;
+          }
+        });
+        if (isImage || empty || selection instanceof NodeSelection) {
+          setShow(false);
+          return;
+        }
+        setShow(true);
+      }, 0);
+      return () => clearTimeout(timer);
+    };
+    t2 = [view, state];
+    $[0] = state;
+    $[1] = view;
+    $[2] = t1;
+    $[3] = t2;
+  } else {
+    t1 = $[2];
+    t2 = $[3];
+  }
+  useEffect(t1, t2);
+  let t3;
+  if ($[4] !== options?.offset || $[5] !== options?.placement || $[6] !== show || $[7] !== state || $[8] !== view) {
+    t3 = () => {
+      if (!show || !view || !state || !menuRef.current) {
+        return;
+      }
+      const {
+        from,
+        to
+      } = state.selection;
+      let start;
+      start = view.coordsAtPos(from);
+      let end;
+      end = view.coordsAtPos(to);
+      const virtualEl = {
+        getBoundingClientRect() {
+          const top = Math.min(start.top, end.top);
+          const bottom = Math.max(start.bottom, end.bottom);
+          const left = Math.min(start.left, end.left);
+          const right = Math.max(start.right, end.right);
+          return {
+            width: right - left,
+            height: bottom - top,
+            x: left,
+            y: top,
+            top,
+            left,
+            right,
+            bottom
+          };
+        }
+      };
+      const cleanup = autoUpdate(virtualEl, menuRef.current, () => {
+        if (!menuRef.current) {
+          return;
+        }
+        try {
+          start = view.coordsAtPos(state.selection.from);
+          end = view.coordsAtPos(state.selection.to);
+        } catch (t42) {
+        }
+        computePosition(virtualEl, menuRef.current, {
+          placement: options?.placement || "top",
+          middleware: [offset(options?.offset || 8), flip(), shift()],
+          strategy: "fixed"
+        }).then((t52) => {
+          const {
+            x,
+            y
+          } = t52;
+          if (menuRef.current) {
+            Object.assign(menuRef.current.style, {
+              left: `${x}px`,
+              top: `${y}px`,
+              visibility: "visible"
+            });
+          }
+        });
+      });
+      return () => cleanup();
+    };
+    $[4] = options?.offset;
+    $[5] = options?.placement;
+    $[6] = show;
+    $[7] = state;
+    $[8] = view;
+    $[9] = t3;
+  } else {
+    t3 = $[9];
+  }
+  let t4;
+  if ($[10] !== options || $[11] !== show || $[12] !== state || $[13] !== view) {
+    t4 = [show, view, state, options];
+    $[10] = options;
+    $[11] = show;
+    $[12] = state;
+    $[13] = view;
+    $[14] = t4;
+  } else {
+    t4 = $[14];
+  }
+  useEffect(t3, t4);
+  if (!show) {
+    return null;
+  }
+  let t5;
+  if ($[15] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t5 = {
+      position: "fixed",
+      zIndex: 9999,
+      visibility: "hidden"
+    };
+    $[15] = t5;
+  } else {
+    t5 = $[15];
+  }
+  let t6;
+  if ($[16] !== children || $[17] !== className) {
+    t6 = /* @__PURE__ */ jsx("div", { ref: menuRef, className, style: t5, onMouseDown: _temp$5, children });
+    $[16] = children;
+    $[17] = className;
+    $[18] = t6;
+  } else {
+    t6 = $[18];
+  }
+  return t6;
+});
+EditorBubble.displayName = "EditorBubble";
+function _temp$5(e_0) {
+  e_0.preventDefault();
+}
+const EditorBubbleItem = forwardRef((t0, ref) => {
+  const $ = c(13);
+  let asChild;
+  let children;
+  let onSelect;
+  let rest;
+  if ($[0] !== t0) {
+    ({
+      children,
+      asChild,
+      onSelect,
+      ...rest
+    } = t0);
+    $[0] = t0;
+    $[1] = asChild;
+    $[2] = children;
+    $[3] = onSelect;
+    $[4] = rest;
+  } else {
+    asChild = $[1];
+    children = $[2];
+    onSelect = $[3];
+    rest = $[4];
+  }
+  const {
+    view
+  } = useProseMirrorContext();
+  const Comp = asChild ? Slot : "div";
+  if (!view) {
+    return null;
+  }
+  let t1;
+  if ($[5] !== onSelect) {
+    t1 = () => onSelect?.();
+    $[5] = onSelect;
+    $[6] = t1;
+  } else {
+    t1 = $[6];
+  }
+  let t2;
+  if ($[7] !== Comp || $[8] !== children || $[9] !== ref || $[10] !== rest || $[11] !== t1) {
+    t2 = /* @__PURE__ */ jsx(Comp, { ref, ...rest, onMouseDown: _temp$4, onClick: t1, children });
+    $[7] = Comp;
+    $[8] = children;
+    $[9] = ref;
+    $[10] = rest;
+    $[11] = t1;
+    $[12] = t2;
+  } else {
+    t2 = $[12];
+  }
+  return t2;
+});
+EditorBubbleItem.displayName = "EditorBubbleItem";
+function _temp$4(e) {
+  e.preventDefault();
+}
+const SlashCommandPluginKey = new PluginKey("slash-command");
+function slashCommandPlugin() {
+  return new Plugin({
+    key: SlashCommandPluginKey,
+    state: {
+      init() {
+        return {
+          active: false
+        };
+      },
+      apply(tr, value, oldState, newState) {
+        const meta = tr.getMeta(SlashCommandPluginKey);
+        if (meta !== void 0) {
+          return meta;
+        }
+        const {
+          selection
+        } = newState;
+        if (!(selection instanceof TextSelection) || !selection.empty) {
+          return {
+            active: false
+          };
+        }
+        const $anchor = selection.$anchor;
+        if ($anchor.parent.type.name === "code_block") {
+          return {
+            active: false
+          };
+        }
+        const textBefore = $anchor.parent.textBetween(Math.max(0, $anchor.parentOffset - 20), $anchor.parentOffset, void 0, "");
+        const match = textBefore.match(/(?:\s|^)(\/)([a-zA-Z0-9]*)$/);
+        if (!match) {
+          return {
+            active: false
+          };
+        }
+        if (value.dismissed) {
+          return {
+            active: false,
+            dismissed: true
+          };
+        }
+        const query = match[2];
+        const from = $anchor.pos - query.length - 1;
+        const to = $anchor.pos;
+        return {
+          active: true,
+          range: {
+            from,
+            to
+          },
+          query
+        };
+      }
+    }
+  });
+}
+const marks = {
+  link: {
+    attrs: {
+      href: {},
+      title: {
+        default: null
+      },
+      target: {
+        default: "_blank"
+      }
+    },
+    inclusive: false,
+    parseDOM: [{
+      tag: "a[href]",
+      getAttrs(dom) {
+        if (typeof dom === "string") return false;
+        return {
+          href: dom.getAttribute("href"),
+          title: dom.getAttribute("title"),
+          target: dom.getAttribute("target") || "_blank"
+        };
+      }
+    }],
+    toDOM(node) {
+      let {
+        href,
+        title,
+        target
+      } = node.attrs;
+      return ["a", {
+        href,
+        title,
+        target,
+        class: "text-surface-700 dark:text-surface-accent-200 underline underline-offset-[3px] hover:text-primary transition-colors cursor-pointer"
+      }, 0];
+    }
+  },
+  bold: {
+    parseDOM: [{
+      tag: "strong"
+    }, {
+      tag: "b",
+      getAttrs: (node) => typeof node !== "string" && node.style.fontWeight !== "normal" && null
+    }, {
+      style: "font-weight=400",
+      clearMark: (m) => m.type.name === "bold"
+    }, {
+      style: "font-weight",
+      getAttrs: (value) => typeof value === "string" && /^(bold(er)?|[5-9]\d{2,})$/.test(value) && null
+    }],
+    toDOM() {
+      return ["strong", 0];
+    }
+  },
+  italic: {
+    parseDOM: [{
+      tag: "i"
+    }, {
+      tag: "em"
+    }, {
+      style: "font-style=italic"
+    }],
+    toDOM() {
+      return ["em", 0];
+    }
+  },
+  strike: {
+    parseDOM: [{
+      tag: "s"
+    }, {
+      tag: "del"
+    }, {
+      tag: "strike"
+    }, {
+      style: "text-decoration=line-through"
+    }],
+    toDOM() {
+      return ["s", 0];
+    }
+  },
+  underline: {
+    parseDOM: [{
+      tag: "u"
+    }, {
+      style: "text-decoration=underline"
+    }],
+    toDOM() {
+      return ["u", 0];
+    }
+  },
+  code: {
+    parseDOM: [{
+      tag: "code"
+    }],
+    toDOM() {
+      return ["code", {
+        class: "rounded-md bg-surface-accent-50 dark:bg-surface-700 px-1.5 py-1 font-mono font-medium",
+        spellcheck: "false"
+      }, 0];
+    }
+  },
+  textStyle: {
+    attrs: {
+      color: {
+        default: null
+      }
+    },
+    parseDOM: [{
+      style: "color",
+      getAttrs: (value) => {
+        if (typeof value === "string") return {
+          color: value
+        };
+        return false;
+      }
+    }],
+    toDOM(mark) {
+      let style = "";
+      if (mark.attrs.color) style += `color: ${mark.attrs.color};`;
+      return ["span", {
+        style
+      }, 0];
+    }
+  },
+  highlight: {
+    attrs: {
+      color: {
+        default: null
+      }
+    },
+    parseDOM: [{
+      tag: "mark",
+      getAttrs: (dom) => {
+        if (typeof dom === "string") return false;
+        return {
+          color: dom.style.backgroundColor || dom.getAttribute("data-color")
+        };
+      }
+    }],
+    toDOM(mark) {
+      return ["mark", mark.attrs.color ? {
+        style: `background-color: ${mark.attrs.color}; color: inherit;`,
+        "data-color": mark.attrs.color
+      } : {}, 0];
+    }
+  }
+};
+const nodes = {
+  doc: {
+    content: "block+"
+  },
+  paragraph: {
+    content: "inline*",
+    group: "block",
+    parseDOM: [{
+      tag: "p"
+    }],
+    toDOM() {
+      return ["p", 0];
+    }
+  },
+  text: {
+    group: "inline"
+  },
+  blockquote: {
+    content: "block+",
+    group: "block",
+    defining: true,
+    parseDOM: [{
+      tag: "blockquote"
+    }],
+    toDOM() {
+      return ["blockquote", {
+        class: "border-l-4 border-primary"
+      }, 0];
+    }
+  },
+  heading: {
+    attrs: {
+      level: {
+        default: 1
+      }
+    },
+    content: "inline*",
+    group: "block",
+    defining: true,
+    parseDOM: [{
+      tag: "h1",
+      attrs: {
+        level: 1
+      }
+    }, {
+      tag: "h2",
+      attrs: {
+        level: 2
+      }
+    }, {
+      tag: "h3",
+      attrs: {
+        level: 3
+      }
+    }, {
+      tag: "h4",
+      attrs: {
+        level: 4
+      }
+    }, {
+      tag: "h5",
+      attrs: {
+        level: 5
+      }
+    }, {
+      tag: "h6",
+      attrs: {
+        level: 6
+      }
+    }],
+    toDOM(node) {
+      return ["h" + node.attrs.level, 0];
+    }
+  },
+  horizontal_rule: {
+    group: "block",
+    parseDOM: [{
+      tag: "hr"
+    }],
+    toDOM() {
+      return ["hr", {
+        class: "mt-4 mb-6 border-t border-solid border-gray-200 dark:border-gray-800"
+      }];
+    }
+  },
+  code_block: {
+    content: "text*",
+    marks: "",
+    group: "block",
+    code: true,
+    defining: true,
+    attrs: {
+      language: {
+        default: null
+      }
+    },
+    parseDOM: [{
+      tag: "pre",
+      preserveWhitespace: "full"
+    }],
+    toDOM(node) {
+      return ["pre", {
+        class: "rounded bg-blue-50 dark:bg-surface-700 border border-solid border-gray-200 dark:border-gray-800 p-5 font-mono font-medium"
+      }, ["code", 0]];
+    }
+  },
+  image: {
+    inline: false,
+    group: "block",
+    attrs: {
+      src: {},
+      alt: {
+        default: null
+      },
+      title: {
+        default: null
+      }
+    },
+    draggable: true,
+    parseDOM: [{
+      tag: "img[src]",
+      getAttrs(dom) {
+        if (typeof dom === "string") return false;
+        return {
+          src: dom.getAttribute("src"),
+          title: dom.getAttribute("title"),
+          alt: dom.getAttribute("alt")
+        };
+      }
+    }],
+    toDOM(node) {
+      let {
+        src,
+        alt,
+        title
+      } = node.attrs;
+      return ["img", {
+        src,
+        alt,
+        title,
+        class: "rounded-lg max-w-full !m-0"
+      }];
+    }
+  },
+  bullet_list: {
+    content: "list_item+",
+    group: "block",
+    parseDOM: [{
+      tag: "ul"
+    }],
+    toDOM() {
+      return ["ul", {
+        class: "list-disc list-outside leading-3 -mt-2"
+      }, 0];
+    }
+  },
+  ordered_list: {
+    content: "list_item+",
+    group: "block",
+    attrs: {
+      order: {
+        default: 1
+      }
+    },
+    parseDOM: [{
+      tag: "ol",
+      getAttrs(dom) {
+        if (typeof dom === "string") return false;
+        return {
+          order: dom.hasAttribute("start") ? +dom.getAttribute("start") : 1
+        };
+      }
+    }],
+    toDOM(node) {
+      return node.attrs.order === 1 ? ["ol", {
+        class: "list-decimal list-outside leading-3 -mt-2"
+      }, 0] : ["ol", {
+        start: node.attrs.order,
+        class: "list-decimal list-outside leading-3 -mt-2"
+      }, 0];
+    }
+  },
+  list_item: {
+    content: "paragraph block*",
+    parseDOM: [{
+      tag: "li"
+    }],
+    toDOM() {
+      return ["li", {
+        class: "leading-normal -mb-2"
+      }, 0];
+    },
+    defining: true
+  },
+  task_list: {
+    group: "block",
+    content: "task_item+",
+    parseDOM: [{
+      tag: 'ul[data-type="taskList"]'
+    }],
+    toDOM() {
+      return ["ul", {
+        "data-type": "taskList",
+        class: "not-prose"
+      }, 0];
+    }
+  },
+  task_item: {
+    content: "paragraph block*",
+    defining: true,
+    attrs: {
+      checked: {
+        default: false
+      }
+    },
+    parseDOM: [{
+      tag: 'li[data-type="taskItem"]',
+      getAttrs(dom) {
+        if (typeof dom === "string") return false;
+        return {
+          checked: dom.getAttribute("data-checked") === "true"
+        };
+      }
+    }],
+    toDOM(node) {
+      return ["li", {
+        "data-type": "taskItem",
+        "data-checked": node.attrs.checked ? "true" : "false",
+        class: "flex items-start my-4"
+      }, 0];
+    }
+  },
+  hard_break: {
+    inline: true,
+    group: "inline",
+    selectable: false,
+    parseDOM: [{
+      tag: "br"
+    }],
+    toDOM() {
+      return ["br"];
+    }
+  },
+  ...tableNodes({
+    tableGroup: "block",
+    cellContent: "block+",
+    cellAttributes: {
+      background: {
+        default: null,
+        getFromDOM(dom) {
+          return dom.style.backgroundColor || null;
+        },
+        setDOMAttr(value, attrs) {
+          if (value) attrs.style = (attrs.style || "") + `background-color: ${value};`;
+        }
+      }
+    }
+  })
+};
+const schema = new Schema({
+  nodes,
+  marks
+});
+async function onFileRead(view, readerEvent, pos, upload, image) {
+  if (view.isDestroyed) return;
+  const plugin = view.state.plugins.find((p) => p.key === ImagePluginKey.key);
+  if (!plugin) {
+    console.error("Image plugin not found");
+    return;
+  }
+  const decoId = Math.random().toString(36).substring(7);
+  const placeholder = document.createElement("div");
+  const imageElement = document.createElement("img");
+  imageElement.setAttribute("class", "opacity-40 rounded-lg border " + defaultBorderMixin);
+  imageElement.src = readerEvent.target?.result;
+  placeholder.appendChild(imageElement);
+  const deco = Decoration.widget(pos, placeholder, {
+    id: decoId
+  });
+  let decorationSet = plugin.getState(view.state);
+  decorationSet = decorationSet?.add(view.state.doc, [deco]);
+  view.dispatch(view.state.tr.setMeta(plugin, {
+    decorationSet
+  }));
+  const src = await upload(image);
+  console.debug("Uploaded image", src);
+  if (view.isDestroyed) return;
+  const replacePlaceholder = () => {
+    if (view.isDestroyed) return;
+    let currentDecos = plugin.getState(view.state);
+    const foundDecos = currentDecos.find(void 0, void 0, (spec) => spec.id === decoId);
+    if (foundDecos.length === 0) {
+      console.warn("Image placeholder removed before upload completed.");
+      return;
+    }
+    const currentPos = foundDecos[0].from;
+    const imageNode = view.state.schema.nodes.image.create({
+      src
+    });
+    const tr = view.state.tr.replaceWith(currentPos, currentPos, imageNode);
+    currentDecos = currentDecos.remove(foundDecos);
+    tr.setMeta(plugin, {
+      decorationSet: currentDecos
+    });
+    view.dispatch(tr);
+  };
+  const preloader = new Image();
+  preloader.src = src;
+  preloader.onload = replacePlaceholder;
+  preloader.onerror = replacePlaceholder;
+}
+const ImagePluginKey = new PluginKey("imagePlugin");
+const createDropImagePlugin = (upload) => {
+  const plugin = new Plugin({
+    key: ImagePluginKey,
+    state: {
+      // Initialize the plugin state with an empty DecorationSet
+      init: () => DecorationSet.empty,
+      // Apply transactions to update the state
+      apply: (tr, old) => {
+        const meta = tr.getMeta(plugin);
+        if (meta && meta.decorationSet) {
+          return meta.decorationSet;
+        }
+        return old.map(tr.mapping, tr.doc);
+      }
+    },
+    props: {
+      handleDOMEvents: {
+        dragover: (view, event) => {
+          if (event.dataTransfer?.types?.includes("Files")) {
+            event.preventDefault();
+            return true;
+          }
+          return false;
+        },
+        drop: (view, event) => {
+          if (!event.dataTransfer?.files || event.dataTransfer?.files.length === 0) {
+            return false;
+          }
+          event.preventDefault();
+          const files = Array.from(event.dataTransfer.files);
+          const images = files.filter((file) => /image/i.test(file.type));
+          if (images.length === 0) {
+            console.log("No images found in dropped files");
+            return false;
+          }
+          images.forEach((image) => {
+            const position = view.posAtCoords({
+              left: event.clientX,
+              top: event.clientY
+            });
+            if (!position) return;
+            const reader = new FileReader();
+            reader.onload = async (readerEvent) => {
+              await onFileRead(view, readerEvent, position.pos, upload, image);
+            };
+            reader.readAsDataURL(image);
+          });
+          return true;
+        }
+      },
+      handlePaste(view, event, slice) {
+        const html = event.clipboardData?.getData("text/html");
+        if (html && html.includes("<img")) {
+          return false;
+        }
+        const items2 = Array.from(event.clipboardData?.items || []);
+        const pos = view.state.selection.from;
+        let anyImageFound = false;
+        items2.filter((item) => item.type.startsWith("image/")).forEach((item) => {
+          const image = item.getAsFile();
+          if (image) {
+            anyImageFound = true;
+            const reader = new FileReader();
+            reader.onload = async (readerEvent) => {
+              await onFileRead(view, readerEvent, pos, upload, image);
+            };
+            reader.readAsDataURL(image);
+          }
+        });
+        return anyImageFound;
+      },
+      decorations(state) {
+        return plugin.getState(state);
+      }
+    }
+  });
+  return plugin;
+};
+const loadingDecorationKey = new PluginKey("loadingDecoration");
+const textLoadingCommands = {
+  toggleLoadingDecoration: (state, dispatch, loadingHtml) => {
+    const {
+      selection
+    } = state;
+    const pos = selection.from;
+    if (!dispatch) return false;
+    const tr = state.tr.setMeta(loadingDecorationKey, {
+      pos,
+      type: "loadingDecoration",
+      remove: false,
+      loadingHtml
+    });
+    dispatch(tr);
+    return true;
+  },
+  removeLoadingDecoration: (state, dispatch) => {
+    if (!dispatch) return false;
+    const tr = state.tr.setMeta(loadingDecorationKey, {
+      pos: 0,
+      // We can pass any position as it will remove the entire decoration set
+      type: "loadingDecoration",
+      remove: true
+    });
+    dispatch(tr);
+    return true;
+  }
+};
+const textLoadingDecorationPlugin = () => {
+  return new Plugin({
+    key: loadingDecorationKey,
+    state: {
+      init() {
+        return {
+          decorationSet: DecorationSet.empty,
+          hasDecoration: false
+        };
+      },
+      apply(tr, oldState) {
+        const action = tr.getMeta(loadingDecorationKey);
+        if (action?.type === "loadingDecoration") {
+          const {
+            pos,
+            remove,
+            loadingHtml
+          } = action;
+          if (remove) {
+            return {
+              decorationSet: DecorationSet.empty,
+              hasDecoration: false
+            };
+          }
+          const decoration = Decoration.widget(pos, () => {
+            const container = document.createElement("span");
+            container.className = "loading-decoration";
+            if (loadingHtml) {
+              container.innerHTML = loadingHtml;
+            } else {
+              const span = document.createElement("span");
+              span.innerText = "loading...";
+              container.appendChild(span);
+            }
+            return container;
+          });
+          return {
+            decorationSet: DecorationSet.empty.add(tr.doc, [decoration]),
+            hasDecoration: true
+          };
+        }
+        return {
+          decorationSet: oldState.decorationSet.map(tr.mapping, tr.doc),
+          hasDecoration: oldState.hasDecoration
+        };
+      }
+    },
+    props: {
+      decorations(state) {
+        return this.getState(state)?.decorationSet || DecorationSet.empty;
+      }
+    }
+  });
+};
+const parserTokens = {
+  ...defaultMarkdownParser.tokens,
+  em: {
+    mark: "italic"
+  },
+  strong: {
+    mark: "bold"
+  },
+  html_inline: {
+    ignore: true,
+    noCloseToken: true
+  },
+  html_block: {
+    ignore: true,
+    noCloseToken: true
+  },
+  s: {
+    mark: "strike"
+  },
+  task_list: {
+    block: "task_list"
+  },
+  task_item: {
+    block: "task_item",
+    getAttrs: (tok) => ({
+      checked: tok.attrGet("checked") === "true"
+    })
+  },
+  mark: {
+    mark: "highlight"
+  },
+  ins: {
+    mark: "underline"
+  },
+  table: {
+    block: "table"
+  },
+  thead: {
+    ignore: true
+  },
+  tbody: {
+    ignore: true
+  },
+  tr: {
+    block: "table_row"
+  },
+  th: {
+    block: "table_header"
+  },
+  td: {
+    block: "table_cell"
+  }
+};
+const md = markdownIt({
+  html: false
+}).use(markdownItTaskLists).use(markdownItMark).use(markdownItIns);
+md.inline.ruler.at("escape", function escapeOverride(state, silent) {
+  let pos = state.pos;
+  const max = state.posMax;
+  if (state.src.charCodeAt(pos) !== 92) return false;
+  pos++;
+  if (pos >= max) return false;
+  const ch1 = state.src.charCodeAt(pos);
+  if (ch1 === 10) {
+    if (!silent) {
+      state.pending += "\\";
+    }
+    state.pos = pos;
+    return true;
+  }
+  let escapedStr = state.src[pos];
+  if (ch1 >= 55296 && ch1 <= 56319 && pos + 1 < max) {
+    const ch2 = state.src.charCodeAt(pos + 1);
+    if (ch2 >= 56320 && ch2 <= 57343) {
+      escapedStr += state.src[pos + 1];
+      pos++;
+    }
+  }
+  const origStr = "\\" + escapedStr;
+  if (!silent) {
+    const isEscapable = ch1 < 256 && /[\\!"#$%&'()*+,./:;<=>?@[\]^_`{|}~-]/.test(String.fromCharCode(ch1));
+    const token = state.push("text_special", "", 0);
+    if (isEscapable) {
+      token.content = escapedStr;
+    } else {
+      token.content = origStr;
+    }
+    token.markup = origStr;
+    token.info = "escape";
+  }
+  state.pos = pos + 1;
+  return true;
+});
+md.inline.ruler.disable(["newline"]);
+md.core.ruler.after("inline", "image-to-block", (state) => {
+  const tokens = state.tokens;
+  for (let i = tokens.length - 2; i >= 1; i--) {
+    if (tokens[i - 1] && tokens[i - 1].type === "paragraph_open" && tokens[i] && tokens[i].type === "inline" && tokens[i + 1] && tokens[i + 1].type === "paragraph_close") {
+      const inlineTokens = tokens[i].children || [];
+      if (inlineTokens.length === 1 && inlineTokens[0].type === "image") {
+        state.tokens.splice(i - 1, 3, inlineTokens[0]);
+      }
+    }
+  }
+});
+md.core.ruler.after("inline", "tables-wrap-paragraphs", (state) => {
+  const tokens = state.tokens;
+  for (let i = tokens.length - 1; i >= 0; i--) {
+    if (tokens[i].type === "td_open" || tokens[i].type === "th_open") {
+      let closeIndex = i + 1;
+      while (closeIndex < tokens.length && tokens[closeIndex].type !== "td_close" && tokens[closeIndex].type !== "th_close") {
+        closeIndex++;
+      }
+      if (closeIndex < tokens.length) {
+        const pOpen = new state.Token("paragraph_open", "p", 1);
+        pOpen.block = true;
+        const pClose = new state.Token("paragraph_close", "p", -1);
+        pClose.block = true;
+        state.tokens.splice(closeIndex, 0, pClose);
+        state.tokens.splice(i + 1, 0, pOpen);
+      }
+    }
+  }
+});
+const markdownParser = new MarkdownParser(schema, md, parserTokens);
+const markdownSerializer = new MarkdownSerializer({
+  ...defaultMarkdownSerializer.nodes,
+  // Add custom serialization for task lists
+  task_list(state, node) {
+    state.renderList(node, "  ", () => "- ");
+  },
+  task_item(state, node) {
+    state.write(`[${node.attrs.checked ? "x" : " "}] `);
+    state.renderContent(node);
+  },
+  horizontal_rule(state, node) {
+    state.write(node.attrs.markup || "---");
+    state.closeBlock(node);
+  },
+  image(state, node) {
+    const rawSrc = node.attrs.src || "";
+    const src = rawSrc.replace(/ /g, "%20");
+    state.write("![" + state.esc(node.attrs.alt || "") + "](" + src.replace(/[\(\)]/g, "\\$&") + (node.attrs.title ? ' "' + node.attrs.title.replace(/"/g, '\\"') + '"' : "") + ")");
+    state.closeBlock(node);
+  },
+  table(state, node) {
+    node.forEach((row, _, i) => {
+      row.forEach((cell, _2, j) => {
+        state.write(j === 0 ? "| " : " ");
+        let cellContent = "";
+        const oldWrite = state.write.bind(state);
+        state.write = (s) => {
+          cellContent += s;
+        };
+        let first = true;
+        cell.forEach((block) => {
+          if (!first) cellContent += "<br>";
+          state.renderInline(block);
+          first = false;
+        });
+        state.write = oldWrite;
+        state.write(cellContent.replace(/\|/g, "\\|"));
+        state.write(" |");
+      });
+      state.write("\n");
+      if (i === 0) {
+        row.forEach((cell, _2, j) => {
+          state.write(j === 0 ? "|---|" : "---|");
+        });
+        state.write("\n");
+      }
+    });
+    state.closeBlock(node);
+  },
+  table_row() {
+  },
+  table_cell() {
+  },
+  table_header() {
+  },
+  // Custom text serializer: since our parser override keeps `\` as
+  // literal text (instead of consuming it), we must avoid the default
+  // esc() from double-escaping it. We escape all standard markdown
+  // specials *except* the backslash itself.
+  text(state, node) {
+    const escaped = node.text.replace(/[`*~\[\]_]/g, (m, i) => {
+      if (m === "_" && i > 0 && i + 1 < node.text.length && /\w/.test(node.text[i - 1]) && /\w/.test(node.text[i + 1])) {
+        return m;
+      }
+      return "\\" + m;
+    });
+    const lines = escaped.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      state.write();
+      let line = lines[i];
+      if (state.atBlockStart || i > 0) {
+        line = line.replace(/^(\+[ ]|[-*>])/, "\\$&").replace(/^(\s*)(#{1,6})(\s|$)/, "$1\\$2$3").replace(/^(\s*\d+)\.\s/, "$1\\. ");
+      }
+      state.out += line;
+      if (i !== lines.length - 1) state.out += "\n";
+    }
+  }
+}, {
+  ...defaultMarkdownSerializer.marks,
+  bold: defaultMarkdownSerializer.marks.strong,
+  italic: defaultMarkdownSerializer.marks.em,
+  strike: {
+    open: "~~",
+    close: "~~",
+    mixable: true,
+    expelEnclosingWhitespace: true
+  },
+  highlight: {
+    open: "==",
+    close: "==",
+    mixable: true,
+    expelEnclosingWhitespace: true
+  },
+  underline: {
+    open: "++",
+    close: "++",
+    mixable: true,
+    expelEnclosingWhitespace: true
+  },
+  link: {
+    ...defaultMarkdownSerializer.marks.link,
+    close(state, mark, parent, index) {
+      const inAutolink = state.inAutolink;
+      state.inAutolink = void 0;
+      const href = mark.attrs.href.replace(/ /g, "%20");
+      return inAutolink ? ">" : "](" + href.replace(/[\(\)"]/g, "\\$&") + (mark.attrs.title ? ` "${mark.attrs.title.replace(/"/g, '\\"')}"` : "") + ")";
+    }
+  },
+  // textStyle (colored text from HTML) has no markdown equivalent — emit content as-is
+  textStyle: {
+    open: "",
+    close: "",
+    mixable: true,
+    expelEnclosingWhitespace: true
+  }
+});
+const parser = markdownParser;
+const serializer = markdownSerializer;
+const suggestionItems = [{
+  title: "Text",
+  description: "Just start typing with plain text.",
+  searchTerms: ["p", "paragraph"],
+  icon: /* @__PURE__ */ jsx(TextFieldsIcon, { size: 18 }),
+  command: (view, range) => {
+    view.dispatch(view.state.tr.deleteRange(range.from, range.to));
+    setBlockType(schema.nodes.paragraph)(view.state, view.dispatch);
+  }
+}, {
+  title: "To-do List",
+  description: "Track tasks with a to-do list.",
+  searchTerms: ["todo", "task", "list", "check", "checkbox"],
+  icon: /* @__PURE__ */ jsx(CheckBoxIcon, { size: 18 }),
+  command: (view, range) => {
+    view.dispatch(view.state.tr.deleteRange(range.from, range.to));
+    wrapInList(schema.nodes.task_list)(view.state, view.dispatch);
+  }
+}, {
+  title: "Heading 1",
+  description: "Big section heading.",
+  searchTerms: ["title", "big", "large"],
+  icon: /* @__PURE__ */ jsx(LooksOneIcon, { size: 18 }),
+  command: (view, range) => {
+    view.dispatch(view.state.tr.deleteRange(range.from, range.to));
+    setBlockType(schema.nodes.heading, {
+      level: 1
+    })(view.state, view.dispatch);
+  }
+}, {
+  title: "Heading 2",
+  description: "Medium section heading.",
+  searchTerms: ["subtitle", "medium"],
+  icon: /* @__PURE__ */ jsx(LooksTwoIcon, { size: 18 }),
+  command: (view, range) => {
+    view.dispatch(view.state.tr.deleteRange(range.from, range.to));
+    setBlockType(schema.nodes.heading, {
+      level: 2
+    })(view.state, view.dispatch);
+  }
+}, {
+  title: "Heading 3",
+  description: "Small section heading.",
+  searchTerms: ["subtitle", "small"],
+  icon: /* @__PURE__ */ jsx(Looks3Icon, { size: 18 }),
+  command: (view, range) => {
+    view.dispatch(view.state.tr.deleteRange(range.from, range.to));
+    setBlockType(schema.nodes.heading, {
+      level: 3
+    })(view.state, view.dispatch);
+  }
+}, {
+  title: "Bullet List",
+  description: "Create a simple bullet list.",
+  searchTerms: ["unordered", "point"],
+  icon: /* @__PURE__ */ jsx(FormatListBulletedIcon, { size: 18 }),
+  command: (view, range) => {
+    view.dispatch(view.state.tr.deleteRange(range.from, range.to));
+    wrapInList(schema.nodes.bullet_list)(view.state, view.dispatch);
+  }
+}, {
+  title: "Numbered List",
+  description: "Create a list with numbering.",
+  searchTerms: ["ordered"],
+  icon: /* @__PURE__ */ jsx(FormatListNumberedIcon, { size: 18 }),
+  command: (view, range) => {
+    view.dispatch(view.state.tr.deleteRange(range.from, range.to));
+    wrapInList(schema.nodes.ordered_list)(view.state, view.dispatch);
+  }
+}, {
+  title: "Quote",
+  description: "Capture a quote.",
+  searchTerms: ["blockquote"],
+  icon: /* @__PURE__ */ jsx(FormatQuoteIcon, { size: 18 }),
+  command: (view, range) => {
+    view.dispatch(view.state.tr.deleteRange(range.from, range.to));
+    wrapIn(schema.nodes.blockquote)(view.state, view.dispatch);
+  }
+}, {
+  title: "Code",
+  description: "Capture a code snippet.",
+  searchTerms: ["codeblock"],
+  icon: /* @__PURE__ */ jsx(CodeIcon, { size: 18 }),
+  command: (view, range) => {
+    view.dispatch(view.state.tr.deleteRange(range.from, range.to));
+    setBlockType(schema.nodes.code_block)(view.state, view.dispatch);
+  }
+}, {
+  title: "Image",
+  description: "Upload an image from your computer.",
+  searchTerms: ["photo", "picture", "media", "upload", "file"],
+  icon: /* @__PURE__ */ jsx(ImageIcon, { size: 18 }),
+  command: (view, range, upload) => {
+    view.dispatch(view.state.tr.deleteRange(range.from, range.to));
+    const input = document.createElement("input");
+    input.type = "file";
+    input.accept = "image/*";
+    input.onchange = async () => {
+      if (input.files?.length) {
+        const file = input.files[0];
+        if (!file) return;
+        const pos = view.state.selection.from;
+        const images = Array.from(input.files).filter((f) => /image/i.test(f.type));
+        if (images.length === 0) return false;
+        images.forEach((image) => {
+          const reader = new FileReader();
+          reader.onload = async (readerEvent) => {
+            await onFileRead(view, readerEvent, pos, upload, image);
+          };
+          reader.readAsDataURL(image);
+        });
+      }
+      return true;
+    };
+    input.click();
+  }
+}, {
+  title: "Table",
+  description: "Insert a custom grid table.",
+  searchTerms: ["table", "grid", "row", "col"],
+  icon: /* @__PURE__ */ jsx(TableChartIcon, { size: 18 }),
+  command: (view, range, upload, aiController, setSubView) => {
+    if (setSubView) setSubView("table-grid");
+  }
+}];
+const autocompleteSuggestionItem = {
+  title: "Autocomplete",
+  description: "Add text based on the context.",
+  searchTerms: ["ai"],
+  icon: /* @__PURE__ */ jsx(AutoFixHighIcon, { size: 18 }),
+  command: async (view, range, upload, aiController) => {
+    if (!aiController) throw Error("No AiController");
+    view.dispatch(view.state.tr.deleteRange(range.from, range.to));
+    setBlockType(schema.nodes.paragraph)(view.state, view.dispatch);
+    const {
+      state
+    } = view;
+    const {
+      from,
+      to
+    } = state.selection;
+    const textBeforeCursor = state.doc.textBetween(0, from, "\n");
+    const textAfterCursor = state.doc.textBetween(to, state.doc.content.size, "\n");
+    let buffer = "";
+    const result = await aiController.autocomplete(textBeforeCursor, textAfterCursor, (delta) => {
+      buffer += delta;
+      if (delta.length !== 0 && !view.isDestroyed) {
+        textLoadingCommands.toggleLoadingDecoration(view.state, view.dispatch, buffer);
+      }
+    });
+    if (view.isDestroyed) return;
+    try {
+      const unescapedResult = result.replace(/\\n/g, "\n").replace(/\\t/g, "	");
+      const isHTML = /<\/?[a-z][\s\S]*>/i.test(unescapedResult);
+      let parsedDoc;
+      if (isHTML) {
+        const div = document.createElement("div");
+        div.innerHTML = unescapedResult;
+        parsedDoc = DOMParser.fromSchema(view.state.schema).parse(div);
+      } else {
+        parsedDoc = parser.parse(unescapedResult);
+      }
+      if (parsedDoc) {
+        const tr = view.state.tr.replaceWith(view.state.selection.from, view.state.selection.from, parsedDoc.content);
+        view.dispatch(tr);
+      } else {
+        view.dispatch(view.state.tr.insertText(unescapedResult));
+      }
+    } catch (e) {
+      console.error(e);
+      view.dispatch(view.state.tr.insertText(result));
+    }
+  }
+};
+const SlashCommandMenu = ({
+  upload,
+  aiController
+}) => {
+  const {
+    view,
+    state
+  } = useProseMirrorContext();
+  const menuRef = useRef(null);
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [subView, setSubView] = useState(null);
+  const [tableGridCoords, setTableGridCoords] = useState({
+    r: 0,
+    c: 0
+  });
+  const pluginState = state ? SlashCommandPluginKey.getState(state) : null;
+  const isActive = pluginState?.active;
+  const query = pluginState?.query || "";
+  const range = pluginState?.range;
+  const filteredItems = React__default.useMemo(() => {
+    if (!isActive) return [];
+    const availableItems = [...suggestionItems];
+    if (aiController) availableItems.push(autocompleteSuggestionItem);
+    return availableItems.filter((item) => {
+      const inTitle = item.title.toLowerCase().includes(query.toLowerCase());
+      if (inTitle) return inTitle;
+      return item.searchTerms?.some((term) => term.toLowerCase().includes(query.toLowerCase()));
+    });
+  }, [query, isActive, aiController]);
+  useEffect(() => {
+    setSelectedIndex(0);
+  }, [query]);
+  useEffect(() => {
+    if (!isActive) setSubView(null);
+  }, [isActive]);
+  useEffect(() => {
+    if (!view || !isActive || !range || !menuRef.current) return;
+    const start = view.coordsAtPos(range.from);
+    const virtualEl = {
+      getBoundingClientRect() {
+        return {
+          width: 0,
+          height: start.bottom - start.top,
+          x: start.left,
+          y: start.top,
+          top: start.top,
+          left: start.left,
+          right: start.left,
+          bottom: start.bottom
+        };
+      }
+    };
+    const cleanup = autoUpdate(virtualEl, menuRef.current, () => {
+      if (!menuRef.current) return;
+      computePosition(virtualEl, menuRef.current, {
+        placement: "bottom-start",
+        middleware: [offset(4), flip(), shift()],
+        strategy: "fixed"
+      }).then(({
+        x,
+        y
+      }) => {
+        if (menuRef.current) {
+          Object.assign(menuRef.current.style, {
+            left: `${x}px`,
+            top: `${y}px`,
+            visibility: "visible"
+          });
+        }
+      });
+    });
+    return () => cleanup();
+  }, [view, isActive, range]);
+  useEffect(() => {
+    if (!isActive || !view) return;
+    const handleKeyDown = (e) => {
+      if (subView === "table-grid") {
+        if (e.key === "Escape") {
+          e.preventDefault();
+          e.stopPropagation();
+          e.stopImmediatePropagation();
+          setSubView(null);
+          setTableGridCoords({
+            r: 0,
+            c: 0
+          });
+        } else if (e.key === "ArrowUp") {
+          e.preventDefault();
+          e.stopPropagation();
+          setTableGridCoords((prev) => ({
+            r: Math.max(0, prev.r - 1),
+            c: prev.c
+          }));
+        } else if (e.key === "ArrowDown") {
+          e.preventDefault();
+          e.stopPropagation();
+          setTableGridCoords((prev_0) => ({
+            r: Math.min(4, prev_0.r + 1),
+            c: prev_0.c
+          }));
+        } else if (e.key === "ArrowLeft") {
+          e.preventDefault();
+          e.stopPropagation();
+          setTableGridCoords((prev_1) => ({
+            r: prev_1.r,
+            c: Math.max(0, prev_1.c - 1)
+          }));
+        } else if (e.key === "ArrowRight") {
+          e.preventDefault();
+          e.stopPropagation();
+          setTableGridCoords((prev_2) => ({
+            r: prev_2.r,
+            c: Math.min(4, prev_2.c + 1)
+          }));
+        } else if (e.key === "Enter") {
+          e.preventDefault();
+          e.stopPropagation();
+          if (range) {
+            const tableNode = createTableNode(view.state.schema, tableGridCoords.r + 1, tableGridCoords.c + 1);
+            const tr = view.state.tr.replaceWith(range.from, range.to, tableNode);
+            try {
+              const selection = TextSelection.create(tr.doc, range.from + 4);
+              tr.setSelection(selection);
+            } catch (e_0) {
+              console.warn("Could not select first cell", e_0);
+            }
+            tr.setMeta(SlashCommandPluginKey, {
+              active: false
+            });
+            view.dispatch(tr);
+            view.focus();
+            setSubView(null);
+            setTableGridCoords({
+              r: 0,
+              c: 0
+            });
+          }
+        }
+        return;
+      }
+      if (e.key === "ArrowUp") {
+        e.preventDefault();
+        e.stopPropagation();
+        setSelectedIndex((prev_3) => (prev_3 + filteredItems.length - 1) % filteredItems.length);
+      } else if (e.key === "ArrowDown") {
+        e.preventDefault();
+        e.stopPropagation();
+        setSelectedIndex((prev_4) => (prev_4 + 1) % filteredItems.length);
+      } else if (e.key === "Enter") {
+        e.preventDefault();
+        e.stopPropagation();
+        if (filteredItems[selectedIndex] && range) {
+          filteredItems[selectedIndex].command(view, range, upload, aiController, setSubView);
+          setTimeout(() => {
+          }, 0);
+        }
+      } else if (e.key === "Escape") {
+        e.preventDefault();
+        e.stopPropagation();
+        e.stopImmediatePropagation();
+        view.dispatch(view.state.tr.setMeta(SlashCommandPluginKey, {
+          active: false,
+          dismissed: true
+        }));
+      }
+    };
+    window.addEventListener("keydown", handleKeyDown, {
+      capture: true
+    });
+    return () => window.removeEventListener("keydown", handleKeyDown, {
+      capture: true
+    });
+  }, [isActive, selectedIndex, filteredItems, view, range, upload, aiController, subView, tableGridCoords]);
+  const itemRefs = useRef([]);
+  useEffect(() => {
+    if (itemRefs.current[selectedIndex]) {
+      itemRefs.current[selectedIndex]?.scrollIntoView({
+        block: "nearest"
+      });
+    }
+  }, [selectedIndex]);
+  useEffect(() => {
+    if (!subView) {
+      setTableGridCoords({
+        r: 0,
+        c: 0
+      });
+    }
+  }, [subView]);
+  if (!isActive || filteredItems.length === 0) return null;
+  if (subView === "table-grid" && range && view) {
+    return /* @__PURE__ */ jsx("div", { ref: menuRef, onMouseDown: (e_1) => e_1.preventDefault(), style: {
+      position: "fixed",
+      zIndex: 9999,
+      visibility: "hidden"
+    }, className: cls("text-surface-900 dark:text-white rounded-md border bg-white dark:bg-surface-900 p-2 shadow transition-none", defaultBorderMixin), children: /* @__PURE__ */ jsx(TableGridPicker, { hoveredRow: tableGridCoords.r, hoveredCol: tableGridCoords.c, onHover: (r, c2) => setTableGridCoords({
+      r,
+      c: c2
+    }), onSelect: (rows, cols) => {
+      const tableNode_0 = createTableNode(view.state.schema, rows, cols);
+      const tr_0 = view.state.tr.replaceWith(range.from, range.to, tableNode_0);
+      try {
+        const selection_0 = TextSelection.create(tr_0.doc, range.from + 4);
+        tr_0.setSelection(selection_0);
+      } catch (e_2) {
+        console.warn("Could not select first cell", e_2);
+      }
+      tr_0.setMeta(SlashCommandPluginKey, {
+        active: false
+      });
+      view.dispatch(tr_0);
+      view.focus();
+      setSubView(null);
+    } }) });
+  }
+  return /* @__PURE__ */ jsx("div", { ref: menuRef, style: {
+    position: "fixed",
+    zIndex: 9999,
+    visibility: "hidden"
+  }, className: cls("text-surface-900 dark:text-white max-h-[280px] w-72 overflow-y-auto rounded-md border bg-white dark:bg-surface-900 px-1 py-2 shadow transition-none", defaultBorderMixin), children: filteredItems.map((item_0, index) => /* @__PURE__ */ jsxs("button", { ref: (el) => {
+    itemRefs.current[index] = el;
+  }, onClick: (e_3) => {
+    e_3.preventDefault();
+    if (range && view) {
+      item_0.command(view, range, upload, aiController, setSubView);
+      if (!subView) view.focus();
+    }
+  }, onMouseDown: (e_4) => e_4.preventDefault(), className: cls("flex w-full items-center space-x-2 rounded-md px-2 py-1 text-left text-sm hover:bg-blue-50 hover:dark:bg-surface-700", index === selectedIndex ? "bg-blue-100 dark:bg-surface-accent-950" : ""), children: [
+    /* @__PURE__ */ jsx("div", { className: cls("flex h-10 w-10 shrink-0 items-center justify-center rounded-md border bg-white dark:bg-surface-900", defaultBorderMixin), children: item_0.icon }),
+    /* @__PURE__ */ jsxs("div", { className: "flex flex-col overflow-hidden", children: [
+      /* @__PURE__ */ jsx("p", { className: "font-medium truncate", children: item_0.title }),
+      /* @__PURE__ */ jsx("p", { className: "text-xs text-surface-700 dark:text-surface-accent-300 truncate", children: item_0.description })
+    ] })
+  ] }, item_0.title)) });
+};
+const createTableNode = (schema2, rowsCount, colsCount) => {
+  const rows = [];
+  for (let r = 0; r < rowsCount; r++) {
+    const cells = [];
+    for (let c2 = 0; c2 < colsCount; c2++) {
+      const isHeader = r === 0;
+      const cellType = isHeader ? schema2.nodes.table_header : schema2.nodes.table_cell;
+      const cell = cellType.createAndFill();
+      if (cell) cells.push(cell);
+    }
+    const row = schema2.nodes.table_row.create(null, Fragment.from(cells));
+    rows.push(row);
+  }
+  return schema2.nodes.table.create(null, Fragment.from(rows));
+};
+const TableGridPicker = (t0) => {
+  const $ = c(12);
+  const {
+    hoveredRow,
+    hoveredCol,
+    onHover,
+    onSelect
+  } = t0;
+  const t1 = hoveredCol + 1;
+  const t2 = hoveredRow + 1;
+  let t3;
+  if ($[0] !== t1 || $[1] !== t2) {
+    t3 = /* @__PURE__ */ jsxs("span", { className: "text-xs text-gray-500 font-medium mb-1", children: [
+      t1,
+      " x ",
+      t2,
+      " Table"
+    ] });
+    $[0] = t1;
+    $[1] = t2;
+    $[2] = t3;
+  } else {
+    t3 = $[2];
+  }
+  let t4;
+  if ($[3] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t4 = Array.from({
+      length: 5
+    });
+    $[3] = t4;
+  } else {
+    t4 = $[3];
+  }
+  let t5;
+  if ($[4] !== hoveredCol || $[5] !== hoveredRow || $[6] !== onHover || $[7] !== onSelect) {
+    t5 = /* @__PURE__ */ jsx("div", { className: "flex flex-col gap-1", children: t4.map((_, r) => /* @__PURE__ */ jsx("div", { className: "flex gap-1", children: Array.from({
+      length: 5
+    }).map((__0, c2) => /* @__PURE__ */ jsx("div", { className: cls("w-5 h-5 border rounded-sm cursor-pointer transition-colors duration-75", r <= hoveredRow && c2 <= hoveredCol ? "bg-blue-100 border-blue-400 dark:bg-blue-900 dark:border-blue-500" : "bg-white dark:bg-surface-800 border-gray-200 dark:border-gray-700 hover:border-blue-300"), onMouseEnter: () => onHover(r, c2), onClick: () => onSelect(hoveredRow + 1, hoveredCol + 1) }, c2)) }, r)) });
+    $[4] = hoveredCol;
+    $[5] = hoveredRow;
+    $[6] = onHover;
+    $[7] = onSelect;
+    $[8] = t5;
+  } else {
+    t5 = $[8];
+  }
+  let t6;
+  if ($[9] !== t3 || $[10] !== t5) {
+    t6 = /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1 items-center justify-center p-1 w-fit", children: [
+      t3,
+      t5
+    ] });
+    $[9] = t3;
+    $[10] = t5;
+    $[11] = t6;
+  } else {
+    t6 = $[11];
+  }
+  return t6;
+};
+const ImageBubble = forwardRef((t0, ref) => {
+  const $ = c(36);
+  const {
+    options,
+    className
+  } = t0;
+  const {
+    view,
+    state
+  } = useProseMirrorContext();
+  const menuRef = useRef(null);
+  const [show, setShow] = useState(false);
+  const [alt, setAlt] = useState("");
+  const [title, setTitle] = useState("");
+  const [imagePos, setImagePos] = useState(null);
+  let t1;
+  let t2;
+  if ($[0] !== view) {
+    t1 = () => {
+      if (!view) {
+        return;
+      }
+      const handleContextMenu = (e) => {
+        const posInfo = view.posAtCoords({
+          left: e.clientX,
+          top: e.clientY
+        });
+        if (posInfo && posInfo.inside >= 0) {
+          const node = view.state.doc.nodeAt(posInfo.inside);
+          if (node && node.type.name === "image") {
+            e.preventDefault();
+            const tr = view.state.tr.setSelection(NodeSelection.create(view.state.doc, posInfo.inside));
+            view.dispatch(tr);
+            setShow(true);
+            setAlt(node.attrs.alt || "");
+            setTitle(node.attrs.title || "");
+            setImagePos(posInfo.inside);
+          }
+        }
+      };
+      view.dom.addEventListener("contextmenu", handleContextMenu);
+      const handleMousedown = (e_0) => {
+        if (menuRef.current && !menuRef.current.contains(e_0.target) && e_0.button !== 2) {
+          setShow(false);
+        }
+      };
+      document.addEventListener("mousedown", handleMousedown);
+      return () => {
+        view.dom.removeEventListener("contextmenu", handleContextMenu);
+        document.removeEventListener("mousedown", handleMousedown);
+      };
+    };
+    t2 = [view];
+    $[0] = view;
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t1 = $[1];
+    t2 = $[2];
+  }
+  useEffect(t1, t2);
+  let t3;
+  if ($[3] !== options?.offset || $[4] !== options?.placement || $[5] !== show || $[6] !== state || $[7] !== view) {
+    t3 = () => {
+      if (!show || !view || !state || !menuRef.current) {
+        return;
+      }
+      const {
+        from,
+        to
+      } = state.selection;
+      let start;
+      start = view.coordsAtPos(from);
+      let end;
+      end = view.coordsAtPos(to);
+      const virtualEl = {
+        getBoundingClientRect() {
+          const top = Math.min(start.top, end.top);
+          const bottom = Math.max(start.bottom, end.bottom);
+          const left = Math.min(start.left, end.left);
+          const right = Math.max(start.right, end.right);
+          return {
+            width: right - left,
+            height: bottom - top,
+            x: left,
+            y: top,
+            top,
+            left,
+            right,
+            bottom
+          };
+        }
+      };
+      const cleanup = autoUpdate(virtualEl, menuRef.current, () => {
+        if (!menuRef.current) {
+          return;
+        }
+        try {
+          start = view.coordsAtPos(state.selection.from);
+          end = view.coordsAtPos(state.selection.to);
+        } catch (t42) {
+        }
+        computePosition(virtualEl, menuRef.current, {
+          placement: options?.placement || "bottom",
+          middleware: [offset(options?.offset || 8), flip(), shift()],
+          strategy: "fixed"
+        }).then((t52) => {
+          const {
+            x,
+            y
+          } = t52;
+          if (menuRef.current) {
+            Object.assign(menuRef.current.style, {
+              left: `${x}px`,
+              top: `${y}px`,
+              visibility: "visible"
+            });
+          }
+        });
+      });
+      return () => cleanup();
+    };
+    $[3] = options?.offset;
+    $[4] = options?.placement;
+    $[5] = show;
+    $[6] = state;
+    $[7] = view;
+    $[8] = t3;
+  } else {
+    t3 = $[8];
+  }
+  let t4;
+  if ($[9] !== options || $[10] !== show || $[11] !== state || $[12] !== view) {
+    t4 = [show, view, state, options];
+    $[9] = options;
+    $[10] = show;
+    $[11] = state;
+    $[12] = view;
+    $[13] = t4;
+  } else {
+    t4 = $[13];
+  }
+  useEffect(t3, t4);
+  let t5;
+  if ($[14] !== imagePos || $[15] !== view) {
+    t5 = (newAlt, newTitle) => {
+      if (imagePos !== null && view) {
+        const node_0 = view.state.doc.nodeAt(imagePos);
+        if (node_0 && node_0.type.name === "image") {
+          const tr_0 = view.state.tr.setNodeMarkup(imagePos, void 0, {
+            ...node_0.attrs,
+            alt: newAlt,
+            title: newTitle
+          });
+          tr_0.setSelection(NodeSelection.create(tr_0.doc, imagePos));
+          view.dispatch(tr_0);
+        }
+      }
+    };
+    $[14] = imagePos;
+    $[15] = view;
+    $[16] = t5;
+  } else {
+    t5 = $[16];
+  }
+  const handleSave = t5;
+  if (!show) {
+    return null;
+  }
+  let t6;
+  if ($[17] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t6 = {
+      visibility: "hidden",
+      position: "fixed",
+      zIndex: 50
+    };
+    $[17] = t6;
+  } else {
+    t6 = $[17];
+  }
+  let t7;
+  if ($[18] !== className) {
+    t7 = cls("flex flex-col gap-1.5 p-2 w-56 max-w-[90vw] rounded-lg border bg-white dark:bg-surface-900 shadow-lg", defaultBorderMixin, className);
+    $[18] = className;
+    $[19] = t7;
+  } else {
+    t7 = $[19];
+  }
+  let t8;
+  if ($[20] !== handleSave || $[21] !== title) {
+    t8 = (e_3) => {
+      setAlt(e_3.target.value);
+      handleSave(e_3.target.value, title);
+    };
+    $[20] = handleSave;
+    $[21] = title;
+    $[22] = t8;
+  } else {
+    t8 = $[22];
+  }
+  let t9;
+  if ($[23] !== alt || $[24] !== t8) {
+    t9 = /* @__PURE__ */ jsx(TextField, { size: "small", placeholder: "Alt text", value: alt, onChange: t8 });
+    $[23] = alt;
+    $[24] = t8;
+    $[25] = t9;
+  } else {
+    t9 = $[25];
+  }
+  let t10;
+  if ($[26] !== alt || $[27] !== handleSave) {
+    t10 = (e_4) => {
+      setTitle(e_4.target.value);
+      handleSave(alt, e_4.target.value);
+    };
+    $[26] = alt;
+    $[27] = handleSave;
+    $[28] = t10;
+  } else {
+    t10 = $[28];
+  }
+  let t11;
+  if ($[29] !== t10 || $[30] !== title) {
+    t11 = /* @__PURE__ */ jsx(TextField, { size: "small", placeholder: "Title", value: title, onChange: t10 });
+    $[29] = t10;
+    $[30] = title;
+    $[31] = t11;
+  } else {
+    t11 = $[31];
+  }
+  let t12;
+  if ($[32] !== t11 || $[33] !== t7 || $[34] !== t9) {
+    t12 = /* @__PURE__ */ jsxs("div", { ref: menuRef, style: t6, className: t7, onMouseDown: _temp$3, children: [
+      t9,
+      t11
+    ] });
+    $[32] = t11;
+    $[33] = t7;
+    $[34] = t9;
+    $[35] = t12;
+  } else {
+    t12 = $[35];
+  }
+  return t12;
+});
+function _temp$3(e_2) {
+  if (e_2.target === e_2.currentTarget) {
+    e_2.preventDefault();
+  }
+}
+const isSelectionInTable = (state) => {
+  const {
+    $from
+  } = state.selection;
+  for (let d = $from.depth; d > 0; d--) {
+    if ($from.node(d).type.name === "table") {
+      return true;
+    }
+  }
+  return false;
+};
+const TableBubble = forwardRef((t0, ref) => {
+  const $ = c(69);
+  const {
+    options,
+    className
+  } = t0;
+  const {
+    view,
+    state
+  } = useProseMirrorContext();
+  const menuRef = useRef(null);
+  const [show, setShow] = useState(false);
+  let t1;
+  if ($[0] !== state) {
+    t1 = () => {
+      if (!state) {
+        return;
+      }
+      setShow(isSelectionInTable(state));
+    };
+    $[0] = state;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const t2 = state?.selection;
+  let t3;
+  if ($[2] !== t2) {
+    t3 = [t2];
+    $[2] = t2;
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  useEffect(t1, t3);
+  let t4;
+  if ($[4] !== options?.offset || $[5] !== options?.placement || $[6] !== show || $[7] !== state || $[8] !== view) {
+    t4 = () => {
+      if (!show || !view || !state || !menuRef.current) {
+        return;
+      }
+      const {
+        from,
+        to
+      } = state.selection;
+      if (view.isDestroyed) {
+        return;
+      }
+      let start;
+      start = view.coordsAtPos(from);
+      let end;
+      end = view.coordsAtPos(to);
+      const virtualEl = {
+        getBoundingClientRect() {
+          const top = Math.min(start.top, end.top);
+          const bottom = Math.max(start.bottom, end.bottom);
+          const left = Math.min(start.left, end.left);
+          const right = Math.max(start.right, end.right);
+          return {
+            width: right - left,
+            height: bottom - top,
+            x: left,
+            y: top,
+            top,
+            bottom,
+            left,
+            right
+          };
+        }
+      };
+      const cleanup = autoUpdate(virtualEl, menuRef.current, () => {
+        if (!menuRef.current || view.isDestroyed) {
+          return;
+        }
+        try {
+          start = view.coordsAtPos(state.selection.from);
+          end = view.coordsAtPos(state.selection.to);
+        } catch (t52) {
+        }
+        computePosition(virtualEl, menuRef.current, {
+          placement: options?.placement || "top",
+          middleware: [offset(options?.offset || 8), flip(), shift()],
+          strategy: "fixed"
+        }).then((t62) => {
+          const {
+            x,
+            y
+          } = t62;
+          if (menuRef.current) {
+            Object.assign(menuRef.current.style, {
+              left: `${x}px`,
+              top: `${y}px`,
+              visibility: "visible"
+            });
+          }
+        });
+      });
+      return () => cleanup();
+    };
+    $[4] = options?.offset;
+    $[5] = options?.placement;
+    $[6] = show;
+    $[7] = state;
+    $[8] = view;
+    $[9] = t4;
+  } else {
+    t4 = $[9];
+  }
+  let t5;
+  if ($[10] !== options || $[11] !== show || $[12] !== state || $[13] !== view) {
+    t5 = [show, view, state, options];
+    $[10] = options;
+    $[11] = show;
+    $[12] = state;
+    $[13] = view;
+    $[14] = t5;
+  } else {
+    t5 = $[14];
+  }
+  useEffect(t4, t5);
+  if (!show || !view || !state) {
+    return null;
+  }
+  let t6;
+  if ($[15] !== state || $[16] !== view) {
+    t6 = (cmd) => {
+      cmd(state, view.dispatch);
+      view.focus();
+    };
+    $[15] = state;
+    $[16] = view;
+    $[17] = t6;
+  } else {
+    t6 = $[17];
+  }
+  const executeCommand = t6;
+  let t7;
+  if ($[18] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t7 = {
+      visibility: "hidden",
+      position: "fixed",
+      zIndex: 50
+    };
+    $[18] = t7;
+  } else {
+    t7 = $[18];
+  }
+  let t8;
+  if ($[19] !== className) {
+    t8 = cls("flex flex-row gap-1 p-1 rounded-lg border bg-white dark:bg-surface-900 shadow-lg", defaultBorderMixin, className);
+    $[19] = className;
+    $[20] = t8;
+  } else {
+    t8 = $[20];
+  }
+  let t9;
+  if ($[21] !== executeCommand) {
+    t9 = () => executeCommand(addRowBefore);
+    $[21] = executeCommand;
+    $[22] = t9;
+  } else {
+    t9 = $[22];
+  }
+  let t10;
+  if ($[23] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t10 = /* @__PURE__ */ jsxs("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+      /* @__PURE__ */ jsx("rect", { x: "3", y: "3", width: "18", height: "18", rx: "2", ry: "2" }),
+      /* @__PURE__ */ jsx("line", { x1: "12", y1: "8", x2: "12", y2: "16" }),
+      /* @__PURE__ */ jsx("line", { x1: "8", y1: "12", x2: "16", y2: "12" }),
+      /* @__PURE__ */ jsx("line", { x1: "3", y1: "9", x2: "21", y2: "9" })
+    ] });
+    $[23] = t10;
+  } else {
+    t10 = $[23];
+  }
+  let t11;
+  if ($[24] !== t9) {
+    t11 = /* @__PURE__ */ jsx(Tooltip, { title: "Add row before", children: /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: t9, children: t10 }) });
+    $[24] = t9;
+    $[25] = t11;
+  } else {
+    t11 = $[25];
+  }
+  let t12;
+  if ($[26] !== executeCommand) {
+    t12 = () => executeCommand(addRowAfter);
+    $[26] = executeCommand;
+    $[27] = t12;
+  } else {
+    t12 = $[27];
+  }
+  let t13;
+  if ($[28] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t13 = /* @__PURE__ */ jsxs("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+      /* @__PURE__ */ jsx("rect", { x: "3", y: "3", width: "18", height: "18", rx: "2", ry: "2" }),
+      /* @__PURE__ */ jsx("line", { x1: "12", y1: "12", x2: "12", y2: "20" }),
+      /* @__PURE__ */ jsx("line", { x1: "8", y1: "16", x2: "16", y2: "16" }),
+      /* @__PURE__ */ jsx("line", { x1: "3", y1: "15", x2: "21", y2: "15" })
+    ] });
+    $[28] = t13;
+  } else {
+    t13 = $[28];
+  }
+  let t14;
+  if ($[29] !== t12) {
+    t14 = /* @__PURE__ */ jsx(Tooltip, { title: "Add row after", children: /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: t12, children: t13 }) });
+    $[29] = t12;
+    $[30] = t14;
+  } else {
+    t14 = $[30];
+  }
+  let t15;
+  if ($[31] !== executeCommand) {
+    t15 = () => executeCommand(deleteRow);
+    $[31] = executeCommand;
+    $[32] = t15;
+  } else {
+    t15 = $[32];
+  }
+  let t16;
+  if ($[33] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t16 = /* @__PURE__ */ jsxs("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+      /* @__PURE__ */ jsx("rect", { x: "3", y: "3", width: "18", height: "18", rx: "2", ry: "2" }),
+      /* @__PURE__ */ jsx("line", { x1: "3", y1: "12", x2: "21", y2: "12" }),
+      /* @__PURE__ */ jsx("line", { x1: "8", y1: "12", x2: "16", y2: "12" })
+    ] });
+    $[33] = t16;
+  } else {
+    t16 = $[33];
+  }
+  let t17;
+  if ($[34] !== t15) {
+    t17 = /* @__PURE__ */ jsx(Tooltip, { title: "Delete row", children: /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: t15, children: t16 }) });
+    $[34] = t15;
+    $[35] = t17;
+  } else {
+    t17 = $[35];
+  }
+  let t18;
+  if ($[36] !== t11 || $[37] !== t14 || $[38] !== t17) {
+    t18 = /* @__PURE__ */ jsxs("div", { className: "flex gap-1 border-r pr-1 mr-1 dark:border-gray-700", children: [
+      t11,
+      t14,
+      t17
+    ] });
+    $[36] = t11;
+    $[37] = t14;
+    $[38] = t17;
+    $[39] = t18;
+  } else {
+    t18 = $[39];
+  }
+  let t19;
+  if ($[40] !== executeCommand) {
+    t19 = () => executeCommand(addColumnBefore);
+    $[40] = executeCommand;
+    $[41] = t19;
+  } else {
+    t19 = $[41];
+  }
+  let t20;
+  if ($[42] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t20 = /* @__PURE__ */ jsxs("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+      /* @__PURE__ */ jsx("rect", { x: "3", y: "3", width: "18", height: "18", rx: "2", ry: "2" }),
+      /* @__PURE__ */ jsx("line", { x1: "8", y1: "12", x2: "16", y2: "12" }),
+      /* @__PURE__ */ jsx("line", { x1: "12", y1: "8", x2: "12", y2: "16" }),
+      /* @__PURE__ */ jsx("line", { x1: "9", y1: "3", x2: "9", y2: "21" })
+    ] });
+    $[42] = t20;
+  } else {
+    t20 = $[42];
+  }
+  let t21;
+  if ($[43] !== t19) {
+    t21 = /* @__PURE__ */ jsx(Tooltip, { title: "Add column before", children: /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: t19, children: t20 }) });
+    $[43] = t19;
+    $[44] = t21;
+  } else {
+    t21 = $[44];
+  }
+  let t22;
+  if ($[45] !== executeCommand) {
+    t22 = () => executeCommand(addColumnAfter);
+    $[45] = executeCommand;
+    $[46] = t22;
+  } else {
+    t22 = $[46];
+  }
+  let t23;
+  if ($[47] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t23 = /* @__PURE__ */ jsxs("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+      /* @__PURE__ */ jsx("rect", { x: "3", y: "3", width: "18", height: "18", rx: "2", ry: "2" }),
+      /* @__PURE__ */ jsx("line", { x1: "12", y1: "12", x2: "20", y2: "12" }),
+      /* @__PURE__ */ jsx("line", { x1: "16", y1: "8", x2: "16", y2: "16" }),
+      /* @__PURE__ */ jsx("line", { x1: "15", y1: "3", x2: "15", y2: "21" })
+    ] });
+    $[47] = t23;
+  } else {
+    t23 = $[47];
+  }
+  let t24;
+  if ($[48] !== t22) {
+    t24 = /* @__PURE__ */ jsx(Tooltip, { title: "Add column after", children: /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: t22, children: t23 }) });
+    $[48] = t22;
+    $[49] = t24;
+  } else {
+    t24 = $[49];
+  }
+  let t25;
+  if ($[50] !== executeCommand) {
+    t25 = () => executeCommand(deleteColumn);
+    $[50] = executeCommand;
+    $[51] = t25;
+  } else {
+    t25 = $[51];
+  }
+  let t26;
+  if ($[52] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t26 = /* @__PURE__ */ jsxs("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+      /* @__PURE__ */ jsx("rect", { x: "3", y: "3", width: "18", height: "18", rx: "2", ry: "2" }),
+      /* @__PURE__ */ jsx("line", { x1: "12", y1: "3", x2: "12", y2: "21" }),
+      /* @__PURE__ */ jsx("line", { x1: "12", y1: "8", x2: "12", y2: "16" })
+    ] });
+    $[52] = t26;
+  } else {
+    t26 = $[52];
+  }
+  let t27;
+  if ($[53] !== t25) {
+    t27 = /* @__PURE__ */ jsx(Tooltip, { title: "Delete column", children: /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: t25, children: t26 }) });
+    $[53] = t25;
+    $[54] = t27;
+  } else {
+    t27 = $[54];
+  }
+  let t28;
+  if ($[55] !== t21 || $[56] !== t24 || $[57] !== t27) {
+    t28 = /* @__PURE__ */ jsxs("div", { className: "flex gap-1 border-r pr-1 mr-1 dark:border-gray-700", children: [
+      t21,
+      t24,
+      t27
+    ] });
+    $[55] = t21;
+    $[56] = t24;
+    $[57] = t27;
+    $[58] = t28;
+  } else {
+    t28 = $[58];
+  }
+  let t29;
+  if ($[59] !== executeCommand) {
+    t29 = () => executeCommand(deleteTable);
+    $[59] = executeCommand;
+    $[60] = t29;
+  } else {
+    t29 = $[60];
+  }
+  let t30;
+  if ($[61] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t30 = /* @__PURE__ */ jsxs("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+      /* @__PURE__ */ jsx("polyline", { points: "3 6 5 6 21 6" }),
+      /* @__PURE__ */ jsx("path", { d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2" }),
+      /* @__PURE__ */ jsx("line", { x1: "10", y1: "11", x2: "10", y2: "17" }),
+      /* @__PURE__ */ jsx("line", { x1: "14", y1: "11", x2: "14", y2: "17" })
+    ] });
+    $[61] = t30;
+  } else {
+    t30 = $[61];
+  }
+  let t31;
+  if ($[62] !== t29) {
+    t31 = /* @__PURE__ */ jsx(Tooltip, { title: "Delete table", children: /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: t29, children: t30 }) });
+    $[62] = t29;
+    $[63] = t31;
+  } else {
+    t31 = $[63];
+  }
+  let t32;
+  if ($[64] !== t18 || $[65] !== t28 || $[66] !== t31 || $[67] !== t8) {
+    t32 = /* @__PURE__ */ jsxs("div", { ref: menuRef, style: t7, className: t8, onMouseDown: _temp$2, children: [
+      t18,
+      t28,
+      t31
+    ] });
+    $[64] = t18;
+    $[65] = t28;
+    $[66] = t31;
+    $[67] = t8;
+    $[68] = t32;
+  } else {
+    t32 = $[68];
+  }
+  return t32;
+});
+function _temp$2(e_0) {
+  e_0.preventDefault();
+}
+function isMarkActive(state, type) {
+  if (!state || !type) return false;
+  const {
+    from,
+    $from,
+    to,
+    empty
+  } = state.selection;
+  if (empty) return !!type.isInSet(state.storedMarks || $from.marks());
+  return state.doc.rangeHasMark(from, to, type);
+}
+function isNodeActive(state, type, attrs = {}) {
+  if (!state || !type) return false;
+  const {
+    $from,
+    to,
+    node
+  } = state.selection;
+  if (node) {
+    return node.type === type && (!attrs || Object.keys(attrs).every((key) => node.attrs[key] === attrs[key]));
+  }
+  return to <= $from.end() && $from.parent.type === type && (!attrs || Object.keys(attrs).every((key) => $from.parent.attrs[key] === attrs[key]));
+}
+function getMarkAttributes(state, type) {
+  if (!state || !type) return {};
+  const {
+    from,
+    $from,
+    to,
+    empty
+  } = state.selection;
+  let mark;
+  if (empty) {
+    mark = type.isInSet(state.storedMarks || $from.marks());
+  } else {
+    let found = false;
+    state.doc.nodesBetween(from, to, (node) => {
+      if (found) return false;
+      const m = type.isInSet(node.marks);
+      if (m) {
+        mark = m;
+        found = true;
+      }
+      return true;
+    });
+  }
+  return mark ? mark.attrs : {};
+}
+function setMark(type, attrs) {
+  return (state, dispatch) => {
+    const {
+      empty,
+      $cursor,
+      ranges
+    } = state.selection;
+    if (empty && !$cursor || !type) return false;
+    if (dispatch) {
+      if ($cursor) {
+        dispatch(state.tr.addStoredMark(type.create(attrs)));
+      } else {
+        let tr = state.tr;
+        for (let i = 0; i < ranges.length; i++) {
+          let {
+            $from,
+            $to
+          } = ranges[i];
+          tr.addMark($from.pos, $to.pos, type.create(attrs));
+        }
+        dispatch(tr.scrollIntoView());
+      }
+    }
+    return true;
+  };
+}
+function unsetMark(type) {
+  return (state, dispatch) => {
+    const {
+      empty,
+      $cursor,
+      ranges
+    } = state.selection;
+    if (empty && !$cursor || !type) return false;
+    if (dispatch) {
+      let tr = state.tr;
+      if ($cursor) {
+        const parent = $cursor.parent;
+        let markStart = -1;
+        let markEnd = -1;
+        let currentMarkStart = -1;
+        parent.forEach((child, offset2) => {
+          const childStart = $cursor.start() + offset2;
+          const childEnd = childStart + child.nodeSize;
+          if (type.isInSet(child.marks)) {
+            if (currentMarkStart === -1) currentMarkStart = childStart;
+            if ($cursor.pos >= childStart && $cursor.pos <= childEnd) {
+              markStart = currentMarkStart;
+            }
+          } else {
+            if (currentMarkStart !== -1) {
+              if (markStart !== -1 && markEnd === -1) markEnd = childStart;
+              currentMarkStart = -1;
+            }
+          }
+        });
+        if (markStart !== -1 && markEnd === -1) {
+          markEnd = $cursor.end();
+        }
+        if (markStart !== -1 && markEnd !== -1) {
+          tr.removeMark(markStart, markEnd, type);
+        }
+        tr.removeStoredMark(type);
+        dispatch(tr.scrollIntoView());
+      } else {
+        for (let i = 0; i < ranges.length; i++) {
+          let {
+            $from,
+            $to
+          } = ranges[i];
+          tr.removeMark($from.pos, $to.pos, type);
+        }
+        dispatch(tr.scrollIntoView());
+      }
+    }
+    return true;
+  };
+}
+const items = [{
+  name: "Text",
+  labelKey: "editor_text",
+  icon: TextFieldsIcon,
+  command: (state, dispatch) => setBlockType(schema.nodes.paragraph)(state, dispatch),
+  isActive: (state) => isNodeActive(state, schema.nodes.paragraph) && !isNodeActive(state, schema.nodes.bullet_list) && !isNodeActive(state, schema.nodes.ordered_list)
+}, {
+  name: "Heading 1",
+  labelKey: "editor_heading_1",
+  icon: LooksOneIcon,
+  command: (state, dispatch) => setBlockType(schema.nodes.heading, {
+    level: 1
+  })(state, dispatch),
+  isActive: (state) => isNodeActive(state, schema.nodes.heading, {
+    level: 1
+  })
+}, {
+  name: "Heading 2",
+  labelKey: "editor_heading_2",
+  icon: LooksTwoIcon,
+  command: (state, dispatch) => setBlockType(schema.nodes.heading, {
+    level: 2
+  })(state, dispatch),
+  isActive: (state) => isNodeActive(state, schema.nodes.heading, {
+    level: 2
+  })
+}, {
+  name: "Heading 3",
+  labelKey: "editor_heading_3",
+  icon: Looks3Icon,
+  command: (state, dispatch) => setBlockType(schema.nodes.heading, {
+    level: 3
+  })(state, dispatch),
+  isActive: (state) => isNodeActive(state, schema.nodes.heading, {
+    level: 3
+  })
+}, {
+  name: "To-do List",
+  labelKey: "editor_todo_list",
+  icon: CheckBoxIcon,
+  command: (state, dispatch) => wrapInList(schema.nodes.task_list)(state, dispatch),
+  isActive: (state) => isNodeActive(state, schema.nodes.task_item)
+}, {
+  name: "Bullet List",
+  labelKey: "editor_bullet_list",
+  icon: FormatListBulletedIcon,
+  command: (state, dispatch) => wrapInList(schema.nodes.bullet_list)(state, dispatch),
+  isActive: (state) => isNodeActive(state, schema.nodes.bullet_list)
+}, {
+  name: "Numbered List",
+  labelKey: "editor_numbered_list",
+  icon: FormatListNumberedIcon,
+  command: (state, dispatch) => wrapInList(schema.nodes.ordered_list)(state, dispatch),
+  isActive: (state) => isNodeActive(state, schema.nodes.ordered_list)
+}, {
+  name: "Quote",
+  labelKey: "editor_quote",
+  icon: FormatQuoteIcon,
+  command: (state, dispatch) => wrapIn(schema.nodes.blockquote)(state, dispatch),
+  isActive: (state) => isNodeActive(state, schema.nodes.blockquote)
+}, {
+  name: "Code",
+  labelKey: "editor_code",
+  icon: CodeIcon,
+  command: (state, dispatch) => setBlockType(schema.nodes.code_block)(state, dispatch),
+  isActive: (state) => isNodeActive(state, schema.nodes.code_block)
+}];
+const NodeSelector = (t0) => {
+  const $ = c(40);
+  const {
+    open,
+    onOpenChange,
+    portalContainer
+  } = t0;
+  const {
+    state,
+    view
+  } = useProseMirrorContext();
+  const {
+    t
+  } = useTranslation();
+  if (!state || !view) {
+    return null;
+  }
+  let T0;
+  let T1;
+  let activeItem;
+  let t1;
+  let t2;
+  let t3;
+  let t4;
+  let t5;
+  let t6;
+  let t7;
+  let t8;
+  let t9;
+  if ($[0] !== portalContainer || $[1] !== state || $[2] !== t) {
+    activeItem = items.filter((item) => item.isActive(state)).pop() ?? {
+      name: "Multiple",
+      labelKey: "editor_multiple"
+    };
+    T1 = Popover;
+    t6 = 5;
+    t7 = "start";
+    t8 = portalContainer;
+    t9 = "w-48 p-1";
+    T0 = Button;
+    t3 = "text";
+    t4 = "gap-2 rounded-none";
+    t5 = "text";
+    t1 = "whitespace-nowrap text-sm";
+    t2 = t(activeItem.labelKey);
+    $[0] = portalContainer;
+    $[1] = state;
+    $[2] = t;
+    $[3] = T0;
+    $[4] = T1;
+    $[5] = activeItem;
+    $[6] = t1;
+    $[7] = t2;
+    $[8] = t3;
+    $[9] = t4;
+    $[10] = t5;
+    $[11] = t6;
+    $[12] = t7;
+    $[13] = t8;
+    $[14] = t9;
+  } else {
+    T0 = $[3];
+    T1 = $[4];
+    activeItem = $[5];
+    t1 = $[6];
+    t2 = $[7];
+    t3 = $[8];
+    t4 = $[9];
+    t5 = $[10];
+    t6 = $[11];
+    t7 = $[12];
+    t8 = $[13];
+    t9 = $[14];
+  }
+  let t10;
+  if ($[15] !== t1 || $[16] !== t2) {
+    t10 = /* @__PURE__ */ jsx("span", { className: t1, children: t2 });
+    $[15] = t1;
+    $[16] = t2;
+    $[17] = t10;
+  } else {
+    t10 = $[17];
+  }
+  let t11;
+  if ($[18] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t11 = /* @__PURE__ */ jsx(KeyboardArrowDownIcon, { size: "small" });
+    $[18] = t11;
+  } else {
+    t11 = $[18];
+  }
+  let t12;
+  if ($[19] !== T0 || $[20] !== t10 || $[21] !== t3 || $[22] !== t4 || $[23] !== t5) {
+    t12 = /* @__PURE__ */ jsxs(T0, { variant: t3, className: t4, color: t5, children: [
+      t10,
+      t11
+    ] });
+    $[19] = T0;
+    $[20] = t10;
+    $[21] = t3;
+    $[22] = t4;
+    $[23] = t5;
+    $[24] = t12;
+  } else {
+    t12 = $[24];
+  }
+  let t13;
+  if ($[25] !== activeItem || $[26] !== onOpenChange || $[27] !== t || $[28] !== view) {
+    t13 = items.map((item_0, index) => /* @__PURE__ */ jsxs(EditorBubbleItem, { onSelect: () => {
+      item_0.command(view.state, view.dispatch);
+      view.focus();
+      onOpenChange(false);
+    }, className: "flex cursor-pointer items-center justify-between rounded px-2 py-1 text-sm hover:bg-blue-50 hover:dark:bg-surface-700 text-surface-900 dark:text-white", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center space-x-2", children: [
+        /* @__PURE__ */ jsx(item_0.icon, { size: "smallest" }),
+        /* @__PURE__ */ jsx("span", { children: t(item_0.labelKey) })
+      ] }),
+      activeItem.name === item_0.name && /* @__PURE__ */ jsx(CheckIcon, { size: "smallest" })
+    ] }, index));
+    $[25] = activeItem;
+    $[26] = onOpenChange;
+    $[27] = t;
+    $[28] = view;
+    $[29] = t13;
+  } else {
+    t13 = $[29];
+  }
+  let t14;
+  if ($[30] !== T1 || $[31] !== onOpenChange || $[32] !== open || $[33] !== t12 || $[34] !== t13 || $[35] !== t6 || $[36] !== t7 || $[37] !== t8 || $[38] !== t9) {
+    t14 = /* @__PURE__ */ jsx(T1, { sideOffset: t6, align: t7, portalContainer: t8, className: t9, trigger: t12, modal: true, open, onOpenChange, children: t13 });
+    $[30] = T1;
+    $[31] = onOpenChange;
+    $[32] = open;
+    $[33] = t12;
+    $[34] = t13;
+    $[35] = t6;
+    $[36] = t7;
+    $[37] = t8;
+    $[38] = t9;
+    $[39] = t14;
+  } else {
+    t14 = $[39];
+  }
+  return t14;
+};
+function isValidUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function getUrlFromString(str) {
+  if (isValidUrl(str)) return str;
+  try {
+    if (str.includes(".") && !str.includes(" ")) {
+      return new URL(`https://${str}`).toString();
+    }
+    return null;
+  } catch (e) {
+    return null;
+  }
+}
+const LinkSelector = (t0) => {
+  const $ = c(58);
+  const {
+    open,
+    onOpenChange
+  } = t0;
+  const inputRef = useRef(null);
+  const {
+    state,
+    view
+  } = useProseMirrorContext();
+  const {
+    t
+  } = useTranslation();
+  let t1;
+  let t2;
+  if ($[0] !== open) {
+    t1 = () => {
+      if (open && inputRef.current) {
+        inputRef.current.focus();
+      }
+    };
+    t2 = [open];
+    $[0] = open;
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t1 = $[1];
+    t2 = $[2];
+  }
+  useEffect(t1, t2);
+  if (!state || !view) {
+    return null;
+  }
+  let t3;
+  if ($[3] !== onOpenChange || $[4] !== view) {
+    t3 = (e) => {
+      e.preventDefault();
+      const value = inputRef.current?.value;
+      if (!value) {
+        return;
+      }
+      const url = getUrlFromString(value);
+      if (url) {
+        setMark(schema.marks.link, {
+          href: url
+        })(view.state, view.dispatch);
+        view.focus();
+        onOpenChange(false);
+      }
+    };
+    $[3] = onOpenChange;
+    $[4] = view;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  const handleSubmit = t3;
+  let t4;
+  if ($[6] !== onOpenChange || $[7] !== view) {
+    t4 = () => {
+      unsetMark(schema.marks.link)(view.state, view.dispatch);
+      view.focus();
+      onOpenChange(false);
+    };
+    $[6] = onOpenChange;
+    $[7] = view;
+    $[8] = t4;
+  } else {
+    t4 = $[8];
+  }
+  const handleRemoveLink = t4;
+  let T0;
+  let T1;
+  let href;
+  let t10;
+  let t11;
+  let t12;
+  let t5;
+  let t6;
+  let t7;
+  let t8;
+  let t9;
+  if ($[9] !== onOpenChange || $[10] !== open || $[11] !== state) {
+    const isActive = isMarkActive(state, schema.marks.link);
+    let t132;
+    if ($[23] !== state) {
+      t132 = getMarkAttributes(state, schema.marks.link).href || "";
+      $[23] = state;
+      $[24] = t132;
+    } else {
+      t132 = $[24];
+    }
+    href = t132;
+    T1 = Popover;
+    t10 = true;
+    t11 = open;
+    t12 = onOpenChange;
+    T0 = Button;
+    t6 = "text";
+    t7 = "button";
+    t8 = "gap-2 rounded-none";
+    t9 = "text";
+    t5 = cls("underline decoration-stone-400 underline-offset-4", {
+      "text-blue-500": isActive
+    });
+    $[9] = onOpenChange;
+    $[10] = open;
+    $[11] = state;
+    $[12] = T0;
+    $[13] = T1;
+    $[14] = href;
+    $[15] = t10;
+    $[16] = t11;
+    $[17] = t12;
+    $[18] = t5;
+    $[19] = t6;
+    $[20] = t7;
+    $[21] = t8;
+    $[22] = t9;
+  } else {
+    T0 = $[12];
+    T1 = $[13];
+    href = $[14];
+    t10 = $[15];
+    t11 = $[16];
+    t12 = $[17];
+    t5 = $[18];
+    t6 = $[19];
+    t7 = $[20];
+    t8 = $[21];
+    t9 = $[22];
+  }
+  let t13;
+  if ($[25] !== t) {
+    t13 = t("editor_link");
+    $[25] = t;
+    $[26] = t13;
+  } else {
+    t13 = $[26];
+  }
+  let t14;
+  if ($[27] !== t13 || $[28] !== t5) {
+    t14 = /* @__PURE__ */ jsx("p", { className: t5, children: t13 });
+    $[27] = t13;
+    $[28] = t5;
+    $[29] = t14;
+  } else {
+    t14 = $[29];
+  }
+  let t15;
+  if ($[30] !== T0 || $[31] !== t14 || $[32] !== t6 || $[33] !== t7 || $[34] !== t8 || $[35] !== t9) {
+    t15 = /* @__PURE__ */ jsx(T0, { variant: t6, type: t7, className: t8, color: t9, children: t14 });
+    $[30] = T0;
+    $[31] = t14;
+    $[32] = t6;
+    $[33] = t7;
+    $[34] = t8;
+    $[35] = t9;
+    $[36] = t15;
+  } else {
+    t15 = $[36];
+  }
+  let t16;
+  if ($[37] !== t) {
+    t16 = t("editor_paste_or_type_link");
+    $[37] = t;
+    $[38] = t16;
+  } else {
+    t16 = $[38];
+  }
+  let t17;
+  if ($[39] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t17 = cls("text-surface-900 dark:text-white flex-grow bg-transparent p-1 text-sm outline-none", focusedDisabled);
+    $[39] = t17;
+  } else {
+    t17 = $[39];
+  }
+  let t18;
+  if ($[40] !== href || $[41] !== open || $[42] !== t16) {
+    t18 = /* @__PURE__ */ jsx("input", { ref: inputRef, autoFocus: open, placeholder: t16, defaultValue: href, className: t17 });
+    $[40] = href;
+    $[41] = open;
+    $[42] = t16;
+    $[43] = t18;
+  } else {
+    t18 = $[43];
+  }
+  let t19;
+  if ($[44] !== handleRemoveLink || $[45] !== href) {
+    t19 = href ? /* @__PURE__ */ jsx(Button, { size: "small", variant: "text", type: "button", color: "text", className: "flex items-center", onClick: handleRemoveLink, children: /* @__PURE__ */ jsx(DeleteIcon, { size: "small" }) }) : /* @__PURE__ */ jsx(Button, { size: "small", type: "submit", variant: "text", children: /* @__PURE__ */ jsx(CheckIcon, { size: "small" }) });
+    $[44] = handleRemoveLink;
+    $[45] = href;
+    $[46] = t19;
+  } else {
+    t19 = $[46];
+  }
+  let t20;
+  if ($[47] !== handleSubmit || $[48] !== t18 || $[49] !== t19) {
+    t20 = /* @__PURE__ */ jsxs("form", { onSubmit: handleSubmit, className: "flex p-1 gap-1", children: [
+      t18,
+      t19
+    ] });
+    $[47] = handleSubmit;
+    $[48] = t18;
+    $[49] = t19;
+    $[50] = t20;
+  } else {
+    t20 = $[50];
+  }
+  let t21;
+  if ($[51] !== T1 || $[52] !== t10 || $[53] !== t11 || $[54] !== t12 || $[55] !== t15 || $[56] !== t20) {
+    t21 = /* @__PURE__ */ jsx(T1, { modal: t10, open: t11, onOpenChange: t12, trigger: t15, children: t20 });
+    $[51] = T1;
+    $[52] = t10;
+    $[53] = t11;
+    $[54] = t12;
+    $[55] = t15;
+    $[56] = t20;
+    $[57] = t21;
+  } else {
+    t21 = $[57];
+  }
+  return t21;
+};
+const TextButtons = () => {
+  const $ = c(3);
+  const {
+    state,
+    view
+  } = useProseMirrorContext();
+  if (!state || !view) {
+    return null;
+  }
+  let t0;
+  if ($[0] !== state || $[1] !== view) {
+    const items2 = [{
+      name: "bold",
+      labelKey: "editor_bold",
+      isActive: _temp$1,
+      command: _temp2,
+      icon: FormatBoldIcon
+    }, {
+      name: "italic",
+      labelKey: "editor_italic",
+      isActive: _temp3,
+      command: _temp4,
+      icon: FormatItalicIcon
+    }, {
+      name: "underline",
+      labelKey: "editor_underline",
+      isActive: _temp5,
+      command: _temp6,
+      icon: FormatUnderlinedIcon
+    }, {
+      name: "strike",
+      labelKey: "editor_strikethrough",
+      isActive: _temp7,
+      command: _temp8,
+      icon: FormatStrikethroughIcon
+    }, {
+      name: "code",
+      labelKey: "editor_code",
+      isActive: _temp9,
+      command: _temp0,
+      icon: CodeIcon
+    }];
+    t0 = /* @__PURE__ */ jsx("div", { className: "flex", children: items2.map((item, index) => /* @__PURE__ */ jsx(EditorBubbleItem, { onSelect: () => {
+      item.command(view.state, view.dispatch);
+      view.focus();
+    }, children: /* @__PURE__ */ jsx(Button, { size: "small", color: "text", className: "gap-2 rounded-none h-full", variant: "text", children: /* @__PURE__ */ jsx(item.icon, { className: cls({
+      "text-inherit": !item.isActive(state),
+      "text-blue-500": item.isActive(state)
+    }) }) }) }, index)) });
+    $[0] = state;
+    $[1] = view;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+};
+function _temp$1(s) {
+  return isMarkActive(s, schema.marks.bold);
+}
+function _temp2(s_0, dispatch) {
+  return toggleMark(schema.marks.bold)(s_0, dispatch);
+}
+function _temp3(s_1) {
+  return isMarkActive(s_1, schema.marks.italic);
+}
+function _temp4(s_2, dispatch_0) {
+  return toggleMark(schema.marks.italic)(s_2, dispatch_0);
+}
+function _temp5(s_3) {
+  return isMarkActive(s_3, schema.marks.underline);
+}
+function _temp6(s_4, dispatch_1) {
+  return toggleMark(schema.marks.underline)(s_4, dispatch_1);
+}
+function _temp7(s_5) {
+  return isMarkActive(s_5, schema.marks.strike);
+}
+function _temp8(s_6, dispatch_2) {
+  return toggleMark(schema.marks.strike)(s_6, dispatch_2);
+}
+function _temp9(s_7) {
+  return isMarkActive(s_7, schema.marks.code);
+}
+function _temp0(s_8, dispatch_3) {
+  return toggleMark(schema.marks.code)(s_8, dispatch_3);
+}
+function removeClassesFromJson(jsonObj) {
+  if (Array.isArray(jsonObj)) {
+    return jsonObj.map((item) => removeClassesFromJson(item));
+  } else if (typeof jsonObj === "object" && jsonObj !== null) {
+    if (jsonObj.attrs && typeof jsonObj.attrs === "object" && "class" in jsonObj.attrs) {
+      delete jsonObj.attrs.class;
+    }
+    Object.keys(jsonObj).forEach((key) => {
+      jsonObj[key] = removeClassesFromJson(jsonObj[key]);
+    });
+  }
+  return jsonObj;
+}
+function serializeForClipboard(view, slice) {
+  view.someProp("transformCopied", (f) => {
+    slice = f(slice, view);
+  });
+  const context = [];
+  let {
+    content,
+    openStart,
+    openEnd
+  } = slice;
+  while (openStart > 1 && openEnd > 1 && content.childCount == 1 && content.firstChild.childCount == 1) {
+    openStart--;
+    openEnd--;
+    const node = content.firstChild;
+    context.push(node.type.name, node.attrs != node.type.defaultAttrs ? node.attrs : null);
+    content = node.content;
+  }
+  const serializer2 = view.someProp("clipboardSerializer") || DOMSerializer.fromSchema(view.state.schema);
+  const doc = detachedDoc(), wrap = doc.createElement("div");
+  wrap.appendChild(serializer2.serializeFragment(content, {
+    document: doc
+  }));
+  let firstChild = wrap.firstChild, needsWrap, wrappers = 0;
+  while (firstChild && firstChild.nodeType == 1 && (needsWrap = wrapMap[firstChild.nodeName.toLowerCase()])) {
+    for (let i = needsWrap.length - 1; i >= 0; i--) {
+      const wrapper = doc.createElement(needsWrap[i]);
+      while (wrap.firstChild) wrapper.appendChild(wrap.firstChild);
+      wrap.appendChild(wrapper);
+      wrappers++;
+    }
+    firstChild = wrap.firstChild;
+  }
+  if (firstChild && firstChild.nodeType == 1) firstChild.setAttribute("data-pm-slice", `${openStart} ${openEnd}${wrappers ? ` -${wrappers}` : ""} ${JSON.stringify(context)}`);
+  const text = view.someProp("clipboardTextSerializer", (f) => f(slice, view)) || slice.content.textBetween(0, slice.content.size, "\n\n");
+  return {
+    dom: wrap,
+    text,
+    slice
+  };
+}
+const wrapMap = {
+  thead: ["table"],
+  tbody: ["table"],
+  tfoot: ["table"],
+  caption: ["table"],
+  colgroup: ["table"],
+  col: ["table", "colgroup"],
+  tr: ["table", "tbody"],
+  td: ["table", "tbody", "tr"],
+  th: ["table", "tbody", "tr"]
+};
+let _detachedDoc = null;
+function detachedDoc() {
+  return _detachedDoc || (_detachedDoc = document.implementation.createHTMLDocument("title"));
+}
+function absoluteRect(element) {
+  const data = element.getBoundingClientRect();
+  let ancestor = element.parentElement;
+  while (ancestor && window.getComputedStyle(ancestor).position === "static") {
+    ancestor = ancestor.parentElement;
+  }
+  const ancestorRect = ancestor?.getBoundingClientRect();
+  return {
+    top: data.top - (ancestorRect?.top ?? 0),
+    left: data.left - (ancestorRect?.left ?? 0),
+    width: data.width
+  };
+}
+function nodeDOMAtCoords(coords, view) {
+  const editorRect = view.dom.getBoundingClientRect();
+  if (coords.y < editorRect.top || coords.y > editorRect.bottom) return void 0;
+  if (coords.x < editorRect.left - 100 || coords.x > editorRect.right + 50) return void 0;
+  let elem = document.elementFromPoint(coords.x, coords.y);
+  let block = elem?.closest('li, p:not(:first-child), pre, blockquote, h1, h2, h3, h4, h5, h6, img, [data-type="taskList"]');
+  if (block && view.dom.contains(block)) {
+    return block.closest("li") || block;
+  }
+  const probeX = editorRect.left + Math.min(60, editorRect.width / 4);
+  if (coords.x > probeX) return void 0;
+  let probeElem = document.elementFromPoint(probeX, coords.y);
+  let probeBlock = probeElem?.closest('li, p:not(:first-child), pre, blockquote, h1, h2, h3, h4, h5, h6, img, [data-type="taskList"]');
+  if (probeBlock) {
+    if (view.dom.contains(probeBlock)) {
+      return probeBlock.closest("li") || probeBlock;
+    }
+  }
+  return void 0;
+}
+function nodePosAtDOM(node, view, options) {
+  try {
+    if (!view.dom.contains(node)) return null;
+    const pos = view.posAtDOM(node, 0);
+    const $pos = view.state.doc.resolve(pos);
+    if ($pos.depth > 0) {
+      return $pos.before();
+    }
+    return pos;
+  } catch (e) {
+    return null;
+  }
+}
+function dragHandlePlugin(options = {
+  dragHandleWidth: 24
+}) {
+  function handleDragStart(event, view) {
+    view.focus();
+    if (!event.dataTransfer) return;
+    const node = nodeDOMAtCoords({
+      x: event.clientX,
+      y: event.clientY
+    }, view);
+    if (!(node instanceof Element)) return;
+    const nodePos = nodePosAtDOM(node, view);
+    if (nodePos == null || nodePos < 0) return;
+    const draggedNodeSelection = NodeSelection.create(view.state.doc, nodePos);
+    view.dispatch(view.state.tr.setSelection(draggedNodeSelection));
+    const slice = view.state.selection.content();
+    const {
+      dom,
+      text
+    } = serializeForClipboard(view, slice);
+    event.dataTransfer.clearData();
+    event.dataTransfer.setData("text/html", dom.innerHTML);
+    event.dataTransfer.setData("text/plain", text);
+    event.dataTransfer.effectAllowed = "copyMove";
+    event.dataTransfer.setDragImage(node, 0, 0);
+    view.dragging = {
+      slice,
+      move: true,
+      node: draggedNodeSelection
+    };
+  }
+  function handleClick(event, view) {
+    view.focus();
+    view.dom.classList.remove("dragging");
+    const node = nodeDOMAtCoords({
+      x: event.clientX,
+      y: event.clientY
+    }, view);
+    if (!(node instanceof Element)) return;
+    const nodePos = nodePosAtDOM(node, view);
+    if (!nodePos) return;
+    view.dispatch(view.state.tr.setSelection(NodeSelection.create(view.state.doc, nodePos)));
+  }
+  let dragHandleElement = null;
+  function hideDragHandle() {
+    if (dragHandleElement) {
+      dragHandleElement.classList.add("hide");
+    }
+  }
+  function showDragHandle() {
+    if (dragHandleElement) {
+      dragHandleElement.classList.remove("hide");
+    }
+  }
+  return new Plugin({
+    view: (view) => {
+      dragHandleElement = document.createElement("div");
+      dragHandleElement.draggable = true;
+      dragHandleElement.dataset.dragHandle = "";
+      dragHandleElement.classList.add("drag-handle");
+      dragHandleElement.addEventListener("dragstart", (e) => {
+        handleDragStart(e, view);
+      });
+      dragHandleElement.addEventListener("click", (e) => {
+        handleClick(e, view);
+      });
+      const onMouseMove = (event) => {
+        if (!view.editable) {
+          return;
+        }
+        const node = nodeDOMAtCoords({
+          x: event.clientX,
+          y: event.clientY
+        }, view);
+        if (!(node instanceof Element)) {
+          hideDragHandle();
+          return;
+        }
+        const compStyle = window.getComputedStyle(node);
+        const lineHeight = parseInt(compStyle.lineHeight, 10);
+        const paddingTop = parseInt(compStyle.paddingTop, 10);
+        const rect = absoluteRect(node);
+        if (!rect) {
+          hideDragHandle();
+          return;
+        }
+        rect.top += (lineHeight - 24) / 2;
+        rect.top += paddingTop;
+        if (node.matches("ul:not([data-type=taskList]) li, ol li")) {
+          rect.left -= options.dragHandleWidth;
+        }
+        rect.width = options.dragHandleWidth;
+        if (!dragHandleElement) return;
+        dragHandleElement.style.left = `${rect.left - rect.width}px`;
+        dragHandleElement.style.top = `${rect.top}px`;
+        showDragHandle();
+      };
+      window.addEventListener("mousemove", onMouseMove);
+      hideDragHandle();
+      view?.dom?.parentElement?.appendChild(dragHandleElement);
+      return {
+        destroy: () => {
+          window.removeEventListener("mousemove", onMouseMove);
+          dragHandleElement?.remove?.();
+          dragHandleElement = null;
+        }
+      };
+    },
+    props: {
+      handleDOMEvents: {
+        keydown: () => {
+          hideDragHandle();
+        },
+        mousewheel: () => {
+          hideDragHandle();
+        },
+        // dragging class is used for CSS
+        dragstart: (view) => {
+          view.dom.classList.add("dragging");
+        },
+        drop: (view) => {
+          view.dom.classList.remove("dragging");
+        },
+        dragend: (view) => {
+          view.dom.classList.remove("dragging");
+        }
+      }
+    }
+  });
+}
+function globalDragDropPlugin() {
+  let dropCursorElement = null;
+  let cleanup = null;
+  function updateDropCursorColor(el) {
+    const isDark = document.documentElement.getAttribute("data-theme") === "dark";
+    const varName = isDark ? "--color-surface-accent-300" : "--color-surface-accent-600";
+    const color = getComputedStyle(document.documentElement).getPropertyValue(varName).trim();
+    el.style.backgroundColor = color || (isDark ? "#cbd5e1" : "#475569");
+  }
+  return new Plugin({
+    view(editorView) {
+      dropCursorElement = document.createElement("div");
+      dropCursorElement.className = "prosemirror-dropcursor-block";
+      dropCursorElement.style.cssText = "position: absolute; z-index: 50; pointer-events: none; height: 2px;";
+      updateDropCursorColor(dropCursorElement);
+      const observer = new MutationObserver(() => {
+        if (dropCursorElement) updateDropCursorColor(dropCursorElement);
+      });
+      observer.observe(document.documentElement, {
+        attributes: true,
+        attributeFilter: ["data-theme"]
+      });
+      const removeCursor = () => {
+        if (dropCursorElement && dropCursorElement.parentNode) {
+          dropCursorElement.parentNode.removeChild(dropCursorElement);
+        }
+      };
+      const getBlockInsertionPoint = (event, clampedX) => {
+        const pos = editorView.posAtCoords({
+          left: clampedX,
+          top: event.clientY
+        });
+        if (!pos) return null;
+        let $pos = editorView.state.doc.resolve(pos.pos);
+        let blockDepth = 0;
+        for (let i = $pos.depth; i > 0; i--) {
+          const name = $pos.node(i).type.name;
+          if (name === "list_item" || name === "taskItem") {
+            blockDepth = i;
+            break;
+          }
+          if ($pos.node(i).isBlock && name !== "bullet_list" && name !== "ordered_list" && name !== "taskList") {
+            blockDepth = i;
+          }
+        }
+        if (blockDepth === 0) return pos.pos;
+        const nodeBeforePos = $pos.before(blockDepth);
+        const nodeAfterPos = $pos.after(blockDepth);
+        const domNode = editorView.nodeDOM(nodeBeforePos);
+        if (domNode instanceof HTMLElement) {
+          const rect = domNode.getBoundingClientRect();
+          const isTopHalf = event.clientY < rect.top + rect.height / 2;
+          return isTopHalf ? nodeBeforePos : nodeAfterPos;
+        }
+        return pos.pos;
+      };
+      const handleDragOver = (event) => {
+        if (!editorView.editable || !editorView.dragging) return;
+        if (!editorView.dragging.node) {
+          removeCursor();
+          return;
+        }
+        event.preventDefault();
+        const editorRect = editorView.dom.getBoundingClientRect();
+        const clampedX = Math.max(editorRect.left + 10, Math.min(event.clientX, editorRect.right - 10));
+        let target = getBlockInsertionPoint(event, clampedX);
+        if (target === null) {
+          removeCursor();
+          return;
+        }
+        const $pos = editorView.state.doc.resolve(target);
+        let rect;
+        const before = $pos.nodeBefore;
+        const after = $pos.nodeAfter;
+        if (before || after) {
+          const nodeDOM = editorView.nodeDOM(target - (before ? before.nodeSize : 0));
+          if (nodeDOM && nodeDOM instanceof HTMLElement) {
+            const nodeRect = nodeDOM.getBoundingClientRect();
+            let top = before ? nodeRect.bottom : nodeRect.top;
+            if (before && after) {
+              const afterDOM = editorView.nodeDOM(target);
+              if (afterDOM && afterDOM instanceof HTMLElement) {
+                top = (top + afterDOM.getBoundingClientRect().top) / 2;
+              }
+            }
+            rect = {
+              left: nodeRect.left,
+              right: nodeRect.right,
+              top: top - 1,
+              bottom: top + 1
+            };
+          }
+        }
+        if (!rect) {
+          const coords = editorView.coordsAtPos(target);
+          rect = {
+            left: editorRect.left + 50,
+            right: editorRect.right - 50,
+            top: coords.top - 1,
+            bottom: coords.top + 1
+          };
+        }
+        const parent = editorView.dom.offsetParent;
+        let parentLeft = 0;
+        let parentTop = 0;
+        if (parent && parent !== document.body && getComputedStyle(parent).position !== "static") {
+          const parentRect = parent.getBoundingClientRect();
+          parentLeft = parentRect.left - parent.scrollLeft;
+          parentTop = parentRect.top - parent.scrollTop;
+        }
+        if (!dropCursorElement.parentNode) {
+          parent.appendChild(dropCursorElement);
+        }
+        dropCursorElement.style.left = `${rect.left - parentLeft}px`;
+        dropCursorElement.style.top = `${rect.top - parentTop}px`;
+        dropCursorElement.style.width = `${rect.right - rect.left}px`;
+      };
+      const handleDrop = (event) => {
+        if (!editorView.editable || !editorView.dragging) return;
+        if (!editorView.dragging.node) {
+          removeCursor();
+          return;
+        }
+        event.preventDefault();
+        removeCursor();
+        editorView.dom.classList.remove("dragging");
+        const editorRect = editorView.dom.getBoundingClientRect();
+        const clampedX = Math.max(editorRect.left + 10, Math.min(event.clientX, editorRect.right - 10));
+        let targetPos = getBlockInsertionPoint(event, clampedX);
+        if (targetPos === null) return;
+        const dragging = editorView.dragging;
+        if (dragging && dragging.slice) {
+          let tr = editorView.state.tr;
+          if (dragging.move) {
+            const {
+              node: node2
+            } = dragging;
+            if (node2) {
+              node2.replace(tr);
+            } else {
+              tr = tr.deleteSelection();
+            }
+          }
+          const mappedTarget = tr.mapping.map(targetPos);
+          const beforeInsert = tr.doc;
+          let {
+            node,
+            slice
+          } = dragging;
+          if (node && node.node) {
+            let nodeToInsert = node.node;
+            const $mapped = tr.doc.resolve(mappedTarget);
+            const parentName = $mapped.parent.type.name;
+            const isTargetList = parentName === "bullet_list" || parentName === "ordered_list";
+            const isTargetTaskList = parentName === "taskList";
+            if (nodeToInsert.type.name === "list_item" && !isTargetList) {
+              nodeToInsert = nodeToInsert.content;
+            } else if (nodeToInsert.type.name === "taskItem" && !isTargetTaskList) {
+              nodeToInsert = nodeToInsert.content;
+            }
+            const isFragment = !nodeToInsert.type;
+            const needsWrap = isFragment || nodeToInsert.type.name !== "list_item" && nodeToInsert.type.name !== "taskItem";
+            if (needsWrap) {
+              if (isTargetList) {
+                const listItemType = editorView.state.schema.nodes.list_item;
+                if (listItemType) nodeToInsert = listItemType.create(null, nodeToInsert);
+              } else if (isTargetTaskList) {
+                const taskItemType = editorView.state.schema.nodes.taskItem;
+                if (taskItemType) nodeToInsert = taskItemType.create({
+                  checked: false
+                }, nodeToInsert);
+              }
+            }
+            try {
+              tr = tr.insert(mappedTarget, nodeToInsert);
+            } catch (e) {
+              console.warn("Could not insert dragged node exactly at target. Attempting fallback.", e);
+              const point = dropPoint(tr.doc, mappedTarget, slice);
+              if (point !== null) {
+                tr = tr.replace(point, point, slice);
+              }
+            }
+          } else if (slice) {
+            const point = dropPoint(tr.doc, mappedTarget, slice);
+            const finalTarget = point !== null ? point : mappedTarget;
+            tr = tr.replace(finalTarget, finalTarget, slice);
+          }
+          if (!tr.doc.eq(beforeInsert)) {
+            editorView.dispatch(tr.setMeta("uiEvent", "drop"));
+            editorView.focus();
+          }
+        }
+        editorView.dragging = null;
+      };
+      const handleDragEnd = () => {
+        removeCursor();
+      };
+      window.addEventListener("dragover", handleDragOver, {
+        capture: true
+      });
+      window.addEventListener("drop", handleDrop, {
+        capture: true
+      });
+      window.addEventListener("dragend", handleDragEnd, {
+        capture: true
+      });
+      cleanup = () => {
+        removeCursor();
+        observer.disconnect();
+        window.removeEventListener("dragover", handleDragOver, {
+          capture: true
+        });
+        window.removeEventListener("drop", handleDrop, {
+          capture: true
+        });
+        window.removeEventListener("dragend", handleDragEnd, {
+          capture: true
+        });
+      };
+      return {
+        destroy() {
+          if (cleanup) cleanup();
+        }
+      };
+    }
+  });
+}
+const highlightDecorationKey = new PluginKey("highlightDecoration");
+function buildDecorationSet(highlight, doc) {
+  const decorations = [];
+  if (highlight) {
+    decorations.push(Decoration.inline(highlight.from, highlight.to, {
+      class: "dark:bg-surface-accent-700 bg-surface-accent-300"
+    }));
+  }
+  const decorationSet = DecorationSet.create(doc, decorations);
+  return decorationSet;
+}
+const highlightCommands = {
+  toggleAutocompleteHighlight: (range) => (state, dispatch) => {
+    const {
+      selection
+    } = state;
+    const pos = selection.from;
+    if (!dispatch) return false;
+    const tr = state.tr.setMeta(highlightDecorationKey, {
+      pos,
+      type: "highlightDecoration",
+      remove: false,
+      range
+    });
+    dispatch(tr);
+    return true;
+  },
+  removeAutocompleteHighlight: () => (state, dispatch) => {
+    if (!dispatch) return false;
+    const tr = state.tr.setMeta(highlightDecorationKey, {
+      pos: 0,
+      type: "highlightDecoration",
+      remove: true
+    });
+    dispatch(tr);
+    return true;
+  }
+};
+const highlightDecorationPlugin = (initialHighlight) => {
+  return new Plugin({
+    key: highlightDecorationKey,
+    state: {
+      init: (_, {
+        doc
+      }) => {
+        const decorationSet = DecorationSet.empty;
+        return {
+          decorationSet,
+          highlight: initialHighlight
+        };
+      },
+      apply(transaction, oldState) {
+        const action = transaction.getMeta(highlightDecorationKey);
+        const highlight = action?.range;
+        if (action?.type === "highlightDecoration") {
+          const doc = transaction.doc;
+          const {
+            remove
+          } = action;
+          if (remove) {
+            return {
+              decorationSet: DecorationSet.empty
+            };
+          }
+          const decorationSet = buildDecorationSet(highlight, doc);
+          return {
+            decorationSet,
+            highlight
+          };
+        } else {
+          return oldState;
+        }
+      }
+    },
+    props: {
+      decorations(state) {
+        const autocompleteState = this.getState(state);
+        if (autocompleteState?.decorationSet) {
+          return autocompleteState.decorationSet;
+        } else {
+          return DecorationSet.empty;
+        }
+      }
+    }
+  });
+};
+const blockQuoteRule = wrappingInputRule(/^\s*>\s$/, schema.nodes.blockquote);
+const orderedListRule = wrappingInputRule(/^(\d+)\.\s$/, schema.nodes.ordered_list, (match) => ({
+  order: +match[1]
+}), (match, node) => node.childCount + node.attrs.order === +match[1]);
+const bulletListRule = wrappingInputRule(/^\s*([-+*])\s$/, schema.nodes.bullet_list);
+const taskListRule = wrappingInputRule(/^\s*(\[ \])\s$/, schema.nodes.task_list);
+const codeBlockRule = textblockTypeInputRule(/^```$/, schema.nodes.code_block);
+const headingRule = textblockTypeInputRule(new RegExp("^(#{1,6})\\s$"), schema.nodes.heading, (match) => ({
+  level: match[1].length
+}));
+const horizontalRuleInputRule = new InputRule(/^(?:---|—-|___\s|\*\*\*\s)$/, (state, match, start, end) => {
+  const tr = state.tr;
+  tr.replaceWith(start - 1, end, schema.nodes.horizontal_rule.create());
+  return tr;
+});
+function markInputRule(regexp, markType, getAttrs) {
+  return new InputRule(regexp, (state, match, start, end) => {
+    const attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
+    const tr = state.tr;
+    if (match[1]) {
+      const textStart = start + match[0].indexOf(match[1]);
+      const textEnd = textStart + match[1].length;
+      if (textEnd < end) tr.delete(textEnd, end);
+      if (textStart > start) tr.delete(start, textStart);
+      end = start + match[1].length;
+    }
+    tr.addMark(start, end, markType.create(attrs));
+    tr.removeStoredMark(markType);
+    return tr;
+  });
+}
+const strongRule = markInputRule(/(?:\*\*|__)([^*_]+)(?:\*\*|__)$/, schema.marks.bold);
+const emRule = markInputRule(/(?:^|[^*_])(?:\*|_)([^*_]+)(?:\*|_)$/, schema.marks.italic);
+const codeRule = markInputRule(/(?:`)([^`]+)(?:`)$/, schema.marks.code);
+const strikeRule = markInputRule(/(?:~~)([^~]+)(?:~~)$/, schema.marks.strike);
+const markdownInputRules = inputRules({
+  rules: [...smartQuotes, ellipsis, emDash, blockQuoteRule, orderedListRule, bulletListRule, codeBlockRule, headingRule, taskListRule, horizontalRuleInputRule, strongRule, emRule, codeRule, strikeRule]
+});
+const placeholderPluginKey = new PluginKey("placeholderPlugin");
+function isNodeEmpty(node) {
+  const defaultContent = node.type.createAndFill();
+  if (!defaultContent) return true;
+  return node.content.eq(defaultContent.content);
+}
+function placeholderPlugin(text) {
+  return new Plugin({
+    key: placeholderPluginKey,
+    props: {
+      decorations: (state) => {
+        const doc = state.doc;
+        const decorations = [];
+        const isEmptyDoc = doc.childCount === 1 && doc.firstChild?.isTextblock && doc.firstChild.content.size === 0;
+        const {
+          anchor
+        } = state.selection;
+        doc.descendants((node, pos) => {
+          const isEmpty = !node.isLeaf && isNodeEmpty(node);
+          if (isEmpty) {
+            const nodeEnd = pos + node.nodeSize;
+            const hasCursor = anchor >= pos && anchor <= nodeEnd;
+            if (!hasCursor && !isEmptyDoc) {
+              return false;
+            }
+            const classes = ["is-empty"];
+            if (isEmptyDoc) {
+              classes.push("is-editor-empty");
+            }
+            decorations.push(Decoration.node(pos, pos + node.nodeSize, {
+              class: classes.join(" "),
+              "data-placeholder": text
+            }));
+          }
+          return false;
+        });
+        return DecorationSet.create(doc, decorations);
+      }
+    }
+  });
+}
+const customKeymap = {
+  "Tab": goToNextCell(1),
+  "Shift-Tab": goToNextCell(-1),
+  "Mod-z": undo,
+  "Mod-y": redo,
+  "Shift-Mod-z": redo,
+  "Mod-b": toggleMark(schema.marks.bold),
+  "Mod-i": toggleMark(schema.marks.italic),
+  "Mod-u": toggleMark(schema.marks.underline),
+  "Mod-Shift-s": toggleMark(schema.marks.strike),
+  "Mod-e": toggleMark(schema.marks.code),
+  "Mod-Shift-h": toggleMark(schema.marks.highlight),
+  "Enter": splitListItem(schema.nodes.list_item),
+  "Shift-Enter": splitListItem(schema.nodes.task_item),
+  "Mod-[": liftListItem(schema.nodes.list_item),
+  "Mod-]": sinkListItem(schema.nodes.list_item),
+  "Shift-Mod-8": setBlockType(schema.nodes.bullet_list),
+  "Shift-Mod-9": setBlockType(schema.nodes.ordered_list),
+  "Mod-Alt-1": setBlockType(schema.nodes.heading, {
+    level: 1
+  }),
+  "Mod-Alt-2": setBlockType(schema.nodes.heading, {
+    level: 2
+  }),
+  "Mod-Alt-3": setBlockType(schema.nodes.heading, {
+    level: 3
+  }),
+  "Mod-Alt-0": setBlockType(schema.nodes.paragraph)
+};
+const corePlugins = [history(), keymap(customKeymap), keymap(baseKeymap), globalDragDropPlugin(), gapCursor(), slashCommandPlugin(), dragHandlePlugin(), highlightDecorationPlugin(), textLoadingDecorationPlugin(), markdownInputRules, placeholderPlugin("Press '/' for commands")];
+class ReactNodeView {
+  node;
+  view;
+  getPos;
+  dom;
+  contentDOM;
+  root;
+  Component;
+  constructor(node, view, getPos, Component, as = "div", className, contentDOMElement) {
+    this.node = node;
+    this.view = view;
+    this.getPos = getPos;
+    this.Component = Component;
+    this.dom = document.createElement(as);
+    if (className) this.dom.className = className;
+    if (contentDOMElement) {
+      this.contentDOM = contentDOMElement;
+    }
+    const container = document.createElement("div");
+    this.dom.appendChild(container);
+    if (this.contentDOM) {
+      this.dom.appendChild(this.contentDOM);
+    }
+    this.root = createRoot(container);
+    this.render();
+  }
+  render() {
+    this.root.render(/* @__PURE__ */ jsx(this.Component, { node: this.node, view: this.view, getPos: this.getPos }));
+  }
+  update(node) {
+    if (node.type !== this.node.type) {
+      return false;
+    }
+    this.node = node;
+    this.render();
+    return true;
+  }
+  destroy() {
+    this.root.unmount();
+  }
+  ignoreMutation(mutation) {
+    if (!this.contentDOM) {
+      return true;
+    }
+    return !this.contentDOM.contains(mutation.target);
+  }
+}
+const TaskItemComponent = (t0) => {
+  const $ = c(7);
+  const {
+    node,
+    view,
+    getPos
+  } = t0;
+  const checked = node.attrs.checked;
+  let t1;
+  if ($[0] !== getPos || $[1] !== node.attrs || $[2] !== view) {
+    t1 = (e) => {
+      const pos = getPos();
+      if (typeof pos !== "number") {
+        return;
+      }
+      view.dispatch(view.state.tr.setNodeMarkup(pos, void 0, {
+        ...node.attrs,
+        checked: e.target.checked
+      }));
+    };
+    $[0] = getPos;
+    $[1] = node.attrs;
+    $[2] = view;
+    $[3] = t1;
+  } else {
+    t1 = $[3];
+  }
+  const handleChange = t1;
+  let t2;
+  if ($[4] !== checked || $[5] !== handleChange) {
+    t2 = /* @__PURE__ */ jsx("label", { contentEditable: false, className: "flex items-start select-none px-1", children: /* @__PURE__ */ jsx("input", { type: "checkbox", checked, onChange: handleChange, className: "mt-1 flex-shrink-0 cursor-pointer" }) });
+    $[4] = checked;
+    $[5] = handleChange;
+    $[6] = t2;
+  } else {
+    t2 = $[6];
+  }
+  return t2;
+};
+const ImageComponent = (t0) => {
+  const $ = c(7);
+  const {
+    node,
+    view,
+    getPos
+  } = t0;
+  const selected = view.state.selection.from === getPos();
+  const t1 = node.attrs.src;
+  const t2 = node.attrs.alt || "";
+  const t3 = node.attrs.title || "";
+  const t4 = selected ? "" : "";
+  let t5;
+  if ($[0] !== t4) {
+    t5 = cls("rounded-lg max-w-full !m-0", t4);
+    $[0] = t4;
+    $[1] = t5;
+  } else {
+    t5 = $[1];
+  }
+  let t6;
+  if ($[2] !== node.attrs.src || $[3] !== t2 || $[4] !== t3 || $[5] !== t5) {
+    t6 = /* @__PURE__ */ jsx("img", { src: t1, alt: t2, title: t3, className: t5 });
+    $[2] = node.attrs.src;
+    $[3] = t2;
+    $[4] = t3;
+    $[5] = t5;
+    $[6] = t6;
+  } else {
+    t6 = $[6];
+  }
+  return t6;
+};
+function createReactNodeView(Component, as = "div", className, createContentDOM) {
+  return (node, view, getPos) => {
+    const contentDOM = createContentDOM ? createContentDOM() : void 0;
+    return new ReactNodeView(node, view, getPos, Component, as, className, contentDOM);
+  };
+}
+const nodeViews = {
+  task_item: createReactNodeView(TaskItemComponent, "li", "flex items-start", () => {
+    const dom = document.createElement("div");
+    dom.className = "flex-grow min-w-0";
+    return dom;
+  }),
+  image: createReactNodeView(ImageComponent, "span", "inline-block w-full")
+};
+const trailingNodePlugin = new Plugin({
+  appendTransaction: (_, oldState, newState) => {
+    const doc = newState.doc;
+    if (doc.lastChild && doc.lastChild.type.name !== "paragraph") {
+      return newState.tr.insert(doc.content.size, newState.schema.nodes.paragraph.create());
+    }
+    return null;
+  }
+});
+function useProseMirror(t0) {
+  const $ = c(13);
+  const {
+    initialContent,
+    editable: t1,
+    handleImageUpload
+  } = t0;
+  const editable = t1 === void 0 ? true : t1;
+  let t2;
+  if ($[0] !== handleImageUpload || $[1] !== initialContent) {
+    const plugins = [...corePlugins, columnResizing(), tableEditing(), trailingNodePlugin];
+    if (handleImageUpload) {
+      plugins.push(createDropImagePlugin(handleImageUpload));
+    }
+    t2 = EditorState.create({
+      doc: typeof initialContent === "string" ? parser.parse(initialContent) : initialContent ? schema.nodeFromJSON(initialContent) : schema.node("doc", null, [schema.node("paragraph")]),
+      schema,
+      plugins
+    });
+    $[0] = handleImageUpload;
+    $[1] = initialContent;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  const defaultState = t2;
+  const [state, setState] = useState(defaultState);
+  const [view, setView] = useState(null);
+  const editorRef = useRef(null);
+  const viewRef = useRef(null);
+  let t3;
+  if ($[3] !== defaultState || $[4] !== editable) {
+    t3 = () => {
+      if (!editorRef.current) {
+        return;
+      }
+      const editorView = new EditorView(editorRef.current, {
+        state: defaultState,
+        editable: () => editable,
+        dispatchTransaction: (tr) => {
+          if (editorView.isDestroyed) {
+            return;
+          }
+          const newState = editorView.state.apply(tr);
+          editorView.updateState(newState);
+          setState(newState);
+        },
+        nodeViews,
+        transformPastedHTML(html) {
+          const div = document.createElement("div");
+          div.innerHTML = html;
+          div.querySelectorAll("*").forEach(_temp);
+          return div.innerHTML;
+        }
+      });
+      const originalPosAtCoords = editorView.posAtCoords.bind(editorView);
+      editorView.posAtCoords = (coords) => {
+        const res = originalPosAtCoords(coords);
+        if (!res) {
+          const editorRect = editorView.dom.getBoundingClientRect();
+          if (coords.left <= editorRect.left) {
+            const probeX = editorRect.left + Math.min(60, editorRect.width / 4);
+            return originalPosAtCoords({
+              left: probeX,
+              top: coords.top
+            });
+          }
+          if (coords.left >= editorRect.right) {
+            const probeX_0 = editorRect.right - Math.min(60, editorRect.width / 4);
+            return originalPosAtCoords({
+              left: probeX_0,
+              top: coords.top
+            });
+          }
+        }
+        return res;
+      };
+      viewRef.current = editorView;
+      setView(editorView);
+      return () => {
+        editorView.destroy();
+        viewRef.current = null;
+      };
+    };
+    $[3] = defaultState;
+    $[4] = editable;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  let t4;
+  if ($[6] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t4 = [];
+    $[6] = t4;
+  } else {
+    t4 = $[6];
+  }
+  useLayoutEffect(t3, t4);
+  let t5;
+  let t6;
+  if ($[7] !== editable) {
+    t5 = () => {
+      if (viewRef.current) {
+        viewRef.current.setProps({
+          editable: () => editable
+        });
+      }
+    };
+    t6 = [editable];
+    $[7] = editable;
+    $[8] = t5;
+    $[9] = t6;
+  } else {
+    t5 = $[8];
+    t6 = $[9];
+  }
+  useEffect(t5, t6);
+  let t7;
+  if ($[10] !== state || $[11] !== view) {
+    t7 = {
+      state,
+      view,
+      editorRef
+    };
+    $[10] = state;
+    $[11] = view;
+    $[12] = t7;
+  } else {
+    t7 = $[12];
+  }
+  return t7;
+}
+function _temp(el) {
+  el.removeAttribute("style");
+  el.removeAttribute("class");
+  el.removeAttribute("color");
+  el.removeAttribute("bgcolor");
+  el.removeAttribute("face");
+}
+const proseClasses = {
+  "sm": "prose-sm",
+  "base": "prose-base",
+  "lg": "prose-lg"
+};
+const FireCMSEditor = (t0) => {
+  const $ = c(78);
+  const {
+    content,
+    onJsonContentChange,
+    onMarkdownContentChange,
+    textSize: t1,
+    highlight,
+    handleImageUpload,
+    aiController,
+    disabled
+  } = t0;
+  const textSize = t1 === void 0 ? "base" : t1;
+  useTranslation();
+  const [openNode, setOpenNode] = useState(false);
+  const [openLink, setOpenLink] = useState(false);
+  const [isMarkdownMode, setIsMarkdownMode] = useState(false);
+  const [internalMarkdown, setInternalMarkdown] = useState("");
+  let t2;
+  if ($[0] !== internalMarkdown || $[1] !== isMarkdownMode) {
+    t2 = [internalMarkdown, isMarkdownMode];
+    $[0] = internalMarkdown;
+    $[1] = isMarkdownMode;
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  useEffect(() => {
+    if (!isMarkdownMode) {
+      return;
+    }
+    const timeout = setTimeout(() => {
+      if (callbacksRef.current.onMarkdownContentChange) {
+        callbacksRef.current.onMarkdownContentChange(internalMarkdown);
+      }
+    }, 250);
+    return () => clearTimeout(timeout);
+  }, t2);
+  const handleToggleMarkdown = () => {
+    if (!isMarkdownMode) {
+      if (view) {
+        setInternalMarkdown(serializer.serialize(view.state.doc));
+      }
+      setIsMarkdownMode(true);
+    } else {
+      if (view) {
+        const newDoc = parser.parse(internalMarkdown);
+        if (newDoc) {
+          const tr = view.state.tr.replaceWith(0, view.state.doc.content.size, newDoc.content);
+          view.dispatch(tr);
+        }
+      }
+      setIsMarkdownMode(false);
+    }
+  };
+  let t3;
+  if ($[3] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t3 = (e) => {
+      setInternalMarkdown(e.target.value);
+    };
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  const handleMarkdownChange = t3;
+  const handleMarkdownBlur = () => {
+    const {
+      onMarkdownContentChange: onMarkdownContentChange_0,
+      onJsonContentChange: onJsonContentChange_0
+    } = callbacksRef.current;
+    if (onMarkdownContentChange_0) {
+      onMarkdownContentChange_0(internalMarkdown);
+    }
+    if (onJsonContentChange_0) {
+      try {
+        const newDoc_0 = parser.parse(internalMarkdown);
+        if (newDoc_0) {
+          onJsonContentChange_0(removeClassesFromJson(newDoc_0.toJSON()));
+        }
+      } catch (t4) {
+        const e_0 = t4;
+        console.warn("Could not parse markdown to JSON", e_0);
+      }
+    }
+  };
+  useInjectStyles("Editor", cssStyles);
+  let t5;
+  if ($[4] !== onJsonContentChange || $[5] !== onMarkdownContentChange) {
+    t5 = {
+      onMarkdownContentChange,
+      onJsonContentChange
+    };
+    $[4] = onJsonContentChange;
+    $[5] = onMarkdownContentChange;
+    $[6] = t5;
+  } else {
+    t5 = $[6];
+  }
+  const callbacksRef = useRef(t5);
+  let t6;
+  if ($[7] !== callbacksRef || $[8] !== onJsonContentChange || $[9] !== onMarkdownContentChange) {
+    t6 = () => {
+      callbacksRef.current = {
+        onMarkdownContentChange,
+        onJsonContentChange
+      };
+    };
+    $[7] = callbacksRef;
+    $[8] = onJsonContentChange;
+    $[9] = onMarkdownContentChange;
+    $[10] = t6;
+  } else {
+    t6 = $[10];
+  }
+  let t7;
+  if ($[11] !== onJsonContentChange || $[12] !== onMarkdownContentChange) {
+    t7 = [onMarkdownContentChange, onJsonContentChange];
+    $[11] = onJsonContentChange;
+    $[12] = onMarkdownContentChange;
+    $[13] = t7;
+  } else {
+    t7 = $[13];
+  }
+  useEffect(t6, t7);
+  let t8;
+  if ($[14] !== callbacksRef) {
+    t8 = (currentState) => {
+      const {
+        onMarkdownContentChange: onMarkdownContentChange_1,
+        onJsonContentChange: onJsonContentChange_1
+      } = callbacksRef.current;
+      if (onMarkdownContentChange_1) {
+        try {
+          const markdown = serializer.serialize(currentState.doc);
+          onMarkdownContentChange_1(markdown);
+        } catch (t92) {
+          const e_1 = t92;
+          console.warn("[FireCMSEditor] Could not serialize editor state to markdown:", e_1);
+        }
+      }
+      if (onJsonContentChange_1) {
+        const jsonContent = removeClassesFromJson(currentState.doc.toJSON());
+        onJsonContentChange_1(jsonContent);
+      }
+    };
+    $[14] = callbacksRef;
+    $[15] = t8;
+  } else {
+    t8 = $[15];
+  }
+  const flushChanges = t8;
+  const t9 = !disabled;
+  let t10;
+  if ($[16] !== content || $[17] !== handleImageUpload || $[18] !== t9) {
+    t10 = {
+      initialContent: content,
+      editable: t9,
+      handleImageUpload
+    };
+    $[16] = content;
+    $[17] = handleImageUpload;
+    $[18] = t9;
+    $[19] = t10;
+  } else {
+    t10 = $[19];
+  }
+  const {
+    state,
+    view: t11,
+    editorRef
+  } = useProseMirror(t10);
+  const view = t11;
+  const doc = state?.doc;
+  const mountedRef = useRef(false);
+  let t12;
+  let t13;
+  if ($[20] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t12 = () => {
+      const raf = requestAnimationFrame(() => {
+        mountedRef.current = true;
+      });
+      return () => cancelAnimationFrame(raf);
+    };
+    t13 = [];
+    $[20] = t12;
+    $[21] = t13;
+  } else {
+    t12 = $[20];
+    t13 = $[21];
+  }
+  useEffect(t12, t13);
+  let t14;
+  if ($[22] !== flushChanges || $[23] !== state) {
+    t14 = () => {
+      if (!state) {
+        return;
+      }
+      if (!mountedRef.current) {
+        return;
+      }
+      const timeout_0 = setTimeout(() => {
+        flushChanges(state);
+      }, 250);
+      return () => clearTimeout(timeout_0);
+    };
+    $[22] = flushChanges;
+    $[23] = state;
+    $[24] = t14;
+  } else {
+    t14 = $[24];
+  }
+  let t15;
+  if ($[25] !== doc) {
+    t15 = [doc];
+    $[25] = doc;
+    $[26] = t15;
+  } else {
+    t15 = $[26];
+  }
+  useEffect(t14, t15);
+  let t16;
+  if ($[27] !== flushChanges || $[28] !== view) {
+    t16 = () => {
+      if (!view) {
+        return;
+      }
+      const dom = view.dom;
+      const handleBlur = () => {
+        if (!mountedRef.current) {
+          return;
+        }
+        flushChanges(view.state);
+      };
+      dom.addEventListener("blur", handleBlur);
+      return () => dom.removeEventListener("blur", handleBlur);
+    };
+    $[27] = flushChanges;
+    $[28] = view;
+    $[29] = t16;
+  } else {
+    t16 = $[29];
+  }
+  let t17;
+  if ($[30] !== view) {
+    t17 = [view];
+    $[30] = view;
+    $[31] = t17;
+  } else {
+    t17 = $[31];
+  }
+  useEffect(t16, t17);
+  let t18;
+  if ($[32] !== highlight || $[33] !== view) {
+    t18 = () => {
+      if (view) {
+        if (highlight) {
+          highlightCommands.toggleAutocompleteHighlight(highlight)(view.state, view.dispatch);
+        } else {
+          highlightCommands.removeAutocompleteHighlight()(view.state, view.dispatch);
+        }
+      }
+    };
+    $[32] = highlight;
+    $[33] = view;
+    $[34] = t18;
+  } else {
+    t18 = $[34];
+  }
+  const t19 = highlight?.from;
+  const t20 = highlight?.to;
+  let t21;
+  if ($[35] !== t19 || $[36] !== t20) {
+    t21 = [t19, t20];
+    $[35] = t19;
+    $[36] = t20;
+    $[37] = t21;
+  } else {
+    t21 = $[37];
+  }
+  useEffect(t18, t21);
+  const proseClass = proseClasses[textSize];
+  const t22 = isMarkdownMode ? "Switch to Visual Editor" : "Switch to Markdown";
+  const t23 = isMarkdownMode ? "Visual" : "Markdown";
+  let t24;
+  if ($[38] !== handleToggleMarkdown || $[39] !== t22 || $[40] !== t23) {
+    t24 = /* @__PURE__ */ jsx("button", { type: "button", onClick: handleToggleMarkdown, title: t22, className: "absolute top-2 right-2 z-10 px-2 py-1 text-xs font-medium text-surface-400 hover:text-surface-700 dark:text-surface-600 dark:hover:text-surface-300 transition-colors opacity-50 hover:opacity-100 bg-transparent rounded", children: t23 });
+    $[38] = handleToggleMarkdown;
+    $[39] = t22;
+    $[40] = t23;
+    $[41] = t24;
+  } else {
+    t24 = $[41];
+  }
+  let t25;
+  if ($[42] !== state || $[43] !== view) {
+    t25 = {
+      state,
+      view
+    };
+    $[42] = state;
+    $[43] = view;
+    $[44] = t25;
+  } else {
+    t25 = $[44];
+  }
+  const t26 = isMarkdownMode ? "none" : "block";
+  let t27;
+  if ($[45] !== t26) {
+    t27 = {
+      display: t26
+    };
+    $[45] = t26;
+    $[46] = t27;
+  } else {
+    t27 = $[46];
+  }
+  let t28;
+  if ($[47] !== proseClass) {
+    t28 = cls(proseClass, "prose-headings:font-title font-default focus:outline-none max-w-full p-12");
+    $[47] = proseClass;
+    $[48] = t28;
+  } else {
+    t28 = $[48];
+  }
+  let t29;
+  if ($[49] !== editorRef || $[50] !== t28) {
+    t29 = /* @__PURE__ */ jsx("div", { ref: editorRef, className: t28 });
+    $[49] = editorRef;
+    $[50] = t28;
+    $[51] = t29;
+  } else {
+    t29 = $[51];
+  }
+  let t30;
+  if ($[52] !== editorRef || $[53] !== openLink || $[54] !== openNode || $[55] !== view) {
+    t30 = view && /* @__PURE__ */ jsxs(Fragment$1, { children: [
+      /* @__PURE__ */ jsxs(EditorBubble, { options: {
+        placement: "top",
+        offset: 6
+      }, className: cls("flex w-fit max-w-[90vw] h-10 overflow-hidden rounded border bg-white dark:bg-surface-900 shadow", defaultBorderMixin), children: [
+        /* @__PURE__ */ jsx(NodeSelector, { portalContainer: editorRef.current, open: openNode, onOpenChange: setOpenNode }),
+        /* @__PURE__ */ jsx(Separator, { orientation: "vertical" }),
+        /* @__PURE__ */ jsx(LinkSelector, { open: openLink, onOpenChange: setOpenLink }),
+        /* @__PURE__ */ jsx(Separator, { orientation: "vertical" }),
+        /* @__PURE__ */ jsx(TextButtons, {})
+      ] }),
+      /* @__PURE__ */ jsx(ImageBubble, { options: {
+        placement: "bottom",
+        offset: 6
+      } }),
+      /* @__PURE__ */ jsx(TableBubble, {})
+    ] });
+    $[52] = editorRef;
+    $[53] = openLink;
+    $[54] = openNode;
+    $[55] = view;
+    $[56] = t30;
+  } else {
+    t30 = $[56];
+  }
+  let t31;
+  if ($[57] !== aiController || $[58] !== handleImageUpload) {
+    t31 = /* @__PURE__ */ jsx(SlashCommandMenu, { upload: handleImageUpload, aiController });
+    $[57] = aiController;
+    $[58] = handleImageUpload;
+    $[59] = t31;
+  } else {
+    t31 = $[59];
+  }
+  let t32;
+  if ($[60] !== t27 || $[61] !== t29 || $[62] !== t30 || $[63] !== t31) {
+    t32 = /* @__PURE__ */ jsxs("div", { style: t27, children: [
+      t29,
+      t30,
+      t31
+    ] });
+    $[60] = t27;
+    $[61] = t29;
+    $[62] = t30;
+    $[63] = t31;
+    $[64] = t32;
+  } else {
+    t32 = $[64];
+  }
+  let t33;
+  if ($[65] !== handleMarkdownBlur || $[66] !== handleMarkdownChange || $[67] !== internalMarkdown || $[68] !== isMarkdownMode || $[69] !== proseClass) {
+    t33 = isMarkdownMode && /* @__PURE__ */ jsx(TextareaAutosize, { value: internalMarkdown, onChange: handleMarkdownChange, onBlur: handleMarkdownBlur, className: cls("w-full min-h-[300px] p-12 bg-transparent resize-none font-mono focus:ring-0 focus:outline-none outline-none", proseClass), style: {
+      tabSize: 4,
+      outline: "none",
+      border: "none",
+      boxShadow: "none"
+    } });
+    $[65] = handleMarkdownBlur;
+    $[66] = handleMarkdownChange;
+    $[67] = internalMarkdown;
+    $[68] = isMarkdownMode;
+    $[69] = proseClass;
+    $[70] = t33;
+  } else {
+    t33 = $[70];
+  }
+  let t34;
+  if ($[71] !== t25 || $[72] !== t32 || $[73] !== t33) {
+    t34 = /* @__PURE__ */ jsxs(ProseMirrorContext.Provider, { value: t25, children: [
+      t32,
+      t33
+    ] });
+    $[71] = t25;
+    $[72] = t32;
+    $[73] = t33;
+    $[74] = t34;
+  } else {
+    t34 = $[74];
+  }
+  let t35;
+  if ($[75] !== t24 || $[76] !== t34) {
+    t35 = /* @__PURE__ */ jsxs("div", { className: "relative min-h-[300px] w-full", children: [
+      t24,
+      t34
+    ] });
+    $[75] = t24;
+    $[76] = t34;
+    $[77] = t35;
+  } else {
+    t35 = $[77];
+  }
+  return t35;
+};
+const cssStyles = `
+.ProseMirror {
+    box-shadow: none !important;
+}
+.ProseMirror .is-editor-empty:first-child::before {
+  content: attr(data-placeholder);
+  float: left;
+  color:  rgb(100 116 139); //500
+  pointer-events: none;
+  height: 0;
+}
+.ProseMirror .is-empty::before {
+  content: attr(data-placeholder);
+  float: left;
+  color:  rgb(100 116 139); //500
+  pointer-events: none;
+  height: 0;
+}
+
+[data-theme="dark"] {
+  .ProseMirror .is-empty::before {
+    color: rgb(100 116 139); //500
+  }
+}
+
+.is-empty {
+  cursor: text;
+  color: rgb(100 116 139); //500
+}
+
+.ProseMirror img {
+  transition: filter 0.1s ease-in-out;
+  &:hover {
+    cursor: pointer;
+    filter: brightness(90%);
+  }
+  &.ProseMirror-selectednode {
+    filter: brightness(90%);
+    box-shadow: var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow, 0 0 #0000) !important;
+  }
+}
+
+ul[data-type="taskList"] li > label {
+  margin-right: 0.2rem;
+  user-select: none;
+}
+@media screen and (max-width: 768px) {
+  ul[data-type="taskList"] li > label {
+    margin-right: 0.5rem;
+  }
+}
+[data-theme="dark"] {
+  ul[data-type="taskList"] li > label input[type="checkbox"] {
+    background-color: rgb(30 41 59);
+    border: 2px solid #666;
+    &:hover { background-color: rgb(51 65 85); }
+    &:active { background-color: rgb(71 85 105); }
+  }
+}
+ul[data-type="taskList"] li > label input[type="checkbox"] {
+  -webkit-appearance: none;
+  appearance: none;
+  background-color: white;
+  margin: 0;
+  cursor: pointer;
+  width: 1.2em;
+  height: 1.2em;
+  position: relative;
+  top: 5px;
+  border: 2px solid #777;
+  border-radius: 0.25em;
+  margin-right: 0.3rem;
+  display: grid;
+  place-content: center;
+  &:hover { background-color: rgb(241 245 249); }
+  &:active { background-color: rgb(226 232 240); }
+  &::before {
+    content: "";
+    width: 0.65em;
+    height: 0.65em;
+    transform: scale(0);
+    transition: 120ms transform ease-in-out;
+    box-shadow: inset 1em 1em;
+    transform-origin: center;
+    clip-path: polygon(14% 44%, 0 65%, 50% 100%, 100% 16%, 80% 0%, 43% 62%);
+  }
+  &:checked::before { transform: scale(1); }
+}
+
+[data-theme="dark"] {
+  ul[data-type="taskList"] li[data-checked="true"] > div > p {
+    color: rgb(226 232 240);
+    text-decoration: line-through;
+    text-decoration-thickness: 2px;
+  }
+}
+ul[data-type="taskList"] li[data-checked="true"] > div > p {
+  color: rgb(51 65 85);
+  text-decoration: line-through;
+  text-decoration-thickness: 2px;
+}
+.tippy-box { max-width: 400px !important; }
+
+.ProseMirror:not(.dragging) .ProseMirror-selectednode {
+  background-color: rgb(219 234 254);
+  transition: background-color 0.2s;
+  box-shadow: none;
+}
+[data-theme="dark"] .ProseMirror:not(.dragging) .ProseMirror-selectednode {
+  background-color:  rgb(51 65 85);
+}
+.prose-base table p { margin: 0; }
+
+.drag-handle {
+  position: absolute;
+  opacity: 1;
+  transition: opacity ease-in 0.2s;
+  border-radius: 0.25rem;
+  background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 10 10' style='fill: rgba(128, 128, 128, 0.9)'%3E%3Cpath d='M3,2 C2.44771525,2 2,1.55228475 2,1 C2,0.44771525 2.44771525,0 3,0 C3.55228475,0 4,0.44771525 4,1 C4,1.55228475 3.55228475,2 3,2 Z M3,6 C2.44771525,6 2,5.55228475 2,5 C2,4.44771525 2.44771525,4 3,4 C3.55228475,4 4,4.44771525 4,5 C4,5.55228475 3.55228475,6 3,6 Z M3,10 C2.44771525,10 2,9.55228475 2,9 C2,8.44771525 2.44771525,8 3,8 C3.55228475,8 4,8.44771525 4,9 C4,9.55228475 3.55228475,10 3,10 Z M7,2 C6.44771525,2 6,1.55228475 6,1 C6,0.44771525 6.44771525,0 7,0 C7.55228475,0 8,0.44771525 8,1 C8,1.55228475 7.55228475,2 7,2 Z M7,6 C6.44771525,6 6,5.55228475 6,5 C6,4.44771525 6.44771525,4 7,4 C7.55228475,4 8,4.44771525 8,5 C8,5.55228475 7.55228475,6 7,6 Z M7,10 C6.44771525,10 6,9.55228475 6,9 C6,8.44771525 6.44771525,8 7,8 C7,8.44771525 7,9 7,9 C7,9.55228475 7,10 7,10 Z'%3E%3C/path%3E%3C/svg%3E");
+  background-size: calc(0.5em + 0.375rem) calc(0.5em + 0.375rem);
+  background-repeat: no-repeat;
+  background-position: center;
+  width: 1.2rem;
+  height: 1.5rem;
+  z-index: 100;
+  cursor: grab;
+  
+  /* Create a hover area around the handle itself that doesn't overlap text */
+  &::before {
+    content: '';
+    position: absolute;
+    top: -10px;
+    bottom: -10px;
+    left: -20px; 
+    right: 0px;
+    z-index: -1;
+  }
+  
+  &:hover { background-color: rgb(241 245 249); transition: background-color 0.2s; }
+  &:active { background-color: rgb(226 232 240); transition: background-color 0.2s; }
+  &.hide { opacity: 0; pointer-events: none; }
+  @media screen and (max-width: 600px) { display: none; pointer-events: none; }
+}
+[data-theme="dark"] .drag-handle {
+  &:hover { background-color: rgb(51 65 85); }
+  &:active { background-color: rgb(51 65 85); }
+}
+.prosemirror-dropcursor-block {
+  background-color: var(--color-surface-accent-600);
+}
+[data-theme="dark"] .prosemirror-dropcursor-block {
+  background-color: var(--color-surface-accent-300);
+}
+
+.ProseMirror table {
+  border-collapse: separate;
+  border-spacing: 0;
+  table-layout: fixed;
+  width: 100%;
+  margin: 1em 0;
+  overflow: hidden;
+  border-radius: 0.375rem;
+  border: 1px solid #e5e7eb;
+}
+[data-theme="dark"] .ProseMirror table {
+  border-color: #374151;
+}
+
+.ProseMirror td, .ProseMirror th {
+  min-width: 1em;
+  padding: 8px 10px;
+  vertical-align: top;
+  box-sizing: border-box;
+  position: relative;
+  border-right: 1px solid #e5e7eb;
+  border-bottom: 1px solid #e5e7eb;
+}
+[data-theme="dark"] .ProseMirror td, [data-theme="dark"] .ProseMirror th {
+  border-right-color: #374151;
+  border-bottom-color: #374151;
+}
+
+.ProseMirror tr:last-child td, .ProseMirror tr:last-child th {
+  border-bottom: none;
+}
+.ProseMirror th:last-child, .ProseMirror td:last-child {
+  border-right: none;
+}
+
+.ProseMirror th {
+  font-weight: 600;
+  text-align: left;
+  background-color: #f9fafb;
+}
+[data-theme="dark"] .ProseMirror th {
+  background-color: #1f2937;
+}
+`;
+export {
+  FireCMSEditor
+};
+//# sourceMappingURL=editor-BSo_aS1I.js.map