@haklex/rich-editor 0.0.82 → 0.0.83

package/dist/SubmitShortcutPlugin-o2y6b-8f.js

@@ -0,0 +1,1650 @@
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { CheckListPlugin } from "@lexical/react/LexicalCheckListPlugin";
+import { LinkPlugin } from "@lexical/react/LexicalLinkPlugin";
+import { ListPlugin } from "@lexical/react/LexicalListPlugin";
+import { TabIndentationPlugin } from "@lexical/react/LexicalTabIndentationPlugin";
+import { TablePlugin } from "@lexical/react/LexicalTablePlugin";
+import { createLinkMatcherWithRegExp, registerAutoLink, LinkNode, AutoLinkNode } from "@lexical/link";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { useEffect, createContext, use, useRef, useState, useMemo, useCallback } from "react";
+import { $isQuoteNode, QuoteNode, $createQuoteNode, DRAG_DROP_PASTE } from "@lexical/rich-text";
+import { KEY_ARROW_RIGHT_COMMAND, $getSelection, $isRangeSelection, COMMAND_PRIORITY_CRITICAL, KEY_ARROW_DOWN_COMMAND, $isDecoratorNode, $isElementNode, $isRootNode, $isParagraphNode, $createParagraphNode, KEY_ENTER_COMMAND, $isNodeSelection, KEY_BACKSPACE_COMMAND, COMMAND_PRIORITY_HIGH, KEY_DELETE_COMMAND, KEY_ARROW_UP_COMMAND, $isTextNode, IS_CODE, $createNodeSelection, $setSelection, $getRoot, COMMAND_PRIORITY_EDITOR, COMMAND_PRIORITY_LOW, $createTextNode, $createLineBreakNode, PASTE_COMMAND, $insertNodes, createEditor, $parseSerializedNode, createState, $getState, $addUpdateTag, $setState, $nodesOfType } from "lexical";
+import { b as setCodeBlockCursorIntent, g as getResolvedEditNodes, $ as $createBannerEditNode, d as $createCodeBlockEditNode } from "./node-registry-Dzp7X3R4.js";
+import { HorizontalRuleNode, $createHorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND } from "@lexical/extension";
+import { HORIZONTAL_RULE_BLOCK_TRANSFORMER as HORIZONTAL_RULE_BLOCK_TRANSFORMER$1, GIT_ALERT_TRANSFORMER as GIT_ALERT_TRANSFORMER$1, COMMENT_TRANSFORMER as COMMENT_TRANSFORMER$1, CONTAINER_TRANSFORMER as CONTAINER_TRANSFORMER$1, FOOTNOTE_TRANSFORMER as FOOTNOTE_TRANSFORMER$1, FOOTNOTE_SECTION_TRANSFORMER as FOOTNOTE_SECTION_TRANSFORMER$1, KATEX_INLINE_TRANSFORMER as KATEX_INLINE_TRANSFORMER$1, KATEX_BLOCK_TRANSFORMER as KATEX_BLOCK_TRANSFORMER$1, MENTION_TRANSFORMER as MENTION_TRANSFORMER$1, RUBY_TRANSFORMER as RUBY_TRANSFORMER$1, SPOILER_TRANSFORMER as SPOILER_TRANSFORMER$1, INSERT_TRANSFORMER, SUPERSCRIPT_TRANSFORMER, SUBSCRIPT_TRANSFORMER, IMAGE_BLOCK_TRANSFORMER, VIDEO_BLOCK_TRANSFORMER, CODE_BLOCK_NODE_TRANSFORMER, LINK_CARD_BLOCK_TRANSFORMER, MERMAID_BLOCK_TRANSFORMER, TABLE_BLOCK_TRANSFORMER } from "@haklex/rich-headless/transformers";
+import { CHECK_LIST, TRANSFORMERS, QUOTE, CODE, $convertFromMarkdownString } from "@lexical/markdown";
+import { $ as $createAlertQuoteEditNode } from "./AlertQuoteEditNode-B2q-1u6S.js";
+import { s as AlertQuoteNode, F as FootnoteNode, w as $createFootnoteNode, k as KaTeXInlineNode, K as KaTeXBlockNode, t as $createKaTeXInlineNode, v as $createKaTeXBlockNode, M as MentionNode, a as $createMentionNode, o as extractTextContent, S as SpoilerNode, x as $createSpoilerNode, $ as $createImageNode, O as OPEN_IMAGE_UPLOAD_DIALOG_COMMAND } from "./theme-Cg8JUW_j.js";
+import { v as CodeBlockNode, C as CommentNode, w as $createCommentPlaceholderNode, $ as $createCommentNode, q as BannerNode, D as DetailsNode, x as $createDetailsNode, F as FootnoteSectionNode, f as $isFootnoteSectionNode, a as $createFootnoteSectionNode, g as $isGridContainerNode, R as RubyNode, d as $createRubyNode } from "./config-BP_kyJbW.js";
+import { $createTableNode, $createTableRowNode, $createTableCellNode, TableCellHeaderStates } from "@lexical/table";
+import { MarkdownShortcutPlugin } from "@lexical/react/LexicalMarkdownShortcutPlugin";
+import { nanoid } from "nanoid";
+import { Dialog, DialogPopup, DialogTitle, SegmentedControl, ActionButton, ActionBar } from "@haklex/rich-editor-ui";
+import { Check, Info, Upload, Link2 } from "lucide-react";
+import { i as computeImageMeta, F as FootnoteDefinitionsProvider } from "./KaTeXRenderer-BFryJSIS.js";
+import "./utils-gy2c_HWc.js";
+import { g as getHostname, p as probeFavicon } from "./favicon-BQgbXF_a.js";
+const URL_REGEX = /https?:\/\/(?:www\.)?[\w#%+.:=@~-]{1,256}\.[A-Za-z]{2}[\w#%&()+./:=?@~-]*/;
+const EMAIL_REGEX = /(?:[\w%+.-]+@[\d.a-z-]+\.[a-z]{2,})/i;
+const URL_MATCHER = createLinkMatcherWithRegExp(URL_REGEX);
+const EMAIL_MATCHER = createLinkMatcherWithRegExp(EMAIL_REGEX, (text) => `mailto:${text}`);
+const DEFAULT_MATCHERS = [URL_MATCHER, EMAIL_MATCHER];
+function AutoLinkPlugin({ matchers }) {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    return registerAutoLink(editor, {
+      matchers: matchers ?? DEFAULT_MATCHERS,
+      changeHandlers: [],
+      excludeParents: []
+    });
+  }, [editor, matchers]);
+  return null;
+}
+function selectDecoratorNode(node, cursorPlacement = "start") {
+  if (node.getType() === "code-block") {
+    setCodeBlockCursorIntent(node.getKey(), cursorPlacement);
+  }
+  const selection = $createNodeSelection();
+  selection.add(node.getKey());
+  $setSelection(selection);
+}
+function isAtTopLevelBoundary(selection, direction) {
+  const point = selection.anchor;
+  const topLevel = point.getNode().getTopLevelElementOrThrow();
+  const pointNode = point.getNode();
+  if (point.type === "text") {
+    if (!$isTextNode(pointNode)) return false;
+    const expectedOffset = direction === "start" ? 0 : pointNode.getTextContentSize();
+    if (point.offset !== expectedOffset) return false;
+  } else {
+    if (!$isElementNode(pointNode)) return false;
+    const expectedOffset = direction === "start" ? 0 : pointNode.getChildrenSize();
+    if (point.offset !== expectedOffset) return false;
+  }
+  let current = pointNode;
+  while (current && current !== topLevel) {
+    const sibling = direction === "start" ? current.getPreviousSibling() : current.getNextSibling();
+    if (sibling !== null) return false;
+    current = current.getParent();
+  }
+  return current === topLevel;
+}
+function isSingleLineParagraph(node) {
+  return $isParagraphNode(node) && !node.getTextContent().includes("\n");
+}
+function getOutermostNodeWithinTopLevel(node, topLevel) {
+  let current = node;
+  while (current.getParent() !== topLevel) {
+    const parent = current.getParent();
+    if (!parent) break;
+    current = parent;
+  }
+  return current;
+}
+function exitInlineCodeAtLineEnd(selection) {
+  if (!selection.isCollapsed() || selection.anchor.type !== "text") {
+    return false;
+  }
+  const anchorNode = selection.anchor.getNode();
+  if (!$isTextNode(anchorNode) || !anchorNode.hasFormat("code")) {
+    return false;
+  }
+  if (selection.anchor.offset !== anchorNode.getTextContentSize()) {
+    return false;
+  }
+  if (!isAtTopLevelBoundary(selection, "end")) {
+    return false;
+  }
+  const topLevel = anchorNode.getTopLevelElementOrThrow();
+  const boundaryNode = getOutermostNodeWithinTopLevel(anchorNode, topLevel);
+  const exitOffset = boundaryNode.getIndexWithinParent() + 1;
+  selection.anchor.set(topLevel.getKey(), exitOffset, "element");
+  selection.focus.set(topLevel.getKey(), exitOffset, "element");
+  selection.setFormat(anchorNode.getFormat() & ~IS_CODE);
+  selection.setStyle(anchorNode.getStyle());
+  return true;
+}
+function BlockExitPlugin() {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    const unregisterArrowRight = editor.registerCommand(
+      KEY_ARROW_RIGHT_COMMAND,
+      (event) => {
+        const selection = $getSelection();
+        if (!$isRangeSelection(selection)) return false;
+        if (!exitInlineCodeAtLineEnd(selection)) return false;
+        event?.preventDefault();
+        return true;
+      },
+      COMMAND_PRIORITY_CRITICAL
+    );
+    const unregisterArrowDown = editor.registerCommand(
+      KEY_ARROW_DOWN_COMMAND,
+      (event) => {
+        const selection = $getSelection();
+        if (!$isRangeSelection(selection) || !selection.isCollapsed()) {
+          return false;
+        }
+        const anchorNode = selection.anchor.getNode();
+        const topLevelElement = anchorNode.getTopLevelElementOrThrow();
+        const shouldSelectNextDecorator = isAtTopLevelBoundary(selection, "end") || isSingleLineParagraph(topLevelElement);
+        if (!$isQuoteNode(topLevelElement) && shouldSelectNextDecorator) {
+          const next2 = topLevelElement.getNextSibling();
+          if (next2 && $isDecoratorNode(next2) && next2.isKeyboardSelectable()) {
+            event?.preventDefault();
+            selectDecoratorNode(next2, "start");
+            return true;
+          }
+        }
+        const element = $isElementNode(anchorNode) ? anchorNode : anchorNode.getParentOrThrow();
+        let quoteChild = element;
+        let quoteNode = null;
+        let current = element;
+        while (current) {
+          const parent = current.getParent();
+          if (!parent || $isRootNode(parent)) break;
+          if ($isQuoteNode(parent)) {
+            quoteNode = parent;
+            quoteChild = current;
+            break;
+          }
+          current = parent;
+        }
+        if (!quoteNode) return false;
+        if (quoteChild.getNextSibling() !== null) return false;
+        if (!$isParagraphNode(quoteChild) || quoteChild.getTextContent() !== "") return false;
+        event?.preventDefault();
+        let next = quoteNode.getNextSibling();
+        if (!next) {
+          next = $createParagraphNode();
+          quoteNode.insertAfter(next);
+        }
+        next.selectStart();
+        return true;
+      },
+      COMMAND_PRIORITY_CRITICAL
+    );
+    const unregisterCmdEnter = editor.registerCommand(
+      KEY_ENTER_COMMAND,
+      (event) => {
+        if (!event?.metaKey && !event?.ctrlKey) return false;
+        const selection = $getSelection();
+        if ($isNodeSelection(selection)) {
+          const nodes = selection.getNodes();
+          if (nodes.length !== 1) return false;
+          const node = nodes[0];
+          if (!$isDecoratorNode(node)) return false;
+          event.preventDefault();
+          let next2 = node.getNextSibling();
+          if (!next2) {
+            next2 = $createParagraphNode();
+            node.insertAfter(next2);
+          }
+          if ($isElementNode(next2)) {
+            next2.selectStart();
+          } else if ($isDecoratorNode(next2)) {
+            selectDecoratorNode(next2, "start");
+          }
+          return true;
+        }
+        if (!$isRangeSelection(selection)) return false;
+        const anchorNode = selection.anchor.getNode();
+        const topLevelElement = anchorNode.getTopLevelElementOrThrow();
+        if ($isParagraphNode(topLevelElement)) return false;
+        event.preventDefault();
+        let next = topLevelElement.getNextSibling();
+        if (!next || !$isParagraphNode(next)) {
+          next = $createParagraphNode();
+          topLevelElement.insertAfter(next);
+        }
+        next.selectStart();
+        return true;
+      },
+      COMMAND_PRIORITY_CRITICAL
+    );
+    function handleDeleteDecorator(event) {
+      const selection = $getSelection();
+      if (!$isNodeSelection(selection)) return false;
+      const nodes = selection.getNodes();
+      if (nodes.length !== 1) return false;
+      const node = nodes[0];
+      if (!$isDecoratorNode(node)) return false;
+      event?.preventDefault();
+      const prev = node.getPreviousSibling();
+      const next = node.getNextSibling();
+      node.remove();
+      if (prev && $isElementNode(prev)) {
+        prev.selectEnd();
+      } else if (prev && $isDecoratorNode(prev)) {
+        selectDecoratorNode(prev, "end");
+      } else if (next && $isElementNode(next)) {
+        next.selectStart();
+      } else if (next && $isDecoratorNode(next)) {
+        selectDecoratorNode(next, "start");
+      } else {
+        const root = $getRoot();
+        if (root && $isElementNode(root)) {
+          const p = $createParagraphNode();
+          root.append(p);
+          p.selectStart();
+        }
+      }
+      return true;
+    }
+    const unregisterBackspace = editor.registerCommand(
+      KEY_BACKSPACE_COMMAND,
+      handleDeleteDecorator,
+      COMMAND_PRIORITY_HIGH
+    );
+    const unregisterDelete = editor.registerCommand(
+      KEY_DELETE_COMMAND,
+      handleDeleteDecorator,
+      COMMAND_PRIORITY_HIGH
+    );
+    const unregisterArrowUpDecorator = editor.registerCommand(
+      KEY_ARROW_UP_COMMAND,
+      (event) => {
+        const selection = $getSelection();
+        if ($isRangeSelection(selection) && selection.isCollapsed()) {
+          const anchorNode = selection.anchor.getNode();
+          const topLevelElement = anchorNode.getTopLevelElementOrThrow();
+          const shouldSelectPreviousDecorator = isAtTopLevelBoundary(selection, "start") || isSingleLineParagraph(topLevelElement);
+          if (!$isQuoteNode(topLevelElement) && shouldSelectPreviousDecorator) {
+            const prev2 = topLevelElement.getPreviousSibling();
+            if (prev2 && $isDecoratorNode(prev2) && prev2.isKeyboardSelectable()) {
+              event?.preventDefault();
+              selectDecoratorNode(prev2, "end");
+              return true;
+            }
+          }
+        }
+        if (!$isNodeSelection(selection)) return false;
+        const nodes = selection.getNodes();
+        if (nodes.length !== 1) return false;
+        const node = nodes[0];
+        if (!$isDecoratorNode(node)) return false;
+        const prev = node.getPreviousSibling();
+        if (prev && $isElementNode(prev)) {
+          event?.preventDefault();
+          prev.selectEnd();
+          return true;
+        }
+        if (prev && $isDecoratorNode(prev)) {
+          event?.preventDefault();
+          selectDecoratorNode(prev, "end");
+          return true;
+        }
+        return false;
+      },
+      COMMAND_PRIORITY_CRITICAL
+    );
+    const unregisterArrowDownDecorator = editor.registerCommand(
+      KEY_ARROW_DOWN_COMMAND,
+      (event) => {
+        const selection = $getSelection();
+        if (!$isNodeSelection(selection)) return false;
+        const nodes = selection.getNodes();
+        if (nodes.length !== 1) return false;
+        const node = nodes[0];
+        if (!$isDecoratorNode(node)) return false;
+        const next = node.getNextSibling();
+        if (next && $isElementNode(next)) {
+          event?.preventDefault();
+          next.selectStart();
+          return true;
+        }
+        if (next && $isDecoratorNode(next)) {
+          event?.preventDefault();
+          selectDecoratorNode(next, "start");
+          return true;
+        }
+        return false;
+      },
+      COMMAND_PRIORITY_CRITICAL
+    );
+    return () => {
+      unregisterArrowRight();
+      unregisterArrowDown();
+      unregisterCmdEnter();
+      unregisterBackspace();
+      unregisterDelete();
+      unregisterArrowUpDecorator();
+      unregisterArrowDownDecorator();
+    };
+  }, [editor]);
+  return null;
+}
+const HORIZONTAL_RULE_REGEX = /^(---|\*\*\*|___)\s?$/;
+const HORIZONTAL_RULE_BLOCK_TRANSFORMER = {
+  ...HORIZONTAL_RULE_BLOCK_TRANSFORMER$1,
+  dependencies: [HorizontalRuleNode],
+  regExp: HORIZONTAL_RULE_REGEX,
+  replace: (parentNode) => {
+    const hrNode = $createHorizontalRuleNode();
+    const paragraph = $createParagraphNode();
+    parentNode.replace(hrNode);
+    hrNode.insertAfter(paragraph);
+    paragraph.selectStart();
+  }
+};
+function HorizontalRulePlugin() {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    const unregisterInsert = editor.registerCommand(
+      INSERT_HORIZONTAL_RULE_COMMAND,
+      () => {
+        const selection = $getSelection();
+        if (!$isRangeSelection(selection)) return false;
+        const focusNode = selection.focus.getNode();
+        const topLevel = focusNode.getTopLevelElement();
+        if (!topLevel) return false;
+        const hrNode = $createHorizontalRuleNode();
+        const paragraph = $createParagraphNode();
+        topLevel.insertAfter(hrNode);
+        hrNode.insertAfter(paragraph);
+        paragraph.selectStart();
+        return true;
+      },
+      COMMAND_PRIORITY_EDITOR
+    );
+    const unregisterEnter = editor.registerCommand(
+      KEY_ENTER_COMMAND,
+      (event) => {
+        const selection = $getSelection();
+        if (!$isRangeSelection(selection) || !selection.isCollapsed()) {
+          return false;
+        }
+        const anchorNode = selection.anchor.getNode();
+        if (!$isTextNode(anchorNode)) return false;
+        const textContent = anchorNode.getTextContent();
+        if (!HORIZONTAL_RULE_REGEX.test(textContent)) return false;
+        const parentNode = anchorNode.getParent();
+        if (!parentNode) return false;
+        event?.preventDefault();
+        const hrNode = $createHorizontalRuleNode();
+        const paragraph = $createParagraphNode();
+        parentNode.replace(hrNode);
+        hrNode.insertAfter(paragraph);
+        paragraph.selectStart();
+        return true;
+      },
+      COMMAND_PRIORITY_LOW
+    );
+    return () => {
+      unregisterInsert();
+      unregisterEnter();
+    };
+  }, [editor]);
+  return null;
+}
+const ALERT_TYPE_MAP = {
+  NOTE: "note",
+  TIP: "tip",
+  IMPORTANT: "important",
+  WARNING: "warning",
+  CAUTION: "caution"
+};
+const GIT_ALERT_TRANSFORMER = {
+  ...GIT_ALERT_TRANSFORMER$1,
+  dependencies: [AlertQuoteNode],
+  regExp: /^>\s*\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]\s*$/,
+  replace: (parentNode, children, match) => {
+    const typeKey = match[1];
+    const alertType = ALERT_TYPE_MAP[typeKey] || "note";
+    const serializedChildren = children.map((child) => child.exportJSON());
+    const content = {
+      root: {
+        children: [
+          {
+            type: "paragraph",
+            children: serializedChildren,
+            direction: null,
+            format: "",
+            indent: 0,
+            textFormat: 0,
+            textStyle: "",
+            version: 1
+          }
+        ],
+        direction: null,
+        format: "",
+        indent: 0,
+        type: "root",
+        version: 1
+      }
+    };
+    const alertNode = $createAlertQuoteEditNode(alertType, content);
+    parentNode.replace(alertNode);
+  }
+};
+function findCodeBlockKlass(nodes) {
+  return nodes.find((n) => n.getType?.() === "code-block") || CodeBlockNode;
+}
+const CODE_BLOCK_MULTILINE_TRANSFORMER = {
+  dependencies: [],
+  regExpEnd: {
+    optional: true,
+    regExp: /[\t ]*```$/
+  },
+  regExpStart: /^[\t ]*```([\w-]+)?/,
+  replace: (rootNode, _children, startMatch, _endMatch, linesInBetween, isImport) => {
+    const lang = startMatch[1] || "";
+    let code = "";
+    if (linesInBetween) {
+      const lines = [...linesInBetween];
+      while (lines.length > 0 && !lines[0].length) lines.shift();
+      while (lines.length > 0 && !lines.at(-1)?.length) lines.pop();
+      code = lines.join("\n");
+    }
+    const Klass = findCodeBlockKlass(getResolvedEditNodes());
+    const node = new Klass(code, lang);
+    if (isImport || $isRootNode(rootNode)) {
+      rootNode.append(node);
+    } else {
+      rootNode.replace(node);
+    }
+    const selection = $createNodeSelection();
+    selection.add(node.getKey());
+    $setSelection(selection);
+  },
+  type: "multiline-element"
+};
+const NEVER = /a^/;
+const COMMENT_OPEN_TRANSFORMER = {
+  dependencies: [CommentNode],
+  export: () => null,
+  importRegExp: NEVER,
+  regExp: /<!--$/,
+  replace: (textNode) => {
+    const node = $createCommentPlaceholderNode();
+    textNode.replace(node);
+    node.select(0, node.getTextContentSize());
+  },
+  trigger: "-",
+  type: "text-match"
+};
+const COMMENT_TRANSFORMER = {
+  ...COMMENT_TRANSFORMER$1,
+  dependencies: [CommentNode],
+  replace: (textNode, match) => {
+    textNode.replace($createCommentNode(match[1] ?? ""));
+  }
+};
+const BANNER_TYPE_MAP = {
+  note: "note",
+  info: "note",
+  tip: "tip",
+  success: "tip",
+  important: "important",
+  warning: "warning",
+  warn: "warning",
+  error: "caution",
+  danger: "caution",
+  caution: "caution"
+};
+const CONTAINER_TRANSFORMER = {
+  ...CONTAINER_TRANSFORMER$1,
+  dependencies: [BannerNode, DetailsNode],
+  regExp: /^:::\s*(\w+)(?:\{([^}]*)\})?\s*$/,
+  replace: (parentNode, children, match) => {
+    const type = match[1];
+    const params = match[2];
+    if (type in BANNER_TYPE_MAP) {
+      const bannerType = BANNER_TYPE_MAP[type];
+      const serializedChildren = children.map(
+        (child) => child.exportJSON()
+      );
+      const content = {
+        root: {
+          children: [
+            {
+              type: "paragraph",
+              children: serializedChildren,
+              direction: null,
+              format: "",
+              indent: 0,
+              textFormat: 0,
+              textStyle: "",
+              version: 1
+            }
+          ],
+          direction: null,
+          format: "",
+          indent: 0,
+          type: "root",
+          version: 1
+        }
+      };
+      const banner = $createBannerEditNode(bannerType, content);
+      parentNode.replace(banner);
+      return;
+    }
+    if (type === "details") {
+      const summaryMatch = params?.match(/summary="([^"]*)"/);
+      const summary = summaryMatch ? summaryMatch[1] : "Details";
+      const details = $createDetailsNode(summary);
+      children.forEach((child) => {
+        details.append(child);
+      });
+      parentNode.replace(details);
+      return;
+    }
+    const paragraph = $createParagraphNode();
+    paragraph.append($createTextNode(`::: ${type}`));
+    children.forEach((child) => {
+      paragraph.append(child);
+    });
+    parentNode.replace(paragraph);
+  }
+};
+const FOOTNOTE_TRANSFORMER = {
+  ...FOOTNOTE_TRANSFORMER$1,
+  dependencies: [FootnoteNode],
+  replace: (textNode, match) => {
+    const footnoteNode = $createFootnoteNode(match[1]);
+    textNode.replace(footnoteNode);
+  }
+};
+const FOOTNOTE_SECTION_TRANSFORMER = {
+  ...FOOTNOTE_SECTION_TRANSFORMER$1,
+  dependencies: [FootnoteSectionNode],
+  regExp: /^\[\^(\w+)\]:[\t ]+(\S.*)$/,
+  replace: (parentNode, _children, match) => {
+    const identifier = match[1];
+    const content = match[2];
+    const root = parentNode.getParent();
+    if (root) {
+      const children = root.getChildren();
+      for (const child of children) {
+        if ($isFootnoteSectionNode(child)) {
+          child.setDefinition(identifier, content);
+          parentNode.remove();
+          return;
+        }
+      }
+    }
+    const sectionNode = $createFootnoteSectionNode({ [identifier]: content });
+    parentNode.replace(sectionNode);
+  }
+};
+const KATEX_INLINE_TRANSFORMER = {
+  ...KATEX_INLINE_TRANSFORMER$1,
+  dependencies: [KaTeXInlineNode],
+  replace: (textNode, match) => {
+    const katexNode = $createKaTeXInlineNode(match[1]);
+    textNode.replace(katexNode);
+  }
+};
+const KATEX_BLOCK_TRANSFORMER = {
+  ...KATEX_BLOCK_TRANSFORMER$1,
+  dependencies: [KaTeXBlockNode],
+  replace: (textNode, match) => {
+    const katexNode = $createKaTeXBlockNode(match[1]);
+    textNode.replace(katexNode);
+  }
+};
+const MENTION_TRANSFORMER = {
+  ...MENTION_TRANSFORMER$1,
+  dependencies: [MentionNode],
+  replace: (textNode, match) => {
+    const displayName = match[1] || void 0;
+    const mentionNode = $createMentionNode(match[2], match[3], displayName);
+    textNode.replace(mentionNode);
+  }
+};
+const QUOTE_TRANSFORMER = {
+  dependencies: [QuoteNode],
+  export: (node, exportChildren) => {
+    if (!$isQuoteNode(node)) {
+      return null;
+    }
+    const lines = exportChildren(node).split("\n");
+    return lines.map((line) => `> ${line}`).join("\n");
+  },
+  regExp: /^>\s/,
+  replace: (parentNode, children, _match, isImport) => {
+    if (isImport) {
+      const previousNode = parentNode.getPreviousSibling();
+      if ($isQuoteNode(previousNode)) {
+        previousNode.splice(previousNode.getChildrenSize(), 0, [
+          $createLineBreakNode(),
+          ...children
+        ]);
+        parentNode.remove();
+        return;
+      }
+    }
+    const node = $createQuoteNode();
+    const paragraph = $createParagraphNode();
+    paragraph.append(...children);
+    node.append(paragraph);
+    parentNode.replace(node);
+    if (!isImport) {
+      paragraph.select(0, 0);
+    }
+  },
+  type: "element"
+};
+function quoteAttr(value) {
+  return value.replaceAll('"', '\\"');
+}
+const GRID_CONTAINER_BLOCK_TRANSFORMER = {
+  dependencies: [],
+  export: (node) => {
+    if (!$isGridContainerNode(node)) return null;
+    const cells = node.getCellStates().map((state) => extractTextContent(state));
+    const body = cells.map((content) => `::: cell
+${content}
+:::`).join("\n");
+    return `::: grid{cols=${node.getCols()} gap="${quoteAttr(node.getGap())}"}
+${body}
+:::`;
+  },
+  regExp: /\b\B/,
+  replace: () => {
+  },
+  type: "element"
+};
+const RUBY_TRANSFORMER = {
+  ...RUBY_TRANSFORMER$1,
+  dependencies: [RubyNode],
+  replace: (textNode, match) => {
+    const rubyNode = $createRubyNode(match[2] ?? "");
+    const baseText = match[1] ?? "";
+    if (baseText) {
+      rubyNode.append($createTextNode(baseText));
+    }
+    textNode.replace(rubyNode);
+  }
+};
+const SPOILER_TRANSFORMER = {
+  ...SPOILER_TRANSFORMER$1,
+  dependencies: [SpoilerNode],
+  replace: (textNode, match) => {
+    const spoilerNode = $createSpoilerNode();
+    spoilerNode.append($createTextNode(match[1]));
+    textNode.replace(spoilerNode);
+  }
+};
+const TABLE_ROW_REG_EXP = /^\|(.+)\|\s*$/;
+const TABLE_DIVIDER_REG_EXP = /^\|(?:\s*:?-+:?\s*\|)+\s*$/;
+function parseCells(row) {
+  const match = row.match(TABLE_ROW_REG_EXP);
+  if (!match) return [];
+  return match[1].split("|").map((c) => c.trim());
+}
+const TABLE_IMPORT_TRANSFORMER = {
+  dependencies: [],
+  export: () => null,
+  handleImportAfterStartMatch({ lines, rootNode, startLineIndex }) {
+    if (startLineIndex + 1 >= lines.length) return null;
+    const dividerLine = lines[startLineIndex + 1];
+    if (!TABLE_DIVIDER_REG_EXP.test(dividerLine)) return null;
+    const headerCells = parseCells(lines[startLineIndex]);
+    if (headerCells.length === 0) return null;
+    let endLineIndex = startLineIndex + 1;
+    const dataRows = [];
+    for (let i = startLineIndex + 2; i < lines.length; i++) {
+      if (!TABLE_ROW_REG_EXP.test(lines[i])) break;
+      dataRows.push(parseCells(lines[i]));
+      endLineIndex = i;
+    }
+    const tableNode = $createTableNode();
+    const headerRow = $createTableRowNode();
+    for (const cell of headerCells) {
+      const cellNode = $createTableCellNode(TableCellHeaderStates.ROW);
+      const p = $createParagraphNode();
+      p.append($createTextNode(cell));
+      cellNode.append(p);
+      headerRow.append(cellNode);
+    }
+    tableNode.append(headerRow);
+    for (const row of dataRows) {
+      const rowNode = $createTableRowNode();
+      for (let i = 0; i < headerCells.length; i++) {
+        const cellNode = $createTableCellNode(TableCellHeaderStates.NO_STATUS);
+        const p = $createParagraphNode();
+        p.append($createTextNode(row[i] ?? ""));
+        cellNode.append(p);
+        rowNode.append(cellNode);
+      }
+      tableNode.append(rowNode);
+    }
+    rootNode.append(tableNode);
+    return [true, endLineIndex];
+  },
+  regExpEnd: {
+    optional: true,
+    regExp: TABLE_ROW_REG_EXP
+  },
+  regExpStart: TABLE_ROW_REG_EXP,
+  replace: () => {
+  },
+  type: "multiline-element"
+};
+const ALL_TRANSFORMERS = [
+  // Inline transformers
+  SPOILER_TRANSFORMER,
+  MENTION_TRANSFORMER,
+  FOOTNOTE_TRANSFORMER,
+  INSERT_TRANSFORMER,
+  SUPERSCRIPT_TRANSFORMER,
+  SUBSCRIPT_TRANSFORMER,
+  RUBY_TRANSFORMER,
+  COMMENT_OPEN_TRANSFORMER,
+  COMMENT_TRANSFORMER,
+  KATEX_INLINE_TRANSFORMER,
+  // Block transformers (order matters - more specific first)
+  FOOTNOTE_SECTION_TRANSFORMER,
+  CONTAINER_TRANSFORMER,
+  GIT_ALERT_TRANSFORMER,
+  CHECK_LIST,
+  KATEX_BLOCK_TRANSFORMER,
+  IMAGE_BLOCK_TRANSFORMER,
+  VIDEO_BLOCK_TRANSFORMER,
+  CODE_BLOCK_NODE_TRANSFORMER,
+  CODE_BLOCK_MULTILINE_TRANSFORMER,
+  LINK_CARD_BLOCK_TRANSFORMER,
+  MERMAID_BLOCK_TRANSFORMER,
+  GRID_CONTAINER_BLOCK_TRANSFORMER,
+  HORIZONTAL_RULE_BLOCK_TRANSFORMER,
+  TABLE_IMPORT_TRANSFORMER,
+  TABLE_BLOCK_TRANSFORMER,
+  QUOTE_TRANSFORMER,
+  ...TRANSFORMERS.filter((t) => t !== QUOTE && t !== CODE)
+];
+function getVSCodePasteData(clipboardData) {
+  const raw = clipboardData.getData("vscode-editor-data");
+  if (!raw) return null;
+  try {
+    const data = JSON.parse(raw);
+    return { language: data.mode || "text" };
+  } catch {
+    return null;
+  }
+}
+function hasRichHTML(clipboardData) {
+  const html = clipboardData.getData("text/html");
+  if (!html) return false;
+  if (/data-vscode|vscode-/i.test(html)) return false;
+  const doc = new DOMParser().parseFromString(html, "text/html");
+  const richTags = doc.body.querySelectorAll(
+    "strong,em,b,i,h1,h2,h3,h4,h5,h6,ul,ol,table,img,blockquote,pre>code,a[href]"
+  );
+  return richTags.length > 0;
+}
+function detectMarkdown(text) {
+  let score = 0;
+  if (/^#{1,6}\s+\S/m.test(text)) score += 5;
+  if (/^```[\w-]*$/m.test(text)) score += 5;
+  if (/\[[^\]]+\]\([^)]+\)/.test(text)) score += 4;
+  if (/!\[[^\]]*\]\([^)]+\)/.test(text)) score += 5;
+  if (/^\|.+\|$/m.test(text) && /^\|[\s:|-]+\|$/m.test(text)) score += 5;
+  if (/^>\s*\[!(?:note|tip|warning|caution|important)\]/im.test(text)) score += 5;
+  if (/^[*-]\s+\[[ x]\]/m.test(text)) score += 4;
+  if (/\*\*.+?\*\*/.test(text)) score += 2;
+  if (/(?<!\*)\*(?!\*)(?!\s).+?(?<!\s)(?<!\*)\*(?!\*)/.test(text)) score += 1;
+  if (/^[*+-]\s+\S/m.test(text)) score += 1;
+  if (/^\d+\.\s+\S/m.test(text)) score += 1;
+  if (/^>\s+\S/m.test(text)) score += 1;
+  if (/`.+?`/.test(text)) score += 1;
+  if (/^[*_-]{3,}$/m.test(text)) score += 2;
+  const paragraphs = text.split(/\n{2,}/).filter(Boolean);
+  if (paragraphs.length >= 2) score += 5;
+  if (text.length < 20) score -= 3;
+  if (!text.includes("\n")) score -= 2;
+  return score >= 5;
+}
+function convertAndInsert(markdown) {
+  let conversionError = null;
+  const tempEditor = createEditor({
+    namespace: "markdown-paste-temp",
+    nodes: getResolvedEditNodes(),
+    onError: (error) => {
+      conversionError = error;
+    }
+  });
+  tempEditor.update(
+    () => {
+      $convertFromMarkdownString(markdown, ALL_TRANSFORMERS);
+    },
+    { discrete: true }
+  );
+  if (conversionError) {
+    console.error("MarkdownPastePlugin: convertAndInsert error", conversionError);
+    return false;
+  }
+  const serializedChildren = tempEditor.getEditorState().toJSON().root.children;
+  if (!serializedChildren.length) return false;
+  const nodes = serializedChildren.map((s) => $parseSerializedNode(s));
+  $insertNodes(nodes);
+  return true;
+}
+function MarkdownPastePlugin() {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    return editor.registerCommand(
+      PASTE_COMMAND,
+      (event) => {
+        const clipboardData = "clipboardData" in event ? event.clipboardData : null;
+        if (!clipboardData) return false;
+        if (Array.from(clipboardData.files).some((f) => f.type.startsWith("image/"))) return false;
+        const vscodeData = getVSCodePasteData(clipboardData);
+        if (vscodeData) {
+          const code = clipboardData.getData("text/plain");
+          if (code) {
+            const segments = code.split(/\r?\n{3,}/).filter(Boolean);
+            const nodes = segments.map(
+              (s) => $createCodeBlockEditNode(
+                s.replace(/^\s*\n/, "").replace(/\n\s*$/, ""),
+                vscodeData.language
+              )
+            );
+            $insertNodes(nodes);
+            event.preventDefault();
+            return true;
+          }
+        }
+        if (hasRichHTML(clipboardData)) return false;
+        const text = clipboardData.getData("text/plain");
+        if (!text || !detectMarkdown(text)) return false;
+        try {
+          if (!convertAndInsert(text)) {
+            return false;
+          }
+          event.preventDefault();
+          return true;
+        } catch (error) {
+          console.error("MarkdownPastePlugin: paste error", error);
+          return false;
+        }
+      },
+      COMMAND_PRIORITY_HIGH
+    );
+  }, [editor]);
+  return null;
+}
+function MarkdownShortcutsPlugin() {
+  return /* @__PURE__ */ jsx(MarkdownShortcutPlugin, { transformers: ALL_TRANSFORMERS });
+}
+function CorePlugins() {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(ListPlugin, {}),
+    /* @__PURE__ */ jsx(LinkPlugin, {}),
+    /* @__PURE__ */ jsx(TabIndentationPlugin, {}),
+    /* @__PURE__ */ jsx(TablePlugin, {}),
+    /* @__PURE__ */ jsx(CheckListPlugin, {}),
+    /* @__PURE__ */ jsx(MarkdownShortcutsPlugin, {}),
+    /* @__PURE__ */ jsx(MarkdownPastePlugin, {}),
+    /* @__PURE__ */ jsx(BlockExitPlugin, {}),
+    /* @__PURE__ */ jsx(HorizontalRulePlugin, {}),
+    /* @__PURE__ */ jsx(AutoLinkPlugin, {})
+  ] });
+}
+const ImageUploadContext = createContext(null);
+function ImageUploadProvider({
+  upload,
+  children
+}) {
+  return /* @__PURE__ */ jsx(ImageUploadContext.Provider, { value: upload, children });
+}
+function useImageUpload() {
+  return use(ImageUploadContext);
+}
+const blockIdState = createState("blockId", {
+  parse: (v) => typeof v === "string" ? v : ""
+});
+const NORMALIZATION_TAG = "block-id-normalization";
+function buildPreviousIdIndex(editorState) {
+  return editorState.read(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const child of $getRoot().getChildren()) {
+      const id = $getState(child, blockIdState);
+      if (!id) continue;
+      const set = map.get(id) ?? /* @__PURE__ */ new Set();
+      set.add(child.getKey());
+      map.set(id, set);
+    }
+    return map;
+  });
+}
+function collectRootChildren(editorState) {
+  return editorState.read(
+    () => $getRoot().getChildren().map((child) => $getState(child, blockIdState))
+  );
+}
+function hasDuplicateOrMissingId(children) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of children) {
+    if (!id || seen.has(id)) {
+      return true;
+    }
+    seen.add(id);
+  }
+  return false;
+}
+function generateBlockId(used) {
+  while (true) {
+    const id = nanoid(8);
+    if (!used.has(id)) {
+      return id;
+    }
+  }
+}
+function pickKeeperKey(nodes, previousKeys) {
+  if (!nodes.length) return null;
+  if (previousKeys?.size) {
+    for (const node of nodes) {
+      if (previousKeys.has(node.getKey())) {
+        return node.getKey();
+      }
+    }
+  }
+  return nodes[0]?.getKey() ?? null;
+}
+function normalizeRootBlockIds(editor, previousIdIndex) {
+  editor.update(
+    () => {
+      $addUpdateTag("history-merge");
+      const children = $getRoot().getChildren();
+      const groupedById = /* @__PURE__ */ new Map();
+      for (const child of children) {
+        const id = $getState(child, blockIdState);
+        if (!id) continue;
+        const bucket = groupedById.get(id) ?? [];
+        bucket.push(child);
+        groupedById.set(id, bucket);
+      }
+      const keeperById = /* @__PURE__ */ new Map();
+      for (const [id, nodes] of groupedById) {
+        if (nodes.length <= 1) continue;
+        const keeperKey = pickKeeperKey(nodes, previousIdIndex.get(id));
+        if (keeperKey) {
+          keeperById.set(id, keeperKey);
+        }
+      }
+      const used = /* @__PURE__ */ new Set();
+      for (const child of children) {
+        let id = $getState(child, blockIdState);
+        const keeperKey = id ? keeperById.get(id) : null;
+        const shouldRegenerate = !id || used.has(id) || keeperKey !== void 0 && child.getKey() !== keeperKey;
+        if (shouldRegenerate) {
+          id = generateBlockId(used);
+          $setState(child, blockIdState, id);
+        }
+        used.add(id);
+      }
+    },
+    { tag: NORMALIZATION_TAG }
+  );
+}
+function BlockIdPlugin() {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    const initialChildren = collectRootChildren(editor.getEditorState());
+    if (hasDuplicateOrMissingId(initialChildren)) {
+      normalizeRootBlockIds(editor, /* @__PURE__ */ new Map());
+    }
+    return editor.registerUpdateListener(({ tags, editorState, prevEditorState }) => {
+      if (tags.has(NORMALIZATION_TAG)) return;
+      const children = collectRootChildren(editorState);
+      if (!hasDuplicateOrMissingId(children)) return;
+      const previousIdIndex = buildPreviousIdIndex(prevEditorState);
+      normalizeRootBlockIds(editor, previousIdIndex);
+    });
+  }, [editor]);
+  return null;
+}
+var draggingWrapperClass = "rich-image-upload-dragging";
+var toastStack = "_1x58dbf1";
+var toast = "_1x58dbf2";
+var toastVariant = { info: "_1x58dbf3", success: "_1x58dbf4", error: "_1x58dbf5" };
+var spinner = "_1x58dbf7";
+var dialogPopup = "_1x58dbf8";
+var dialogHeader = "_1x58dbf9";
+var dialogTitle = "_1x58dbfa";
+var dialogBody = "_1x58dbfb";
+var tabWrap = "_1x58dbfc";
+var uploadDropzone = "_1x58dbfd";
+var uploadDropzoneState = { idle: "_1x58dbfe", active: "_1x58dbff", busy: "_1x58dbfg" };
+var uploadDropIcon = "_1x58dbfh";
+var uploadDropTitle = "_1x58dbfi";
+var uploadDropDesc = "_1x58dbfj";
+var hiddenInput = "_1x58dbfk";
+var uploadBusyWrap = "_1x58dbfl";
+var uploadProgress = "_1x58dbfm";
+var urlInputRow = "_1x58dbfn";
+var textInput = "_1x58dbfo";
+var urlPreview = "_1x58dbfp";
+var urlPreviewImage = "_1x58dbfq";
+var helperText = "_1x58dbfr";
+var dialogFooter = "_1x58dbfs";
+function isImageFile(file) {
+  return file.type.startsWith("image/");
+}
+function hasImageData(dataTransfer) {
+  if (!dataTransfer) return false;
+  if ([...dataTransfer.files].some(isImageFile)) return true;
+  return [...dataTransfer.items].some((item) => item.type.startsWith("image/"));
+}
+const UNSAFE_URL_RE = /^(?:javascript\s*:|vbscript\s*:|data\s*:(?!image\/))/i;
+function isSafeImageUrl(url) {
+  return !UNSAFE_URL_RE.test(url);
+}
+function loadImageByUrl(src) {
+  return new Promise((resolve, reject) => {
+    const image = new Image();
+    image.onload = () => {
+      resolve({
+        width: image.naturalWidth || image.width,
+        height: image.naturalHeight || image.height
+      });
+    };
+    image.onerror = () => reject(new Error("Failed to load image"));
+    image.src = src;
+  });
+}
+function readAsDataUrl(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(String(reader.result));
+    reader.onerror = () => reject(reader.error ?? new Error("File read failed"));
+    reader.readAsDataURL(file);
+  });
+}
+async function defaultImageUpload(file) {
+  return {
+    src: await readAsDataUrl(file),
+    altText: file.name
+  };
+}
+function ImageUploadPlugin({ onUpload }) {
+  const [editor] = useLexicalComposerContext();
+  const uploadRef = useRef(onUpload);
+  uploadRef.current = onUpload;
+  const fileInputRef = useRef(null);
+  const toastTimerRef = useRef(null);
+  const [dialogOpen, setDialogOpen] = useState(false);
+  const [tab, setTab] = useState("upload");
+  const [rootDragActive, setRootDragActive] = useState(false);
+  const [dialogDragActive, setDialogDragActive] = useState(false);
+  const [pendingUploads, setPendingUploads] = useState(0);
+  const [dialogUploading, setDialogUploading] = useState(false);
+  const [toast$1, setToast] = useState(null);
+  const [urlInput, setUrlInput] = useState("");
+  const [urlPreview$1, setUrlPreview] = useState(null);
+  const [urlMeta, setUrlMeta] = useState(null);
+  const [urlLoading, setUrlLoading] = useState(false);
+  const [urlError, setUrlError] = useState(null);
+  const tabItems = useMemo(
+    () => [
+      { value: "upload", label: "Upload" },
+      { value: "url", label: "URL" }
+    ],
+    []
+  );
+  const pushToast = useCallback((kind, message) => {
+    setToast({ kind, message });
+    if (toastTimerRef.current) {
+      window.clearTimeout(toastTimerRef.current);
+    }
+    toastTimerRef.current = window.setTimeout(setToast, 2200, null);
+  }, []);
+  const insertByUpload = useCallback(
+    async (file, options) => {
+      if (!isImageFile(file)) return false;
+      const closeDialog = Boolean(options?.closeDialog);
+      setPendingUploads((value) => value + 1);
+      if (closeDialog) setDialogUploading(true);
+      try {
+        const [result, meta] = await Promise.all([uploadRef.current(file), computeImageMeta(file)]);
+        editor.update(() => {
+          const node = $createImageNode({
+            src: result.src,
+            altText: result.altText ?? file.name,
+            width: result.width ?? meta.width,
+            height: result.height ?? meta.height,
+            thumbhash: result.thumbhash ?? meta.thumbhash
+          });
+          $insertNodes([node]);
+        });
+        if (closeDialog) {
+          setDialogOpen(false);
+          setUrlInput("");
+          setUrlPreview(null);
+          setUrlMeta(null);
+          setUrlError(null);
+        }
+        pushToast("success", "Image uploaded");
+        return true;
+      } catch (err) {
+        console.error("[ImageUploadPlugin]", err);
+        pushToast("error", "Image upload failed");
+        return false;
+      } finally {
+        setPendingUploads((value) => Math.max(value - 1, 0));
+        setDialogUploading(false);
+      }
+    },
+    [editor, pushToast]
+  );
+  const handleFiles = useCallback(
+    (files) => {
+      const images = files.filter(isImageFile);
+      if (images.length === 0) return false;
+      for (const file of images) {
+        void insertByUpload(file);
+      }
+      return true;
+    },
+    [insertByUpload]
+  );
+  useEffect(() => {
+    const unregisterDragDrop = editor.registerCommand(
+      DRAG_DROP_PASTE,
+      (files) => handleFiles(files),
+      COMMAND_PRIORITY_HIGH
+    );
+    const unregisterPaste = editor.registerCommand(
+      PASTE_COMMAND,
+      (event) => {
+        const clipboardData = "clipboardData" in event ? event.clipboardData : null;
+        if (!clipboardData) return false;
+        const files = [...clipboardData.files];
+        if (files.some(isImageFile)) {
+          return handleFiles(files);
+        }
+        return false;
+      },
+      COMMAND_PRIORITY_HIGH
+    );
+    const unregisterOpenDialog = editor.registerCommand(
+      OPEN_IMAGE_UPLOAD_DIALOG_COMMAND,
+      () => {
+        setDialogOpen(true);
+        return true;
+      },
+      COMMAND_PRIORITY_EDITOR
+    );
+    const rootElement = editor.getRootElement();
+    const wrapper = rootElement?.parentElement ?? null;
+    if (!wrapper) {
+      return () => {
+        unregisterDragDrop();
+        unregisterPaste();
+        unregisterOpenDialog();
+      };
+    }
+    let dragCounter = 0;
+    const setWrapperDragging = (next) => {
+      setRootDragActive(next);
+      wrapper.classList.toggle(draggingWrapperClass, next);
+    };
+    const onDragEnter = (event) => {
+      if (!hasImageData(event.dataTransfer)) return;
+      dragCounter += 1;
+      setWrapperDragging(true);
+    };
+    const onDragOver = (event) => {
+      if (!hasImageData(event.dataTransfer)) return;
+      event.preventDefault();
+    };
+    const onDragLeave = () => {
+      dragCounter = Math.max(dragCounter - 1, 0);
+      if (dragCounter === 0) {
+        setWrapperDragging(false);
+      }
+    };
+    const onDrop = () => {
+      dragCounter = 0;
+      setWrapperDragging(false);
+    };
+    rootElement?.addEventListener("dragenter", onDragEnter);
+    rootElement?.addEventListener("dragover", onDragOver);
+    rootElement?.addEventListener("dragleave", onDragLeave);
+    rootElement?.addEventListener("drop", onDrop);
+    return () => {
+      if (toastTimerRef.current) {
+        window.clearTimeout(toastTimerRef.current);
+      }
+      unregisterDragDrop();
+      unregisterPaste();
+      unregisterOpenDialog();
+      setWrapperDragging(false);
+      rootElement?.removeEventListener("dragenter", onDragEnter);
+      rootElement?.removeEventListener("dragover", onDragOver);
+      rootElement?.removeEventListener("dragleave", onDragLeave);
+      rootElement?.removeEventListener("drop", onDrop);
+    };
+  }, [editor, handleFiles]);
+  const resetUrlState = useCallback(() => {
+    setUrlInput("");
+    setUrlPreview(null);
+    setUrlMeta(null);
+    setUrlError(null);
+    setUrlLoading(false);
+  }, []);
+  const handleDialogFile = useCallback(
+    async (file) => {
+      if (!file) return;
+      await insertByUpload(file, { closeDialog: true });
+    },
+    [insertByUpload]
+  );
+  const handleUrlPreview = useCallback(async () => {
+    const nextUrl = urlInput.trim();
+    if (!nextUrl) return;
+    if (!isSafeImageUrl(nextUrl)) {
+      setUrlError("Unsupported URL scheme");
+      return;
+    }
+    setUrlLoading(true);
+    setUrlError(null);
+    try {
+      const meta = await loadImageByUrl(nextUrl);
+      setUrlMeta(meta);
+      setUrlPreview(nextUrl);
+    } catch {
+      setUrlPreview(null);
+      setUrlMeta(null);
+      setUrlError("Could not load this image URL");
+    } finally {
+      setUrlLoading(false);
+    }
+  }, [urlInput]);
+  const handleInsertByUrl = useCallback(() => {
+    if (!urlPreview$1 || !isSafeImageUrl(urlPreview$1)) return;
+    editor.update(() => {
+      const node = $createImageNode({
+        src: urlPreview$1,
+        altText: "",
+        width: urlMeta?.width,
+        height: urlMeta?.height
+      });
+      $insertNodes([node]);
+    });
+    pushToast("success", "Image inserted");
+    setDialogOpen(false);
+    resetUrlState();
+  }, [editor, pushToast, resetUrlState, urlMeta, urlPreview$1]);
+  const helperMessage = pendingUploads > 0 ? `Uploading ${pendingUploads} image${pendingUploads > 1 ? "s" : ""}...` : rootDragActive ? "Drop image files to upload" : null;
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    (helperMessage || toast$1) && /* @__PURE__ */ jsxs("div", { className: toastStack, children: [
+      helperMessage && /* @__PURE__ */ jsxs("div", { className: `${toast} ${toastVariant.info}`, children: [
+        /* @__PURE__ */ jsx("span", { className: spinner }),
+        helperMessage
+      ] }),
+      toast$1 && /* @__PURE__ */ jsxs("div", { className: `${toast} ${toastVariant[toast$1.kind]}`, children: [
+        toast$1.kind === "success" ? /* @__PURE__ */ jsx(Check, { size: 12 }) : /* @__PURE__ */ jsx(Info, { size: 12 }),
+        toast$1.message
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx(
+      Dialog,
+      {
+        open: dialogOpen,
+        onOpenChange: (nextOpen) => {
+          if (!nextOpen && dialogUploading) return;
+          setDialogOpen(nextOpen);
+          if (!nextOpen) {
+            resetUrlState();
+            setDialogUploading(false);
+            setDialogDragActive(false);
+          }
+        },
+        children: /* @__PURE__ */ jsxs(DialogPopup, { className: dialogPopup, showCloseButton: !dialogUploading, children: [
+          /* @__PURE__ */ jsx("div", { className: dialogHeader, children: /* @__PURE__ */ jsx(DialogTitle, { className: dialogTitle, children: "Insert image" }) }),
+          /* @__PURE__ */ jsxs("div", { className: dialogBody, children: [
+            /* @__PURE__ */ jsx("div", { className: tabWrap, children: /* @__PURE__ */ jsx(SegmentedControl, { fullWidth: true, items: tabItems, value: tab, onChange: setTab }) }),
+            tab === "upload" ? /* @__PURE__ */ jsxs(
+              "div",
+              {
+                className: `${uploadDropzone} ${uploadDropzoneState[dialogUploading ? "busy" : dialogDragActive ? "active" : "idle"]}`,
+                role: "button",
+                tabIndex: 0,
+                onDragLeave: () => setDialogDragActive(false),
+                onClick: () => {
+                  if (!dialogUploading) fileInputRef.current?.click();
+                },
+                onDragEnter: (event) => {
+                  if (hasImageData(event.dataTransfer)) {
+                    event.preventDefault();
+                    setDialogDragActive(true);
+                  }
+                },
+                onDragOver: (event) => {
+                  if (hasImageData(event.dataTransfer)) {
+                    event.preventDefault();
+                  }
+                },
+                onDrop: (event) => {
+                  event.preventDefault();
+                  setDialogDragActive(false);
+                  const file = [...event.dataTransfer.files].find(isImageFile);
+                  void handleDialogFile(file ?? null);
+                },
+                onKeyDown: (event) => {
+                  if (event.key !== "Enter" && event.key !== " ") return;
+                  event.preventDefault();
+                  if (!dialogUploading) fileInputRef.current?.click();
+                },
+                children: [
+                  /* @__PURE__ */ jsx(
+                    "input",
+                    {
+                      accept: "image/*",
+                      className: hiddenInput,
+                      ref: fileInputRef,
+                      type: "file",
+                      onChange: (event) => {
+                        const file = event.currentTarget.files?.[0] ?? null;
+                        void handleDialogFile(file);
+                        event.currentTarget.value = "";
+                      }
+                    }
+                  ),
+                  dialogUploading ? /* @__PURE__ */ jsx("div", { className: uploadBusyWrap, children: /* @__PURE__ */ jsxs("div", { className: uploadProgress, children: [
+                    /* @__PURE__ */ jsx("span", { className: spinner }),
+                    "Uploading image..."
+                  ] }) }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+                    /* @__PURE__ */ jsx("span", { className: uploadDropIcon, children: /* @__PURE__ */ jsx(Upload, { size: 18 }) }),
+                    /* @__PURE__ */ jsx("span", { className: uploadDropTitle, children: "Click to upload or drag and drop" }),
+                    /* @__PURE__ */ jsx("span", { className: uploadDropDesc, children: "PNG, JPG, GIF, WebP" })
+                  ] })
+                ]
+              }
+            ) : /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsxs("div", { className: urlInputRow, children: [
+                /* @__PURE__ */ jsx(
+                  "input",
+                  {
+                    className: textInput,
+                    placeholder: "https://example.com/image.jpg",
+                    type: "url",
+                    value: urlInput,
+                    onChange: (event) => {
+                      setUrlInput(event.target.value);
+                      setUrlError(null);
+                      setUrlPreview(null);
+                      setUrlMeta(null);
+                    },
+                    onKeyDown: (event) => {
+                      if (event.key === "Enter") {
+                        event.preventDefault();
+                        if (urlPreview$1) {
+                          handleInsertByUrl();
+                        } else {
+                          void handleUrlPreview();
+                        }
+                      }
+                    }
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  ActionButton,
+                  {
+                    disabled: urlLoading || !urlInput.trim(),
+                    size: "md",
+                    variant: "outline",
+                    onClick: () => void handleUrlPreview(),
+                    children: urlLoading ? "Loading" : "Preview"
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  ActionButton,
+                  {
+                    disabled: !urlPreview$1,
+                    size: "md",
+                    variant: "accent",
+                    onClick: handleInsertByUrl,
+                    children: "Insert"
+                  }
+                )
+              ] }),
+              urlError && /* @__PURE__ */ jsxs("span", { className: `${helperText} ${toastVariant.error}`, children: [
+                /* @__PURE__ */ jsx(Info, { size: 12 }),
+                urlError
+              ] }),
+              urlPreview$1 && /* @__PURE__ */ jsx("div", { className: urlPreview, children: /* @__PURE__ */ jsx("img", { alt: "Preview", className: urlPreviewImage, src: urlPreview$1 }) })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs("div", { className: dialogFooter, children: [
+            /* @__PURE__ */ jsxs("span", { className: helperText, children: [
+              /* @__PURE__ */ jsx(Link2, { size: 12 }),
+              "You can also paste images or drag files directly into the editor."
+            ] }),
+            /* @__PURE__ */ jsx(ActionBar, { children: /* @__PURE__ */ jsx(
+              ActionButton,
+              {
+                disabled: dialogUploading,
+                size: "md",
+                variant: "outline",
+                onClick: () => setDialogOpen(false),
+                children: "Close"
+              }
+            ) })
+          ] })
+        ] })
+      }
+    )
+  ] });
+}
+function applyFavicon(dom, href) {
+  if (dom.dataset.faviconHref === href) return;
+  dom.dataset.faviconHref = href;
+  const hostname = getHostname(href);
+  if (!hostname) return;
+  probeFavicon(hostname).then((faviconUrl) => {
+    if (faviconUrl) {
+      dom.style.setProperty("--rc-link-favicon", `url(${faviconUrl})`);
+      dom.dataset.favicon = "loaded";
+    }
+  });
+}
+function LinkFaviconPlugin() {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    const handleMutations = (mutations) => {
+      for (const [nodeKey, mutation] of mutations) {
+        if (mutation === "destroyed") continue;
+        const dom = editor.getElementByKey(nodeKey);
+        if (!dom) continue;
+        const href = dom.getAttribute("href");
+        if (href) applyFavicon(dom, href);
+      }
+    };
+    const unregisterLink = editor.registerMutationListener(
+      LinkNode,
+      handleMutations
+    );
+    const unregisterAutoLink = editor.registerMutationListener(
+      AutoLinkNode,
+      handleMutations
+    );
+    return () => {
+      unregisterLink();
+      unregisterAutoLink();
+    };
+  }, [editor]);
+  return null;
+}
+function AutoFocusPlugin() {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    const root = editor.getRootElement();
+    if (root) {
+      root.focus({ preventScroll: true });
+    } else {
+      editor.focus();
+    }
+  }, [editor]);
+  return null;
+}
+function EditorRefPlugin({ onEditorReady }) {
+  const [editor] = useLexicalComposerContext();
+  const callbackRef = useRef(onEditorReady);
+  callbackRef.current = onEditorReady;
+  useEffect(() => {
+    callbackRef.current?.(editor);
+    return () => callbackRef.current?.(null);
+  }, [editor]);
+  return null;
+}
+function FootnotePlugin({ children }) {
+  const [editor] = useLexicalComposerContext();
+  const [definitions, setDefinitions] = useState({});
+  const [displayNumberMap, setDisplayNumberMap] = useState({});
+  const pendingUpdateRef = useRef(false);
+  useEffect(() => {
+    return editor.registerUpdateListener(({ editorState }) => {
+      editorState.read(() => {
+        const footnoteNodes = $nodesOfType(FootnoteNode);
+        const seen = /* @__PURE__ */ new Set();
+        const numberMap = {};
+        let counter = 1;
+        for (const node of footnoteNodes) {
+          const id = node.getIdentifier();
+          if (!seen.has(id)) {
+            seen.add(id);
+            numberMap[id] = counter++;
+          }
+        }
+        setDisplayNumberMap(numberMap);
+        const sectionNodes = $nodesOfType(FootnoteSectionNode);
+        if (sectionNodes.length > 0) {
+          setDefinitions(sectionNodes[0].getDefinitions());
+        } else {
+          setDefinitions({});
+        }
+        if (!editor.isEditable() || pendingUpdateRef.current) return;
+        if (footnoteNodes.length === 0 && sectionNodes.length > 0) {
+          pendingUpdateRef.current = true;
+          queueMicrotask(() => {
+            editor.update(() => {
+              const sections = $nodesOfType(FootnoteSectionNode);
+              for (const s of sections) s.remove();
+            });
+            pendingUpdateRef.current = false;
+          });
+          return;
+        }
+        if (footnoteNodes.length > 0 && sectionNodes.length === 0) {
+          const seenSnapshot = [...seen];
+          pendingUpdateRef.current = true;
+          queueMicrotask(() => {
+            editor.update(() => {
+              const root = $getRoot();
+              const defs = {};
+              for (const id of seenSnapshot) {
+                defs[id] = "";
+              }
+              const section = $parseSerializedNode({
+                type: "footnote-section",
+                definitions: defs,
+                version: 1
+              });
+              root.append(section);
+            });
+            pendingUpdateRef.current = false;
+          });
+        } else if (sectionNodes.length > 0) {
+          const existingDefs = sectionNodes[0].getDefinitions();
+          const missingIds = [...seen].filter((id) => !(id in existingDefs));
+          const orphanIds = Object.keys(existingDefs).filter(
+            (id) => !seen.has(id)
+          );
+          if (missingIds.length > 0 || orphanIds.length > 0) {
+            pendingUpdateRef.current = true;
+            queueMicrotask(() => {
+              editor.update(() => {
+                const freshSections = $nodesOfType(FootnoteSectionNode);
+                if (freshSections.length > 0) {
+                  for (const id of missingIds) {
+                    freshSections[0].setDefinition(id, "");
+                  }
+                  for (const id of orphanIds) {
+                    freshSections[0].removeDefinition(id);
+                  }
+                }
+              });
+              pendingUpdateRef.current = false;
+            });
+          }
+        }
+      });
+    });
+  }, [editor]);
+  return /* @__PURE__ */ jsx(
+    FootnoteDefinitionsProvider,
+    {
+      definitions,
+      displayNumberMap,
+      children
+    }
+  );
+}
+function OnChangePlugin({ onChange, debounceMs }) {
+  const [editor] = useLexicalComposerContext();
+  const timerRef = useRef(void 0);
+  const onChangeRef = useRef(onChange);
+  onChangeRef.current = onChange;
+  useEffect(() => {
+    const unregister = editor.registerUpdateListener(({ editorState }) => {
+      const fn = onChangeRef.current;
+      if (!fn) return;
+      if (debounceMs && debounceMs > 0) {
+        clearTimeout(timerRef.current);
+        timerRef.current = setTimeout(() => {
+          fn(editorState.toJSON());
+        }, debounceMs);
+      } else {
+        fn(editorState.toJSON());
+      }
+    });
+    return () => {
+      clearTimeout(timerRef.current);
+      unregister();
+    };
+  }, [editor, debounceMs]);
+  return null;
+}
+function SubmitShortcutPlugin({ onSubmit }) {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    if (!onSubmit) return;
+    return editor.registerCommand(
+      KEY_ENTER_COMMAND,
+      (event) => {
+        if (event && (event.metaKey || event.ctrlKey)) {
+          event.preventDefault();
+          onSubmit();
+          return true;
+        }
+        return false;
+      },
+      COMMAND_PRIORITY_HIGH
+    );
+  }, [editor, onSubmit]);
+  return null;
+}
+export {
+  ALL_TRANSFORMERS as A,
+  BlockExitPlugin as B,
+  CorePlugins as C,
+  EditorRefPlugin as E,
+  FootnotePlugin as F,
+  HorizontalRulePlugin as H,
+  ImageUploadPlugin as I,
+  LinkFaviconPlugin as L,
+  MarkdownPastePlugin as M,
+  OnChangePlugin as O,
+  SubmitShortcutPlugin as S,
+  AutoFocusPlugin as a,
+  AutoLinkPlugin as b,
+  BlockIdPlugin as c,
+  ImageUploadProvider as d,
+  MarkdownShortcutsPlugin as e,
+  blockIdState as f,
+  defaultImageUpload as g,
+  useImageUpload as u
+};