@rebasepro/admin 0.0.1-canary.4f204c2

package/dist/editor.js

@@ -0,0 +1,3834 @@
+import { jsx, jsxs, Fragment as Fragment$1 } from "react/jsx-runtime";
+import React__default, { createContext, useContext, forwardRef, useRef, useState, useEffect, useLayoutEffect, useMemo } from "react";
+import { defaultBorderMixin, cls, iconSize, TextField, IconButton, Tooltip, Popover, Button, focusedDisabled, useInjectStyles, Separator, TextareaAutosize } from "@rebasepro/ui";
+import { useTranslation } from "@rebasepro/core";
+import { c } from "react-compiler-runtime";
+import { autoUpdate, computePosition, offset, flip, shift } from "@floating-ui/dom";
+import { NodeSelection, PluginKey, Plugin, TextSelection, EditorState } from "prosemirror-state";
+import { Slot } from "@radix-ui/react-slot";
+import { Fragment, DOMParser, DOMSerializer } from "prosemirror-model";
+import { TypeIcon, CheckSquareIcon, Heading1Icon, Heading2Icon, Heading3Icon, ListIcon, ListOrderedIcon, QuoteIcon, CodeIcon, ImageIcon, TableIcon, Wand2Icon, ChevronDownIcon, CheckIcon, Trash2Icon, BoldIcon, ItalicIcon, UnderlineIcon, StrikethroughIcon } from "lucide-react";
+import { setBlockType, wrapIn, toggleMark, baseKeymap } from "prosemirror-commands";
+import { wrapInList, sinkListItem, liftListItem, splitListItem } from "prosemirror-schema-list";
+import { s as schema, p as parser, a as serializer } from "./markdown-z2Ir7Cgo.js";
+import { DecorationSet, Decoration, EditorView } from "prosemirror-view";
+import { addRowBefore, addRowAfter, deleteRow, addColumnBefore, addColumnAfter, deleteColumn, deleteTable, goToNextCell, columnResizing, tableEditing } from "prosemirror-tables";
+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
+        };
+      }
+    }
+  });
+}
+async function onFileRead(view, readerEvent, pos, upload, image) {
+  const {
+    schema: schema2
+  } = view.state;
+  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);
+  const replacePlaceholder = () => {
+    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) {
+        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 suggestionItems = [{
+  title: "Text",
+  description: "Just start typing with plain text.",
+  searchTerms: ["p", "paragraph"],
+  icon: /* @__PURE__ */ jsx(TypeIcon, { size: iconSize.small }),
+  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(CheckSquareIcon, { size: iconSize.small }),
+  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(Heading1Icon, { size: iconSize.small }),
+  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(Heading2Icon, { size: iconSize.small }),
+  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(Heading3Icon, { size: iconSize.small }),
+  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(ListIcon, { size: iconSize.small }),
+  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(ListOrderedIcon, { size: iconSize.small }),
+  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(QuoteIcon, { size: iconSize.small }),
+  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: iconSize.small }),
+  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: iconSize.small }),
+  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(TableIcon, { size: iconSize.small }),
+  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(Wand2Icon, { size: iconSize.small }),
+  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) {
+        textLoadingCommands.toggleLoadingDecoration(view.state, view.dispatch, buffer);
+      }
+    });
+    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-800 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-800 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-800", 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(42);
+  const {
+    options,
+    className
+  } = t0;
+  const {
+    view,
+    state
+  } = useProseMirrorContext();
+  const {
+    t
+  } = useTranslation();
+  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-800 shadow-lg", defaultBorderMixin, className);
+    $[18] = className;
+    $[19] = t7;
+  } else {
+    t7 = $[19];
+  }
+  let t8;
+  if ($[20] !== t) {
+    t8 = t("alt_text");
+    $[20] = t;
+    $[21] = t8;
+  } else {
+    t8 = $[21];
+  }
+  let t9;
+  if ($[22] !== handleSave || $[23] !== title) {
+    t9 = (e_3) => {
+      setAlt(e_3.target.value);
+      handleSave(e_3.target.value, title);
+    };
+    $[22] = handleSave;
+    $[23] = title;
+    $[24] = t9;
+  } else {
+    t9 = $[24];
+  }
+  let t10;
+  if ($[25] !== alt || $[26] !== t8 || $[27] !== t9) {
+    t10 = /* @__PURE__ */ jsx(TextField, { size: "small", placeholder: t8, value: alt, onChange: t9 });
+    $[25] = alt;
+    $[26] = t8;
+    $[27] = t9;
+    $[28] = t10;
+  } else {
+    t10 = $[28];
+  }
+  let t11;
+  if ($[29] !== t) {
+    t11 = t("title");
+    $[29] = t;
+    $[30] = t11;
+  } else {
+    t11 = $[30];
+  }
+  let t12;
+  if ($[31] !== alt || $[32] !== handleSave) {
+    t12 = (e_4) => {
+      setTitle(e_4.target.value);
+      handleSave(alt, e_4.target.value);
+    };
+    $[31] = alt;
+    $[32] = handleSave;
+    $[33] = t12;
+  } else {
+    t12 = $[33];
+  }
+  let t13;
+  if ($[34] !== t11 || $[35] !== t12 || $[36] !== title) {
+    t13 = /* @__PURE__ */ jsx(TextField, { size: "small", placeholder: t11, value: title, onChange: t12 });
+    $[34] = t11;
+    $[35] = t12;
+    $[36] = title;
+    $[37] = t13;
+  } else {
+    t13 = $[37];
+  }
+  let t14;
+  if ($[38] !== t10 || $[39] !== t13 || $[40] !== t7) {
+    t14 = /* @__PURE__ */ jsxs("div", { ref: menuRef, style: t6, className: t7, onMouseDown: _temp$3, children: [
+      t10,
+      t13
+    ] });
+    $[38] = t10;
+    $[39] = t13;
+    $[40] = t7;
+    $[41] = t14;
+  } else {
+    t14 = $[41];
+  }
+  return t14;
+});
+ImageBubble.displayName = "ImageBubble";
+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(104);
+  const {
+    options,
+    className
+  } = t0;
+  const {
+    view,
+    state
+  } = useProseMirrorContext();
+  const {
+    t
+  } = useTranslation();
+  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-800 shadow-lg", defaultBorderMixin, className);
+    $[19] = className;
+    $[20] = t8;
+  } else {
+    t8 = $[20];
+  }
+  let t9;
+  if ($[21] !== t) {
+    t9 = t("add_row_before");
+    $[21] = t;
+    $[22] = t9;
+  } else {
+    t9 = $[22];
+  }
+  let t10;
+  if ($[23] !== executeCommand) {
+    t10 = () => executeCommand(addRowBefore);
+    $[23] = executeCommand;
+    $[24] = t10;
+  } else {
+    t10 = $[24];
+  }
+  let t11;
+  if ($[25] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t11 = /* @__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" })
+    ] });
+    $[25] = t11;
+  } else {
+    t11 = $[25];
+  }
+  let t12;
+  if ($[26] !== t10) {
+    t12 = /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: t10, children: t11 });
+    $[26] = t10;
+    $[27] = t12;
+  } else {
+    t12 = $[27];
+  }
+  let t13;
+  if ($[28] !== t12 || $[29] !== t9) {
+    t13 = /* @__PURE__ */ jsx(Tooltip, { title: t9, children: t12 });
+    $[28] = t12;
+    $[29] = t9;
+    $[30] = t13;
+  } else {
+    t13 = $[30];
+  }
+  let t14;
+  if ($[31] !== t) {
+    t14 = t("add_row_after");
+    $[31] = t;
+    $[32] = t14;
+  } else {
+    t14 = $[32];
+  }
+  let t15;
+  if ($[33] !== executeCommand) {
+    t15 = () => executeCommand(addRowAfter);
+    $[33] = executeCommand;
+    $[34] = t15;
+  } else {
+    t15 = $[34];
+  }
+  let t16;
+  if ($[35] === /* @__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: "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" })
+    ] });
+    $[35] = t16;
+  } else {
+    t16 = $[35];
+  }
+  let t17;
+  if ($[36] !== t15) {
+    t17 = /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: t15, children: t16 });
+    $[36] = t15;
+    $[37] = t17;
+  } else {
+    t17 = $[37];
+  }
+  let t18;
+  if ($[38] !== t14 || $[39] !== t17) {
+    t18 = /* @__PURE__ */ jsx(Tooltip, { title: t14, children: t17 });
+    $[38] = t14;
+    $[39] = t17;
+    $[40] = t18;
+  } else {
+    t18 = $[40];
+  }
+  let t19;
+  if ($[41] !== t) {
+    t19 = t("delete_row");
+    $[41] = t;
+    $[42] = t19;
+  } else {
+    t19 = $[42];
+  }
+  let t20;
+  if ($[43] !== executeCommand) {
+    t20 = () => executeCommand(deleteRow);
+    $[43] = executeCommand;
+    $[44] = t20;
+  } else {
+    t20 = $[44];
+  }
+  let t21;
+  if ($[45] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t21 = /* @__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" })
+    ] });
+    $[45] = t21;
+  } else {
+    t21 = $[45];
+  }
+  let t22;
+  if ($[46] !== t20) {
+    t22 = /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: t20, children: t21 });
+    $[46] = t20;
+    $[47] = t22;
+  } else {
+    t22 = $[47];
+  }
+  let t23;
+  if ($[48] !== t19 || $[49] !== t22) {
+    t23 = /* @__PURE__ */ jsx(Tooltip, { title: t19, children: t22 });
+    $[48] = t19;
+    $[49] = t22;
+    $[50] = t23;
+  } else {
+    t23 = $[50];
+  }
+  let t24;
+  if ($[51] !== t13 || $[52] !== t18 || $[53] !== t23) {
+    t24 = /* @__PURE__ */ jsxs("div", { className: "flex gap-1 border-r pr-1 mr-1 dark:border-gray-700", children: [
+      t13,
+      t18,
+      t23
+    ] });
+    $[51] = t13;
+    $[52] = t18;
+    $[53] = t23;
+    $[54] = t24;
+  } else {
+    t24 = $[54];
+  }
+  let t25;
+  if ($[55] !== t) {
+    t25 = t("add_column_before");
+    $[55] = t;
+    $[56] = t25;
+  } else {
+    t25 = $[56];
+  }
+  let t26;
+  if ($[57] !== executeCommand) {
+    t26 = () => executeCommand(addColumnBefore);
+    $[57] = executeCommand;
+    $[58] = t26;
+  } else {
+    t26 = $[58];
+  }
+  let t27;
+  if ($[59] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t27 = /* @__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" })
+    ] });
+    $[59] = t27;
+  } else {
+    t27 = $[59];
+  }
+  let t28;
+  if ($[60] !== t26) {
+    t28 = /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: t26, children: t27 });
+    $[60] = t26;
+    $[61] = t28;
+  } else {
+    t28 = $[61];
+  }
+  let t29;
+  if ($[62] !== t25 || $[63] !== t28) {
+    t29 = /* @__PURE__ */ jsx(Tooltip, { title: t25, children: t28 });
+    $[62] = t25;
+    $[63] = t28;
+    $[64] = t29;
+  } else {
+    t29 = $[64];
+  }
+  let t30;
+  if ($[65] !== t) {
+    t30 = t("add_column_after");
+    $[65] = t;
+    $[66] = t30;
+  } else {
+    t30 = $[66];
+  }
+  let t31;
+  if ($[67] !== executeCommand) {
+    t31 = () => executeCommand(addColumnAfter);
+    $[67] = executeCommand;
+    $[68] = t31;
+  } else {
+    t31 = $[68];
+  }
+  let t32;
+  if ($[69] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t32 = /* @__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" })
+    ] });
+    $[69] = t32;
+  } else {
+    t32 = $[69];
+  }
+  let t33;
+  if ($[70] !== t31) {
+    t33 = /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: t31, children: t32 });
+    $[70] = t31;
+    $[71] = t33;
+  } else {
+    t33 = $[71];
+  }
+  let t34;
+  if ($[72] !== t30 || $[73] !== t33) {
+    t34 = /* @__PURE__ */ jsx(Tooltip, { title: t30, children: t33 });
+    $[72] = t30;
+    $[73] = t33;
+    $[74] = t34;
+  } else {
+    t34 = $[74];
+  }
+  let t35;
+  if ($[75] !== t) {
+    t35 = t("delete_column");
+    $[75] = t;
+    $[76] = t35;
+  } else {
+    t35 = $[76];
+  }
+  let t36;
+  if ($[77] !== executeCommand) {
+    t36 = () => executeCommand(deleteColumn);
+    $[77] = executeCommand;
+    $[78] = t36;
+  } else {
+    t36 = $[78];
+  }
+  let t37;
+  if ($[79] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t37 = /* @__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" })
+    ] });
+    $[79] = t37;
+  } else {
+    t37 = $[79];
+  }
+  let t38;
+  if ($[80] !== t36) {
+    t38 = /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: t36, children: t37 });
+    $[80] = t36;
+    $[81] = t38;
+  } else {
+    t38 = $[81];
+  }
+  let t39;
+  if ($[82] !== t35 || $[83] !== t38) {
+    t39 = /* @__PURE__ */ jsx(Tooltip, { title: t35, children: t38 });
+    $[82] = t35;
+    $[83] = t38;
+    $[84] = t39;
+  } else {
+    t39 = $[84];
+  }
+  let t40;
+  if ($[85] !== t29 || $[86] !== t34 || $[87] !== t39) {
+    t40 = /* @__PURE__ */ jsxs("div", { className: "flex gap-1 border-r pr-1 mr-1 dark:border-gray-700", children: [
+      t29,
+      t34,
+      t39
+    ] });
+    $[85] = t29;
+    $[86] = t34;
+    $[87] = t39;
+    $[88] = t40;
+  } else {
+    t40 = $[88];
+  }
+  let t41;
+  if ($[89] !== t) {
+    t41 = t("delete_table");
+    $[89] = t;
+    $[90] = t41;
+  } else {
+    t41 = $[90];
+  }
+  let t42;
+  if ($[91] !== executeCommand) {
+    t42 = () => executeCommand(deleteTable);
+    $[91] = executeCommand;
+    $[92] = t42;
+  } else {
+    t42 = $[92];
+  }
+  let t43;
+  if ($[93] === /* @__PURE__ */ Symbol.for("react.memo_cache_sentinel")) {
+    t43 = /* @__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" })
+    ] });
+    $[93] = t43;
+  } else {
+    t43 = $[93];
+  }
+  let t44;
+  if ($[94] !== t42) {
+    t44 = /* @__PURE__ */ jsx(IconButton, { size: "small", onClick: t42, children: t43 });
+    $[94] = t42;
+    $[95] = t44;
+  } else {
+    t44 = $[95];
+  }
+  let t45;
+  if ($[96] !== t41 || $[97] !== t44) {
+    t45 = /* @__PURE__ */ jsx(Tooltip, { title: t41, children: t44 });
+    $[96] = t41;
+    $[97] = t44;
+    $[98] = t45;
+  } else {
+    t45 = $[98];
+  }
+  let t46;
+  if ($[99] !== t24 || $[100] !== t40 || $[101] !== t45 || $[102] !== t8) {
+    t46 = /* @__PURE__ */ jsxs("div", { ref: menuRef, style: t7, className: t8, onMouseDown: _temp$2, children: [
+      t24,
+      t40,
+      t45
+    ] });
+    $[99] = t24;
+    $[100] = t40;
+    $[101] = t45;
+    $[102] = t8;
+    $[103] = t46;
+  } else {
+    t46 = $[103];
+  }
+  return t46;
+});
+TableBubble.displayName = "TableBubble";
+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 selection = state.selection;
+  const {
+    $from,
+    to
+  } = selection;
+  const node = selection instanceof TextSelection ? void 0 : selection.node;
+  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 selection = state.selection;
+    const {
+      empty,
+      $cursor,
+      ranges
+    } = selection;
+    if (empty && !$cursor || !type) return false;
+    if (dispatch) {
+      if ($cursor) {
+        dispatch(state.tr.addStoredMark(type.create(attrs)));
+      } else {
+        const tr = state.tr;
+        for (let i = 0; i < ranges.length; i++) {
+          const {
+            $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 selection = state.selection;
+    const {
+      empty,
+      $cursor,
+      ranges
+    } = selection;
+    if (empty && !$cursor || !type) return false;
+    if (dispatch) {
+      const 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++) {
+          const {
+            $from,
+            $to
+          } = ranges[i];
+          tr.removeMark($from.pos, $to.pos, type);
+        }
+        dispatch(tr.scrollIntoView());
+      }
+    }
+    return true;
+  };
+}
+const items = [{
+  name: "Text",
+  labelKey: "editor_text",
+  icon: TypeIcon,
+  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: Heading1Icon,
+  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: Heading2Icon,
+  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: Heading3Icon,
+  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: CheckSquareIcon,
+  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: ListIcon,
+  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: ListOrderedIcon,
+  command: (state, dispatch) => wrapInList(schema.nodes.ordered_list)(state, dispatch),
+  isActive: (state) => isNodeActive(state, schema.nodes.ordered_list)
+}, {
+  name: "Quote",
+  labelKey: "editor_quote",
+  icon: QuoteIcon,
+  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(ChevronDownIcon, { size: iconSize.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: iconSize.smallest }),
+        /* @__PURE__ */ jsx("span", { children: t(item_0.labelKey) })
+      ] }),
+      activeItem.name === item_0.name && /* @__PURE__ */ jsx(CheckIcon, { size: iconSize.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(Trash2Icon, { size: iconSize.small }) }) : /* @__PURE__ */ jsx(Button, { size: "small", type: "submit", variant: "text", children: /* @__PURE__ */ jsx(CheckIcon, { size: iconSize.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: BoldIcon
+    }, {
+      name: "italic",
+      labelKey: "editor_italic",
+      isActive: _temp3,
+      command: _temp4,
+      icon: ItalicIcon
+    }, {
+      name: "underline",
+      labelKey: "editor_underline",
+      isActive: _temp5,
+      command: _temp6,
+      icon: UnderlineIcon
+    }, {
+      name: "strike",
+      labelKey: "editor_strikethrough",
+      isActive: _temp7,
+      command: _temp8,
+      icon: StrikethroughIcon
+    }, {
+      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;
+  const blockSelector = 'li, p, pre, blockquote, h1, h2, h3, h4, h5, h6, img, [data-type="taskList"]';
+  const elem = document.elementFromPoint(coords.x, coords.y);
+  const block = elem?.closest(blockSelector);
+  if (block && view.dom.contains(block) && block.textContent?.trim()) {
+    const li = block.closest("li");
+    return li && view.dom.contains(li) ? li : block;
+  }
+  const probeX = editorRect.left + Math.min(60, editorRect.width / 4);
+  if (coords.x > probeX) return void 0;
+  const probeElem = document.elementFromPoint(probeX, coords.y);
+  const probeBlock = probeElem?.closest(blockSelector);
+  if (probeBlock && probeBlock.textContent?.trim()) {
+    if (view.dom.contains(probeBlock)) {
+      const li = probeBlock.closest("li");
+      return li && view.dom.contains(li) ? 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");
+      dragHandleElement.style.opacity = "0";
+      dragHandleElement.style.pointerEvents = "none";
+    }
+  }
+  function showDragHandle() {
+    if (dragHandleElement) {
+      dragHandleElement.classList.remove("hide");
+      dragHandleElement.style.opacity = "1";
+      dragHandleElement.style.pointerEvents = "auto";
+    }
+  }
+  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;
+        const $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));
+        const 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));
+        const 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;
+          const {
+            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 ("type" in nodeToInsert && nodeToInsert.type.name === "list_item" && !isTargetList) {
+              nodeToInsert = nodeToInsert.content;
+            } else if ("type" in nodeToInsert && nodeToInsert.type.name === "taskItem" && !isTargetTaskList) {
+              nodeToInsert = nodeToInsert.content;
+            }
+            const isFragment = !("type" in nodeToInsert);
+            const needsWrap = isFragment || "type" in nodeToInsert && 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 getCorePlugins = () => [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 = [...getCorePlugins(), 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) => {
+          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 RebaseEditor = ({
+  content,
+  onJsonContentChange,
+  onHtmlContentChange,
+  onMarkdownContentChange,
+  version,
+  textSize = "base",
+  highlight,
+  handleImageUpload,
+  aiController,
+  disabled,
+  markdownConfig
+}) => {
+  const {
+    t
+  } = useTranslation();
+  const [openNode, setOpenNode] = useState(false);
+  const [openLink, setOpenLink] = useState(false);
+  const [isMarkdownMode, setIsMarkdownMode] = useState(false);
+  const [internalMarkdown, setInternalMarkdown] = useState("");
+  useEffect(() => {
+    if (!isMarkdownMode) return;
+    const timeout = setTimeout(() => {
+      if (callbacksRef.current.onMarkdownContentChange) {
+        callbacksRef.current.onMarkdownContentChange(internalMarkdown);
+      }
+    }, 250);
+    return () => clearTimeout(timeout);
+  }, [internalMarkdown, isMarkdownMode]);
+  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);
+    }
+  };
+  const handleMarkdownChange = (e) => {
+    setInternalMarkdown(e.target.value);
+  };
+  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 (e_0) {
+        console.warn("Could not parse markdown to JSON", e_0);
+      }
+    }
+  };
+  useInjectStyles("Editor", cssStyles);
+  const callbacksRef = useRef({
+    onMarkdownContentChange,
+    onJsonContentChange
+  });
+  useEffect(() => {
+    callbacksRef.current = {
+      onMarkdownContentChange,
+      onJsonContentChange
+    };
+  }, [onMarkdownContentChange, onJsonContentChange]);
+  const flushChanges = (currentState) => {
+    const {
+      onMarkdownContentChange: onMarkdownContentChange_1,
+      onJsonContentChange: onJsonContentChange_1
+    } = callbacksRef.current;
+    if (onMarkdownContentChange_1) {
+      try {
+        const markdown = serializer.serialize(currentState.doc);
+        onMarkdownContentChange_1(markdown);
+      } catch (e_1) {
+        console.warn("[RebaseEditor] Could not serialize editor state to markdown:", e_1);
+      }
+    }
+    if (onJsonContentChange_1) {
+      const jsonContent = removeClassesFromJson(currentState.doc.toJSON());
+      onJsonContentChange_1(jsonContent);
+    }
+  };
+  const {
+    state,
+    view,
+    editorRef
+  } = useProseMirror({
+    initialContent: content,
+    editable: !disabled,
+    handleImageUpload
+  });
+  const versionRef = useRef(version);
+  useEffect(() => {
+    if (versionRef.current === version) return;
+    versionRef.current = version;
+    if (!view) return;
+    try {
+      const newDoc_1 = typeof content === "string" ? parser.parse(content ?? "") : content ? schema.nodeFromJSON(content) : schema.node("doc", null, [schema.node("paragraph")]);
+      if (newDoc_1) {
+        const tr_0 = view.state.tr.replaceWith(0, view.state.doc.content.size, newDoc_1.content);
+        view.dispatch(tr_0);
+      }
+    } catch (e_2) {
+      console.warn("[RebaseEditor] Could not reset editor content:", e_2);
+    }
+    if (isMarkdownMode) {
+      setInternalMarkdown(typeof content === "string" ? content : "");
+    }
+    mountTimeRef.current = Date.now();
+    hasUserEditedRef.current = false;
+  }, [version]);
+  const doc = state?.doc;
+  const mountTimeRef = useRef(Date.now());
+  const hasUserEditedRef = useRef(false);
+  useEffect(() => {
+    if (!state) return;
+    const elapsed = Date.now() - mountTimeRef.current;
+    if (elapsed < 500 && !hasUserEditedRef.current) {
+      return;
+    }
+    hasUserEditedRef.current = true;
+    const timeout_0 = setTimeout(() => {
+      flushChanges(state);
+    }, 250);
+    return () => clearTimeout(timeout_0);
+  }, [doc]);
+  useEffect(() => {
+    if (!view) return;
+    const dom = view.dom;
+    const handleBlur = () => {
+      if (!hasUserEditedRef.current) {
+        const elapsed_0 = Date.now() - mountTimeRef.current;
+        if (elapsed_0 < 500) return;
+      }
+      flushChanges(view.state);
+    };
+    dom.addEventListener("blur", handleBlur);
+    return () => dom.removeEventListener("blur", handleBlur);
+  }, [view]);
+  useEffect(() => {
+    if (view) {
+      if (highlight) {
+        highlightCommands.toggleAutocompleteHighlight(highlight)(view.state, view.dispatch);
+      } else {
+        highlightCommands.removeAutocompleteHighlight()(view.state, view.dispatch);
+      }
+    }
+  }, [highlight?.from, highlight?.to]);
+  const proseClass = proseClasses[textSize];
+  return /* @__PURE__ */ jsxs("div", { className: "relative min-h-[200px] w-full", children: [
+    /* @__PURE__ */ jsx("button", { type: "button", onClick: handleToggleMarkdown, title: isMarkdownMode ? "Switch to Visual Editor" : "Switch to Markdown", 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: isMarkdownMode ? "Visual" : "Markdown" }),
+    /* @__PURE__ */ jsxs(ProseMirrorContext.Provider, { value: useMemo(() => ({
+      state,
+      view
+    }), [state, view]), children: [
+      /* @__PURE__ */ jsxs("div", { style: {
+        display: isMarkdownMode ? "none" : "block"
+      }, children: [
+        /* @__PURE__ */ jsx("div", { ref: editorRef, className: cls("relative prose dark:prose-invert", proseClass, "prose-headings:font-title prose-headings:font-normal prose-strong:font-semibold prose-code:font-normal prose-blockquote:font-normal prose-a:font-normal font-default focus:outline-none max-w-full p-12") }),
+        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-800 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, {})
+        ] }),
+        /* @__PURE__ */ jsx(SlashCommandMenu, { upload: handleImageUpload, aiController })
+      ] }),
+      isMarkdownMode && /* @__PURE__ */ jsx(TextareaAutosize, { value: internalMarkdown, onChange: handleMarkdownChange, onBlur: handleMarkdownBlur, className: cls("w-full h-full min-h-[200px] p-12 bg-transparent resize-none font-mono focus:ring-0", proseClass), style: {
+        tabSize: 4,
+        outline: "none",
+        border: "none",
+        boxShadow: "none"
+      } })
+    ] })
+  ] });
+};
+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;
+}
+.ProseMirror img:hover {
+  cursor: pointer;
+  filter: brightness(90%);
+}
+.ProseMirror img.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;
+}
+[data-theme="dark"] ul[data-type="taskList"] li > label input[type="checkbox"]:hover { background-color: rgb(51 65 85); }
+[data-theme="dark"] ul[data-type="taskList"] li > label input[type="checkbox"]: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;
+}
+ul[data-type="taskList"] li > label input[type="checkbox"]:hover { background-color: rgb(241 245 249); }
+ul[data-type="taskList"] li > label input[type="checkbox"]:active { background-color: rgb(226 232 240); }
+ul[data-type="taskList"] li > label input[type="checkbox"]::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%);
+}
+ul[data-type="taskList"] li > label input[type="checkbox"]: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;
+}
+.drag-handle::before {
+  content: '';
+  position: absolute;
+  top: -10px;
+  bottom: -10px;
+  left: -20px; 
+  right: 0px;
+  z-index: -1;
+}
+.drag-handle:hover { background-color: rgb(241 245 249); transition: background-color 0.2s; }
+.drag-handle:active { background-color: rgb(226 232 240); transition: background-color 0.2s; }
+.drag-handle.hide { opacity: 0; pointer-events: none; }
+@media screen and (max-width: 600px) { .drag-handle { display: none; pointer-events: none; } }
+[data-theme="dark"] .drag-handle:hover { background-color: rgb(51 65 85); }
+[data-theme="dark"] .drag-handle: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 td {
+  background-color: transparent;
+}
+
+.ProseMirror th {
+  font-weight: 600;
+  text-align: left;
+  background-color: #f3f4f6;
+  color: #374151;
+}
+[data-theme="dark"] .ProseMirror td {
+  background-color: transparent;
+}
+[data-theme="dark"] .ProseMirror th {
+  background-color: rgba(255, 255, 255, 0.05);
+  color: #d1d5db;
+}
+`;
+export {
+  RebaseEditor
+};
+//# sourceMappingURL=editor.js.map