@haklex/rich-editor 0.0.1

package/dist/utils-CctLX9nj.js

@@ -0,0 +1,2702 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { createContext, useMemo, use, createElement, useCallback, useState, useEffect, useRef } from "react";
+import { CodeNode } from "@lexical/code";
+import { HorizontalRuleNode } from "@lexical/extension";
+import { LinkNode, AutoLinkNode } from "@lexical/link";
+import { ListNode, ListItemNode } from "@lexical/list";
+import { HeadingNode, QuoteNode } from "@lexical/rich-text";
+import { TableNode, TableCellNode, TableRowNode } from "@lexical/table";
+import { DecoratorNode, ElementNode, $insertNodes, $getRoot, createEditor, $getNodeByKey, $nodesOfType } from "lexical";
+import { OctagonAlert, TriangleAlert, MessageSquareWarning, Lightbulb, Info, Flag, Code, ChevronDown, ChevronRight, LayoutGrid, ImageIcon, Sigma, Link, Workflow, Video } from "lucide-react";
+import { ContentEditable } from "@lexical/react/LexicalContentEditable";
+import { LexicalErrorBoundary } from "@lexical/react/LexicalErrorBoundary";
+import { LexicalNestedComposer } from "@lexical/react/LexicalNestedComposer";
+import { RichTextPlugin } from "@lexical/react/LexicalRichTextPlugin";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { TooltipRoot, TooltipTrigger, TooltipContent } from "@haklex/rich-editor-ui";
+const PortalThemeContext = createContext({
+  className: ""
+});
+function PortalThemeProvider({
+  className,
+  children
+}) {
+  return /* @__PURE__ */ jsx(
+    PortalThemeContext.Provider,
+    {
+      value: useMemo(() => ({ className }), [className]),
+      children
+    }
+  );
+}
+const RendererConfigContext = createContext({
+  config: void 0,
+  mode: "renderer"
+});
+function RendererConfigProvider({
+  config,
+  mode,
+  children
+}) {
+  const value = useMemo(() => ({ config, mode }), [config, mode]);
+  return /* @__PURE__ */ jsx(RendererConfigContext.Provider, { value, children });
+}
+function useRendererConfig() {
+  return use(RendererConfigContext).config;
+}
+function useRendererMode() {
+  return use(RendererConfigContext).mode;
+}
+function RendererWrapper({
+  rendererKey,
+  defaultRenderer: DefaultRenderer,
+  props
+}) {
+  const config = useRendererConfig();
+  const Renderer = config?.[rendererKey] ?? DefaultRenderer;
+  return /* @__PURE__ */ jsx(Renderer, { ...props });
+}
+function createRendererDecoration(rendererKey, defaultRenderer, props) {
+  return createElement(RendererWrapper, {
+    rendererKey,
+    defaultRenderer,
+    props
+  });
+}
+const InfoIcon = () => /* @__PURE__ */ jsx(Info, { size: 16 });
+const LightbulbIcon = () => /* @__PURE__ */ jsx(Lightbulb, { size: 16 });
+const MessageWarningIcon = () => /* @__PURE__ */ jsx(MessageSquareWarning, { size: 16 });
+const TriangleAlertIcon = () => /* @__PURE__ */ jsx(TriangleAlert, { size: 16 });
+const OctagonAlertIcon = () => /* @__PURE__ */ jsx(OctagonAlert, { size: 16 });
+const ALERT_ICONS = {
+  note: InfoIcon,
+  tip: LightbulbIcon,
+  important: MessageWarningIcon,
+  warning: TriangleAlertIcon,
+  caution: OctagonAlertIcon
+};
+const AlertRenderer = ({ type }) => {
+  const Icon = ALERT_ICONS[type];
+  return /* @__PURE__ */ jsxs("div", { className: `rich-alert-header rich-alert-header-${type}`, children: [
+    /* @__PURE__ */ jsx("span", { className: "rich-alert-icon", children: /* @__PURE__ */ jsx(Icon, {}) }),
+    /* @__PURE__ */ jsx("span", { className: "rich-alert-label", children: ALERT_LABELS[type] })
+  ] });
+};
+function AlertReadOnlyDecorator({
+  alertType,
+  contentEditor
+}) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      RendererWrapper,
+      {
+        rendererKey: "Alert",
+        defaultRenderer: AlertRenderer,
+        props: { type: alertType }
+      }
+    ),
+    /* @__PURE__ */ jsx("div", { className: "rich-alert-content", children: /* @__PURE__ */ jsx(LexicalNestedComposer, { initialEditor: contentEditor, children: /* @__PURE__ */ jsx(
+      RichTextPlugin,
+      {
+        contentEditable: /* @__PURE__ */ jsx(
+          ContentEditable,
+          {
+            className: "rich-alert-content-editable",
+            style: { outline: "none" },
+            "aria-placeholder": "",
+            placeholder: /* @__PURE__ */ jsx("span", { style: { display: "none" } })
+          }
+        ),
+        ErrorBoundary: LexicalErrorBoundary
+      }
+    ) }) })
+  ] });
+}
+const editorTheme = {
+  text: {
+    bold: "rich-text-bold",
+    italic: "rich-text-italic",
+    underline: "rich-text-underline",
+    strikethrough: "rich-text-strikethrough",
+    code: "rich-text-code",
+    highlight: "rich-text-highlight"
+  },
+  heading: {
+    h1: "rich-heading-h1",
+    h2: "rich-heading-h2",
+    h3: "rich-heading-h3",
+    h4: "rich-heading-h4",
+    h5: "rich-heading-h5",
+    h6: "rich-heading-h6"
+  },
+  list: {
+    ol: "rich-list-ol",
+    ul: "rich-list-ul",
+    listitem: "rich-list-item",
+    nested: {
+      listitem: "rich-list-nested-item"
+    }
+  },
+  quote: "rich-quote",
+  link: "rich-link",
+  paragraph: "rich-paragraph",
+  code: "rich-code-block",
+  table: "rich-table",
+  tableCell: "rich-table-cell",
+  tableCellHeader: "rich-table-cell-header",
+  tableScrollableWrapper: "rich-table-scrollable-wrapper",
+  /** Used by @lexical/extension HorizontalRuleNode */
+  hr: "rich-hr"
+};
+const FootnoteDefinitionsContext = createContext({
+  definitions: {},
+  displayNumberMap: {}
+});
+function FootnoteDefinitionsProvider({
+  definitions,
+  displayNumberMap,
+  children
+}) {
+  const value = useMemo(
+    () => ({ definitions, displayNumberMap }),
+    [definitions, displayNumberMap]
+  );
+  return /* @__PURE__ */ jsx(FootnoteDefinitionsContext, { value, children });
+}
+function useFootnoteDefinitions() {
+  return use(FootnoteDefinitionsContext);
+}
+function useFootnoteContent(identifier) {
+  const { definitions } = use(FootnoteDefinitionsContext);
+  return definitions[identifier];
+}
+function useFootnoteDisplayNumber(identifier) {
+  const { displayNumberMap } = use(FootnoteDefinitionsContext);
+  return displayNumberMap[identifier];
+}
+function FootnoteRenderer({ identifier }) {
+  const content = useFootnoteContent(identifier);
+  const displayNumber = useFootnoteDisplayNumber(identifier);
+  const referenceId = `footnote-ref-${identifier}`;
+  const targetId = `footnote-${identifier}`;
+  const handleClick = useCallback(
+    (e) => {
+      const target = document.getElementById(targetId) || document.getElementById(`fn-${identifier}`);
+      if (!target) return;
+      e.preventDefault();
+      target.scrollIntoView({ behavior: "smooth", block: "center" });
+      target.classList.add("rich-footnote-highlight");
+      window.setTimeout(() => {
+        target.classList.remove("rich-footnote-highlight");
+      }, 1200);
+    },
+    [identifier, targetId]
+  );
+  const label = displayNumber ?? identifier;
+  return /* @__PURE__ */ jsx("span", { className: "rich-footnote-ref-wrapper", children: /* @__PURE__ */ jsxs(TooltipRoot, { children: [
+    /* @__PURE__ */ jsx(
+      TooltipTrigger,
+      {
+        render: (props) => /* @__PURE__ */ jsx(
+          "a",
+          {
+            ...props,
+            className: "rich-footnote-ref",
+            href: `#${targetId}`,
+            id: referenceId,
+            role: "doc-noteref",
+            "aria-label": content ? `Footnote ${label}: ${content}` : `Footnote ${label}`,
+            onClick: handleClick,
+            "data-footnote-ref": identifier,
+            children: label
+          }
+        )
+      }
+    ),
+    content ? /* @__PURE__ */ jsx(TooltipContent, { children: content }) : null
+  ] }) });
+}
+class FootnoteNode extends DecoratorNode {
+  constructor(identifier, key) {
+    super(key);
+    __publicField(this, "__identifier");
+    this.__identifier = identifier;
+  }
+  static getType() {
+    return "footnote";
+  }
+  static clone(node) {
+    return new FootnoteNode(node.__identifier, node.__key);
+  }
+  createDOM(_config) {
+    const sup = document.createElement("sup");
+    sup.className = "rich-footnote";
+    return sup;
+  }
+  updateDOM() {
+    return false;
+  }
+  isInline() {
+    return true;
+  }
+  static importJSON(serializedNode) {
+    return $createFootnoteNode(serializedNode.identifier);
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: "footnote",
+      identifier: this.__identifier,
+      version: 1
+    };
+  }
+  getIdentifier() {
+    return this.getLatest().__identifier;
+  }
+  setIdentifier(identifier) {
+    const writable = this.getWritable();
+    writable.__identifier = identifier;
+  }
+  decorate(_editor, _config) {
+    return createRendererDecoration("Footnote", FootnoteRenderer, {
+      identifier: this.__identifier
+    });
+  }
+}
+function $createFootnoteNode(identifier) {
+  return new FootnoteNode(identifier);
+}
+function $isFootnoteNode(node) {
+  return node instanceof FootnoteNode;
+}
+let katexModule = null;
+let katexLoadPromise = null;
+function loadKaTeX() {
+  if (katexModule) return Promise.resolve(katexModule);
+  if (!katexLoadPromise) {
+    katexLoadPromise = import("katex").then((mod) => {
+      katexModule = mod;
+      return katexModule;
+    });
+  }
+  return katexLoadPromise;
+}
+function KaTeXRenderer({ equation, displayMode }) {
+  const [html, setHtml] = useState(null);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    let cancelled = false;
+    loadKaTeX().then((katex) => {
+      if (cancelled) return;
+      const rendered = katex.default.renderToString(equation, {
+        displayMode,
+        throwOnError: false
+      });
+      setHtml(rendered);
+      setError(null);
+    }).catch(() => {
+      if (cancelled) return;
+      setHtml(null);
+      setError("KaTeX is not available");
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [equation, displayMode]);
+  if (error) {
+    return /* @__PURE__ */ jsx("code", { className: "rich-katex-fallback", children: equation });
+  }
+  if (html) {
+    return /* @__PURE__ */ jsx(
+      "span",
+      {
+        className: displayMode ? "rich-katex-block" : "rich-katex-inline",
+        dangerouslySetInnerHTML: { __html: html }
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx("code", { className: "rich-katex-fallback", children: equation });
+}
+class KaTeXInlineNode extends DecoratorNode {
+  constructor(equation, key) {
+    super(key);
+    __publicField(this, "__equation");
+    this.__equation = equation;
+  }
+  static getType() {
+    return "katex-inline";
+  }
+  static clone(node) {
+    return new KaTeXInlineNode(node.__equation, node.__key);
+  }
+  createDOM(_config) {
+    return document.createElement("span");
+  }
+  updateDOM() {
+    return false;
+  }
+  isInline() {
+    return true;
+  }
+  static importJSON(serializedNode) {
+    return $createKaTeXInlineNode(serializedNode.equation);
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: "katex-inline",
+      equation: this.__equation,
+      version: 1
+    };
+  }
+  getEquation() {
+    return this.__equation;
+  }
+  setEquation(equation) {
+    const writable = this.getWritable();
+    writable.__equation = equation;
+  }
+  decorate(_editor, _config) {
+    return createRendererDecoration("KaTeX", KaTeXRenderer, {
+      equation: this.__equation,
+      displayMode: false
+    });
+  }
+}
+function $createKaTeXInlineNode(equation) {
+  return new KaTeXInlineNode(equation);
+}
+function $isKaTeXInlineNode(node) {
+  return node instanceof KaTeXInlineNode;
+}
+function MentionRenderer({ handle, displayName }) {
+  const normalizedHandle = handle.replace(/^@+/, "");
+  const label = displayName || normalizedHandle;
+  return /* @__PURE__ */ jsx("span", { className: "rich-mention rich-mention-plain", children: /* @__PURE__ */ jsxs("span", { className: "rich-mention-handle", children: [
+    "@",
+    label
+  ] }) });
+}
+class MentionNode extends DecoratorNode {
+  constructor(platform, handle, displayName, key) {
+    super(key);
+    __publicField(this, "__platform");
+    __publicField(this, "__handle");
+    __publicField(this, "__displayName");
+    this.__platform = platform;
+    this.__handle = handle;
+    this.__displayName = displayName;
+  }
+  static getType() {
+    return "mention";
+  }
+  static clone(node) {
+    return new MentionNode(
+      node.__platform,
+      node.__handle,
+      node.__displayName,
+      node.__key
+    );
+  }
+  createDOM(_config) {
+    const el = document.createElement("span");
+    el.style.display = "inline-flex";
+    el.style.alignItems = "center";
+    el.style.height = "1lh";
+    return el;
+  }
+  updateDOM() {
+    return false;
+  }
+  isInline() {
+    return true;
+  }
+  getPlatform() {
+    return this.getLatest().__platform;
+  }
+  getHandle() {
+    return this.getLatest().__handle;
+  }
+  getDisplayName() {
+    return this.getLatest().__displayName;
+  }
+  static importJSON(serializedNode) {
+    return $createMentionNode(
+      serializedNode.platform,
+      serializedNode.handle,
+      serializedNode.displayName
+    );
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: "mention",
+      platform: this.__platform,
+      handle: this.__handle,
+      ...this.__displayName ? { displayName: this.__displayName } : {},
+      version: 1
+    };
+  }
+  decorate(_editor, _config) {
+    return createRendererDecoration("Mention", MentionRenderer, {
+      platform: this.__platform,
+      handle: this.__handle,
+      displayName: this.__displayName
+    });
+  }
+}
+function $createMentionNode(platform, handle, displayName) {
+  return new MentionNode(platform, handle, displayName);
+}
+function $isMentionNode(node) {
+  return node instanceof MentionNode;
+}
+class SpoilerNode extends ElementNode {
+  static getType() {
+    return "spoiler";
+  }
+  static clone(node) {
+    return new SpoilerNode(node.__key);
+  }
+  constructor(key) {
+    super(key);
+  }
+  createDOM(_config) {
+    const span = document.createElement("span");
+    span.className = "rich-spoiler";
+    span.setAttribute("role", "button");
+    span.setAttribute("tabindex", "0");
+    span.setAttribute("aria-label", "Spoiler (click to reveal)");
+    const toggle = () => {
+      if (span.isContentEditable) return;
+      const revealed = span.classList.toggle("rich-spoiler-revealed");
+      span.setAttribute(
+        "aria-label",
+        revealed ? "Spoiler (revealed)" : "Spoiler (click to reveal)"
+      );
+    };
+    span.addEventListener("click", toggle);
+    span.addEventListener("keydown", (e) => {
+      if (e.key === "Enter" || e.key === " ") {
+        e.preventDefault();
+        toggle();
+      }
+    });
+    return span;
+  }
+  updateDOM() {
+    return false;
+  }
+  static importJSON(_serializedNode) {
+    return $createSpoilerNode();
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: "spoiler",
+      version: 1
+    };
+  }
+  canInsertTextBefore() {
+    return true;
+  }
+  canInsertTextAfter() {
+    return true;
+  }
+  isInline() {
+    return true;
+  }
+}
+function $createSpoilerNode() {
+  return new SpoilerNode();
+}
+function $isSpoilerNode(node) {
+  return node instanceof SpoilerNode;
+}
+class TaskListItemNode extends ElementNode {
+  constructor(checked, key) {
+    super(key);
+    __publicField(this, "__checked");
+    this.__checked = checked;
+  }
+  static getType() {
+    return "task-list-item";
+  }
+  static clone(node) {
+    return new TaskListItemNode(node.__checked, node.__key);
+  }
+  createDOM(_config) {
+    const li = document.createElement("li");
+    li.className = "rich-task-list-item";
+    li.setAttribute("role", "listitem");
+    const checkbox = document.createElement("input");
+    checkbox.type = "checkbox";
+    checkbox.checked = this.__checked;
+    checkbox.disabled = true;
+    checkbox.className = "rich-task-checkbox";
+    li.prepend(checkbox);
+    if (this.__checked) {
+      li.classList.add("rich-task-checked");
+    }
+    return li;
+  }
+  updateDOM(prevNode, dom) {
+    if (prevNode.__checked !== this.__checked) {
+      const checkbox = dom.querySelector(
+        'input[type="checkbox"]'
+      );
+      if (checkbox) {
+        checkbox.checked = this.__checked;
+      }
+      dom.classList.toggle("rich-task-checked", this.__checked);
+    }
+    return false;
+  }
+  static importJSON(serializedNode) {
+    return $createTaskListItemNode(serializedNode.checked);
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: "task-list-item",
+      checked: this.__checked,
+      version: 1
+    };
+  }
+  getChecked() {
+    return this.getLatest().__checked;
+  }
+  setChecked(checked) {
+    const writable = this.getWritable();
+    writable.__checked = checked;
+  }
+  toggleChecked() {
+    this.setChecked(!this.getChecked());
+  }
+  isInline() {
+    return false;
+  }
+}
+function $createTaskListItemNode(checked = false) {
+  return new TaskListItemNode(checked);
+}
+function $isTaskListItemNode(node) {
+  return node instanceof TaskListItemNode;
+}
+const NESTED_EDITOR_NODES = [
+  HeadingNode,
+  QuoteNode,
+  ListNode,
+  ListItemNode,
+  LinkNode,
+  AutoLinkNode,
+  HorizontalRuleNode,
+  CodeNode,
+  TableNode,
+  TableCellNode,
+  TableRowNode,
+  SpoilerNode,
+  MentionNode,
+  TaskListItemNode,
+  FootnoteNode,
+  KaTeXInlineNode
+];
+const ALERT_TYPES = [
+  "note",
+  "tip",
+  "important",
+  "warning",
+  "caution"
+];
+const ALERT_LABELS = {
+  note: "Note",
+  tip: "Tip",
+  important: "Important",
+  warning: "Warning",
+  caution: "Caution"
+};
+function createContentEditor$1() {
+  return createEditor({
+    namespace: "AlertContent",
+    nodes: NESTED_EDITOR_NODES,
+    theme: editorTheme,
+    onError: (error) => {
+      console.error("[AlertContent]", error);
+    }
+  });
+}
+const _AlertQuoteNode = class _AlertQuoteNode extends DecoratorNode {
+  constructor(alertType, contentEditor, key) {
+    super(key);
+    __publicField(this, "__alertType");
+    __publicField(this, "__contentEditor");
+    this.__alertType = alertType;
+    this.__contentEditor = contentEditor || createContentEditor$1();
+  }
+  static getType() {
+    return "alert-quote";
+  }
+  static clone(node) {
+    return new _AlertQuoteNode(
+      node.__alertType,
+      node.__contentEditor,
+      node.__key
+    );
+  }
+  createDOM(_config) {
+    const div = document.createElement("div");
+    div.className = `rich-alert rich-alert-${this.__alertType}`;
+    return div;
+  }
+  updateDOM(prevNode, dom) {
+    if (prevNode.__alertType !== this.__alertType) {
+      dom.className = `rich-alert rich-alert-${this.__alertType}`;
+    }
+    return false;
+  }
+  isInline() {
+    return false;
+  }
+  getAlertType() {
+    return this.__alertType;
+  }
+  setAlertType(alertType) {
+    const writable = this.getWritable();
+    writable.__alertType = alertType;
+  }
+  getContentEditor() {
+    return this.__contentEditor;
+  }
+  getTextContent() {
+    return this.__contentEditor.getEditorState().read(() => {
+      return $getRoot().getTextContent();
+    });
+  }
+  static importJSON(serializedNode) {
+    const node = new _AlertQuoteNode(serializedNode.alertType);
+    if (serializedNode.content) {
+      const editorState = node.__contentEditor.parseEditorState(
+        serializedNode.content
+      );
+      node.__contentEditor.setEditorState(editorState);
+    }
+    return node;
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: "alert-quote",
+      alertType: this.__alertType,
+      content: this.__contentEditor.getEditorState().toJSON(),
+      version: 1
+    };
+  }
+  decorate(_editor, _config) {
+    return createElement(AlertReadOnlyDecorator, {
+      alertType: this.__alertType,
+      contentEditor: this.__contentEditor
+    });
+  }
+};
+__publicField(_AlertQuoteNode, "slashMenuItems", [
+  {
+    title: "Callout",
+    icon: createElement(Info, { size: 20 }),
+    description: "Info callout block",
+    keywords: ["alert", "note", "info", "callout"],
+    section: "ADVANCED",
+    onSelect: (editor) => {
+      editor.update(() => {
+        $insertNodes([$createAlertQuoteNode("note")]);
+      });
+    }
+  },
+  {
+    title: "Tip",
+    icon: createElement(Lightbulb, { size: 20 }),
+    description: "Highlight a useful tip",
+    keywords: ["alert", "tip", "hint"],
+    section: "ADVANCED",
+    onSelect: (editor) => {
+      editor.update(() => {
+        $insertNodes([$createAlertQuoteNode("tip")]);
+      });
+    }
+  },
+  {
+    title: "Warning",
+    icon: createElement(TriangleAlert, { size: 20 }),
+    description: "Warn about something",
+    keywords: ["alert", "warning", "caution"],
+    section: "ADVANCED",
+    onSelect: (editor) => {
+      editor.update(() => {
+        $insertNodes([$createAlertQuoteNode("warning")]);
+      });
+    }
+  }
+]);
+let AlertQuoteNode = _AlertQuoteNode;
+function $createAlertQuoteNode(alertType) {
+  return new AlertQuoteNode(alertType);
+}
+function $isAlertQuoteNode(node) {
+  return node instanceof AlertQuoteNode;
+}
+const BannerRenderer = ({ type }) => {
+  return /* @__PURE__ */ jsx("span", { className: `rich-banner-icon rich-banner-icon-${type}` });
+};
+function BannerReadOnlyDecorator({
+  bannerType,
+  contentEditor
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: "rich-banner-inner", children: [
+    /* @__PURE__ */ jsx(
+      RendererWrapper,
+      {
+        rendererKey: "Banner",
+        defaultRenderer: BannerRenderer,
+        props: { type: bannerType }
+      }
+    ),
+    /* @__PURE__ */ jsx("div", { className: "rich-banner-content", children: /* @__PURE__ */ jsx(LexicalNestedComposer, { initialEditor: contentEditor, children: /* @__PURE__ */ jsx(
+      RichTextPlugin,
+      {
+        contentEditable: /* @__PURE__ */ jsx(
+          ContentEditable,
+          {
+            className: "rich-banner-content-editable",
+            style: { outline: "none" },
+            "aria-placeholder": "",
+            placeholder: /* @__PURE__ */ jsx("span", { style: { display: "none" } })
+          }
+        ),
+        ErrorBoundary: LexicalErrorBoundary
+      }
+    ) }) })
+  ] });
+}
+const LEGACY_TYPE_MAP = {
+  info: "note",
+  success: "tip",
+  error: "caution"
+};
+function normalizeBannerType(type) {
+  if (type in LEGACY_TYPE_MAP) return LEGACY_TYPE_MAP[type];
+  return type || "note";
+}
+const BANNER_TYPES = [
+  "note",
+  "tip",
+  "important",
+  "warning",
+  "caution"
+];
+const BANNER_LABELS = {
+  note: "Note",
+  tip: "Tip",
+  important: "Important",
+  warning: "Warning",
+  caution: "Caution"
+};
+function createContentEditor() {
+  return createEditor({
+    namespace: "BannerContent",
+    nodes: NESTED_EDITOR_NODES,
+    theme: editorTheme,
+    onError: (error) => {
+      console.error("[BannerContent]", error);
+    }
+  });
+}
+const _BannerNode = class _BannerNode extends DecoratorNode {
+  constructor(bannerType, contentEditor, key) {
+    super(key);
+    __publicField(this, "__bannerType");
+    __publicField(this, "__contentEditor");
+    this.__bannerType = bannerType;
+    this.__contentEditor = contentEditor || createContentEditor();
+  }
+  static getType() {
+    return "banner";
+  }
+  static clone(node) {
+    return new _BannerNode(node.__bannerType, node.__contentEditor, node.__key);
+  }
+  createDOM(_config) {
+    const div = document.createElement("div");
+    div.className = `rich-banner rich-banner-${this.__bannerType}`;
+    return div;
+  }
+  updateDOM(prevNode, dom) {
+    if (prevNode.__bannerType !== this.__bannerType) {
+      dom.className = `rich-banner rich-banner-${this.__bannerType}`;
+    }
+    return false;
+  }
+  isInline() {
+    return false;
+  }
+  getBannerType() {
+    return this.__bannerType;
+  }
+  setBannerType(bannerType) {
+    const writable = this.getWritable();
+    writable.__bannerType = bannerType;
+  }
+  getContentEditor() {
+    return this.__contentEditor;
+  }
+  getTextContent() {
+    return this.__contentEditor.getEditorState().read(() => {
+      return $getRoot().getTextContent();
+    });
+  }
+  static importJSON(serializedNode) {
+    const legacy = serializedNode;
+    const bannerType = normalizeBannerType(serializedNode.bannerType);
+    const node = new _BannerNode(bannerType);
+    if (serializedNode.content) {
+      const editorState = node.__contentEditor.parseEditorState(
+        serializedNode.content
+      );
+      node.__contentEditor.setEditorState(editorState);
+    } else if (legacy.children) {
+      const content = {
+        root: {
+          children: legacy.children,
+          direction: null,
+          format: "",
+          indent: 0,
+          type: "root",
+          version: 1
+        }
+      };
+      const editorState = node.__contentEditor.parseEditorState(content);
+      node.__contentEditor.setEditorState(editorState);
+    }
+    return node;
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: "banner",
+      bannerType: this.__bannerType,
+      content: this.__contentEditor.getEditorState().toJSON(),
+      version: 1
+    };
+  }
+  decorate(_editor, _config) {
+    return createElement(BannerReadOnlyDecorator, {
+      bannerType: this.__bannerType,
+      contentEditor: this.__contentEditor
+    });
+  }
+};
+__publicField(_BannerNode, "slashMenuItems", [
+  {
+    title: "Banner",
+    icon: createElement(Flag, { size: 20 }),
+    description: "Highlighted banner block",
+    keywords: ["banner", "notice", "announcement"],
+    section: "ADVANCED",
+    onSelect: (editor) => {
+      editor.update(() => {
+        $insertNodes([$createBannerNode("note")]);
+      });
+    }
+  }
+]);
+let BannerNode = _BannerNode;
+function $createBannerNode(bannerType) {
+  return new BannerNode(bannerType);
+}
+function $isBannerNode(node) {
+  return node instanceof BannerNode;
+}
+const ColorSchemeContext = createContext("light");
+function ColorSchemeProvider({
+  colorScheme,
+  children
+}) {
+  return /* @__PURE__ */ jsx(ColorSchemeContext.Provider, { value: colorScheme, children });
+}
+function useColorScheme() {
+  return use(ColorSchemeContext);
+}
+let codeToHtmlFn = null;
+let shikiLoadPromise = null;
+function loadCodeToHtml() {
+  if (codeToHtmlFn) return Promise.resolve(codeToHtmlFn);
+  if (!shikiLoadPromise) {
+    shikiLoadPromise = import("shiki/bundle/web").then((mod) => {
+      codeToHtmlFn = mod.codeToHtml;
+      return mod.codeToHtml;
+    }).catch((err) => {
+      shikiLoadPromise = null;
+      throw err;
+    });
+  }
+  return shikiLoadPromise;
+}
+function CodeBlockRenderer({
+  code,
+  language,
+  showLineNumbers
+}) {
+  const colorScheme = useColorScheme();
+  const shikiTheme = colorScheme === "dark" ? "github-dark" : "github-light";
+  const [highlightedHtml, setHighlightedHtml] = useState(null);
+  const [copied, setCopied] = useState(false);
+  const copyTimerRef = useRef(void 0);
+  useEffect(() => {
+    let cancelled = false;
+    setHighlightedHtml(null);
+    loadCodeToHtml().then(
+      (toHtml) => toHtml(code, {
+        lang: language,
+        theme: shikiTheme
+      })
+    ).then((html) => {
+      if (!cancelled) {
+        setHighlightedHtml(html);
+      }
+    }).catch(() => {
+      if (!cancelled) {
+        setHighlightedHtml(null);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [code, language, shikiTheme]);
+  useEffect(() => {
+    return () => clearTimeout(copyTimerRef.current);
+  }, []);
+  const handleCopy = useCallback(() => {
+    navigator.clipboard.writeText(code).then(() => {
+      setCopied(true);
+      clearTimeout(copyTimerRef.current);
+      copyTimerRef.current = setTimeout(() => setCopied(false), 2e3);
+    }).catch(() => {
+    });
+  }, [code]);
+  const header = language ? /* @__PURE__ */ jsxs("div", { className: "rich-code-block-header", children: [
+    /* @__PURE__ */ jsx("span", { className: "rich-code-block-lang", children: language }),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        className: "rich-code-block-copy",
+        onClick: handleCopy,
+        "aria-label": copied ? "Copied to clipboard" : "Copy code",
+        children: copied ? "Copied" : "Copy"
+      }
+    )
+  ] }) : null;
+  const wrapperClass = showLineNumbers ? "rich-code-block rich-code-block-numbered" : "rich-code-block";
+  if (highlightedHtml) {
+    return /* @__PURE__ */ jsxs("div", { className: wrapperClass, children: [
+      header,
+      /* @__PURE__ */ jsx("div", { dangerouslySetInnerHTML: { __html: highlightedHtml } })
+    ] });
+  }
+  const lines = code.split("\n");
+  return /* @__PURE__ */ jsxs("div", { className: wrapperClass, children: [
+    header,
+    /* @__PURE__ */ jsx("pre", { children: /* @__PURE__ */ jsx("code", { children: lines.map((line, i) => /* @__PURE__ */ jsxs("span", { className: "line", children: [
+      line,
+      i < lines.length - 1 ? "\n" : ""
+    ] }, i)) }) })
+  ] });
+}
+const _CodeBlockNode = class _CodeBlockNode extends DecoratorNode {
+  constructor(code, language, key) {
+    super(key);
+    __publicField(this, "__code");
+    __publicField(this, "__language");
+    this.__code = code;
+    this.__language = language;
+  }
+  static getType() {
+    return "code-block";
+  }
+  static clone(node) {
+    return new _CodeBlockNode(node.__code, node.__language, node.__key);
+  }
+  createDOM(_config) {
+    const div = document.createElement("div");
+    div.className = "rich-code-block-wrapper";
+    return div;
+  }
+  updateDOM() {
+    return false;
+  }
+  isInline() {
+    return false;
+  }
+  static importJSON(serializedNode) {
+    return $createCodeBlockNode(serializedNode.code, serializedNode.language);
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: "code-block",
+      code: this.__code,
+      language: this.__language,
+      version: 1
+    };
+  }
+  getCode() {
+    return this.__code;
+  }
+  setCode(code) {
+    const writable = this.getWritable();
+    writable.__code = code;
+  }
+  getLanguage() {
+    return this.__language;
+  }
+  setLanguage(language) {
+    const writable = this.getWritable();
+    writable.__language = language;
+  }
+  decorate(_editor, _config) {
+    return createRendererDecoration("CodeBlock", CodeBlockRenderer, {
+      code: this.__code,
+      language: this.__language
+    });
+  }
+};
+__publicField(_CodeBlockNode, "slashMenuItems", [
+  {
+    title: "Code Block",
+    icon: createElement(Code, { size: 20 }),
+    description: "Syntax-highlighted code",
+    keywords: ["code", "snippet", "codeblock"],
+    section: "MEDIA",
+    onSelect: (editor) => {
+      editor.update(() => {
+        $insertNodes([$createCodeBlockNode("", "text")]);
+      });
+    }
+  }
+]);
+let CodeBlockNode = _CodeBlockNode;
+function $createCodeBlockNode(code, language) {
+  return new CodeBlockNode(code, language);
+}
+function $isCodeBlockNode(node) {
+  return node instanceof CodeBlockNode;
+}
+const SVG_NS = "http://www.w3.org/2000/svg";
+const DEFAULT_ATTRS = {
+  xmlns: SVG_NS,
+  width: "24",
+  height: "24",
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-width": "2",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round"
+};
+function createLucideSvg(iconNode, attrs = {}) {
+  const svg = document.createElementNS(SVG_NS, "svg");
+  const merged = { ...DEFAULT_ATTRS, ...attrs };
+  for (const [k, v] of Object.entries(merged)) {
+    svg.setAttribute(k, v);
+  }
+  for (const [tag, elAttrs] of iconNode) {
+    const el = document.createElementNS(SVG_NS, tag);
+    for (const [k, v] of Object.entries(elAttrs)) {
+      if (k === "key") continue;
+      el.setAttribute(k, v);
+    }
+    svg.append(el);
+  }
+  return svg;
+}
+const ChevronDownIconNode = ChevronDown.iconNode ?? ChevronDown.__iconNode ?? [];
+const _DetailsNode = class _DetailsNode extends ElementNode {
+  constructor(summary, open = false, key) {
+    super(key);
+    __publicField(this, "__summary");
+    __publicField(this, "__open");
+    this.__summary = summary;
+    this.__open = open;
+  }
+  static getType() {
+    return "details";
+  }
+  static clone(node) {
+    return new _DetailsNode(node.__summary, node.__open, node.__key);
+  }
+  createDOM(_config) {
+    const details = document.createElement("details");
+    details.className = "rich-details";
+    if (this.__open) {
+      details.open = true;
+    }
+    const summary = document.createElement("summary");
+    summary.className = "rich-details-summary";
+    const label = document.createElement("span");
+    label.className = "rich-details-summary-text";
+    label.textContent = this.__summary;
+    summary.append(label);
+    const chevron = document.createElement("span");
+    chevron.className = "rich-details-chevron";
+    chevron.append(
+      createLucideSvg(ChevronDownIconNode, { width: "1em", height: "1em" })
+    );
+    summary.append(chevron);
+    const content = document.createElement("div");
+    content.className = "rich-details-content";
+    details.append(summary, content);
+    return details;
+  }
+  updateDOM(prevNode, dom) {
+    const details = dom;
+    if (prevNode.__open !== this.__open) {
+      details.open = this.__open;
+    }
+    if (prevNode.__summary !== this.__summary) {
+      const label = dom.querySelector(".rich-details-summary-text");
+      if (label) {
+        label.textContent = this.__summary;
+      }
+    }
+    return false;
+  }
+  static importJSON(serializedNode) {
+    return $createDetailsNode(serializedNode.summary, serializedNode.open);
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: "details",
+      summary: this.__summary,
+      open: this.__open,
+      version: 1
+    };
+  }
+  getSummary() {
+    return this.getLatest().__summary;
+  }
+  setSummary(summary) {
+    const writable = this.getWritable();
+    writable.__summary = summary;
+  }
+  getOpen() {
+    return this.getLatest().__open;
+  }
+  setOpen(open) {
+    const writable = this.getWritable();
+    writable.__open = open;
+  }
+  toggleOpen() {
+    this.setOpen(!this.getOpen());
+  }
+  getDOMSlot(element) {
+    const content = element.querySelector(
+      ".rich-details-content"
+    );
+    return super.getDOMSlot(element).withElement(content);
+  }
+  isInline() {
+    return false;
+  }
+};
+__publicField(_DetailsNode, "slashMenuItems", [
+  {
+    title: "Details",
+    icon: createElement(ChevronRight, { size: 20 }),
+    description: "Collapsible content block",
+    keywords: ["details", "toggle", "collapse", "accordion"],
+    section: "ADVANCED",
+    onSelect: (editor) => {
+      editor.update(() => {
+        $insertNodes([$createDetailsNode("Details")]);
+      });
+    }
+  }
+]);
+let DetailsNode = _DetailsNode;
+function $createDetailsNode(summary, open = false) {
+  return new DetailsNode(summary, open);
+}
+function $isDetailsNode(node) {
+  return node instanceof DetailsNode;
+}
+function FootnoteSectionRenderer({
+  definitions
+}) {
+  const { displayNumberMap } = useFootnoteDefinitions();
+  const sortedEntries = Object.entries(definitions).sort(
+    ([a], [b]) => (displayNumberMap[a] ?? 0) - (displayNumberMap[b] ?? 0)
+  );
+  if (sortedEntries.length === 0) return null;
+  return /* @__PURE__ */ jsxs("div", { className: "rich-footnote-section-content", role: "doc-endnotes", children: [
+    /* @__PURE__ */ jsx("hr", { className: "rich-footnote-section-divider" }),
+    /* @__PURE__ */ jsx("ol", { className: "rich-footnote-section-list", children: sortedEntries.map(([identifier, content]) => {
+      const displayNum = displayNumberMap[identifier] ?? identifier;
+      return /* @__PURE__ */ jsx(
+        FootnoteSectionItem,
+        {
+          identifier,
+          content,
+          displayNum
+        },
+        identifier
+      );
+    }) })
+  ] });
+}
+function FootnoteSectionItem({
+  identifier,
+  content,
+  displayNum
+}) {
+  const targetId = `footnote-${identifier}`;
+  const refId = `footnote-ref-${identifier}`;
+  const handleBackClick = useCallback(
+    (e) => {
+      e.preventDefault();
+      const refElement = document.getElementById(refId);
+      if (!refElement) return;
+      refElement.scrollIntoView({ behavior: "smooth", block: "center" });
+      refElement.classList.add("rich-footnote-highlight");
+      window.setTimeout(() => {
+        refElement.classList.remove("rich-footnote-highlight");
+      }, 1200);
+    },
+    [refId]
+  );
+  return /* @__PURE__ */ jsxs(
+    "li",
+    {
+      id: targetId,
+      className: "rich-footnote-section-item",
+      value: typeof displayNum === "number" ? displayNum : void 0,
+      children: [
+        /* @__PURE__ */ jsx("span", { className: "rich-footnote-section-item-content", children: content }),
+        /* @__PURE__ */ jsx(
+          "a",
+          {
+            href: `#${refId}`,
+            onClick: handleBackClick,
+            className: "rich-footnote-back-ref",
+            role: "doc-backlink",
+            "aria-label": `Back to reference ${displayNum}`,
+            children: "↩"
+          }
+        )
+      ]
+    }
+  );
+}
+class FootnoteSectionNode extends DecoratorNode {
+  constructor(definitions, key) {
+    super(key);
+    __publicField(this, "__definitions");
+    this.__definitions = definitions;
+  }
+  static getType() {
+    return "footnote-section";
+  }
+  static clone(node) {
+    return new FootnoteSectionNode({ ...node.__definitions }, node.__key);
+  }
+  createDOM(_config) {
+    const div = document.createElement("div");
+    div.className = "rich-footnote-section";
+    return div;
+  }
+  updateDOM() {
+    return false;
+  }
+  isInline() {
+    return false;
+  }
+  static importJSON(serializedNode) {
+    return $createFootnoteSectionNode(serializedNode.definitions);
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: "footnote-section",
+      definitions: this.__definitions,
+      version: 1
+    };
+  }
+  getDefinitions() {
+    return this.getLatest().__definitions;
+  }
+  setDefinitions(definitions) {
+    const writable = this.getWritable();
+    writable.__definitions = definitions;
+  }
+  getDefinition(identifier) {
+    return this.getLatest().__definitions[identifier];
+  }
+  setDefinition(identifier, content) {
+    const writable = this.getWritable();
+    writable.__definitions = {
+      ...writable.__definitions,
+      [identifier]: content
+    };
+  }
+  removeDefinition(identifier) {
+    const writable = this.getWritable();
+    const { [identifier]: _, ...rest } = writable.__definitions;
+    writable.__definitions = rest;
+  }
+  decorate(_editor, _config) {
+    return createRendererDecoration(
+      "FootnoteSection",
+      FootnoteSectionRenderer,
+      {
+        definitions: this.__definitions,
+        nodeKey: this.__key
+      }
+    );
+  }
+}
+function $createFootnoteSectionNode(definitions = {}) {
+  return new FootnoteSectionNode(definitions);
+}
+function $isFootnoteSectionNode(node) {
+  return node instanceof FootnoteSectionNode;
+}
+function GridReadOnlyDecorator({
+  cols,
+  gap,
+  cellEditors
+}) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: "rich-grid-inner",
+      style: {
+        display: "grid",
+        gridTemplateColumns: `repeat(${cols}, 1fr)`,
+        gap
+      },
+      children: cellEditors.map((editor, i) => /* @__PURE__ */ jsx("div", { className: "rich-grid-cell", children: /* @__PURE__ */ jsx(LexicalNestedComposer, { initialEditor: editor, children: /* @__PURE__ */ jsx(
+        RichTextPlugin,
+        {
+          contentEditable: /* @__PURE__ */ jsx(
+            ContentEditable,
+            {
+              className: "rich-grid-cell-editable",
+              style: { outline: "none" },
+              "aria-placeholder": "",
+              placeholder: /* @__PURE__ */ jsx("span", { style: { display: "none" } })
+            }
+          ),
+          ErrorBoundary: LexicalErrorBoundary
+        }
+      ) }) }, i))
+    }
+  );
+}
+function createCellEditor() {
+  return createEditor({
+    namespace: "GridCell",
+    nodes: NESTED_EDITOR_NODES,
+    theme: editorTheme,
+    onError: (error) => {
+      console.error("[GridCell]", error);
+    }
+  });
+}
+const _GridContainerNode = class _GridContainerNode extends DecoratorNode {
+  constructor(cols = 2, gap, cellEditors, key) {
+    super(key);
+    __publicField(this, "__cols");
+    __publicField(this, "__gap");
+    __publicField(this, "__cellEditors");
+    this.__cols = cols;
+    this.__gap = gap || "16px";
+    if (cellEditors) {
+      this.__cellEditors = cellEditors;
+    } else {
+      this.__cellEditors = Array.from(
+        { length: cols },
+        () => createCellEditor()
+      );
+    }
+  }
+  static getType() {
+    return "grid-container";
+  }
+  static clone(node) {
+    return new _GridContainerNode(
+      node.__cols,
+      node.__gap,
+      [...node.__cellEditors],
+      node.__key
+    );
+  }
+  createDOM(_config) {
+    const div = document.createElement("div");
+    div.className = "rich-grid-container";
+    return div;
+  }
+  updateDOM() {
+    return false;
+  }
+  isInline() {
+    return false;
+  }
+  getCols() {
+    return this.getLatest().__cols;
+  }
+  setCols(cols) {
+    const writable = this.getWritable();
+    const prev = writable.__cellEditors.length;
+    writable.__cols = cols;
+    if (cols > prev) {
+      for (let i = prev; i < cols; i++) {
+        writable.__cellEditors.push(createCellEditor());
+      }
+    }
+  }
+  getGap() {
+    return this.getLatest().__gap;
+  }
+  setGap(gap) {
+    const writable = this.getWritable();
+    writable.__gap = gap;
+  }
+  getCellEditors() {
+    return this.getLatest().__cellEditors;
+  }
+  addCells(count) {
+    const writable = this.getWritable();
+    for (let i = 0; i < count; i++) {
+      writable.__cellEditors.push(createCellEditor());
+    }
+  }
+  removeCells(count) {
+    const writable = this.getWritable();
+    const editors = writable.__cellEditors;
+    const toRemove = Math.min(count, editors.length);
+    for (let i = 0; i < toRemove; i++) {
+      const editor = editors.at(-1);
+      if (!editor) break;
+      const isEmpty = editor.getEditorState().read(() => {
+        return $getRoot().getTextContentSize() === 0;
+      });
+      if (!isEmpty) break;
+      editors.pop();
+    }
+  }
+  getTextContent() {
+    return this.__cellEditors.map(
+      (editor) => editor.getEditorState().read(() => $getRoot().getTextContent())
+    ).join("\n");
+  }
+  static importJSON(serializedNode) {
+    const legacy = serializedNode;
+    const cols = legacy.cols || 2;
+    const rawGap = legacy.gap;
+    const gap = typeof rawGap === "number" ? `${rawGap}px` : rawGap;
+    const node = new _GridContainerNode(cols, gap);
+    if (legacy.cells && legacy.cells.length > 0) {
+      const editors = legacy.cells.map((cellState) => {
+        const editor = createCellEditor();
+        const editorState = editor.parseEditorState(cellState);
+        editor.setEditorState(editorState);
+        return editor;
+      });
+      node.__cellEditors = editors;
+    } else if (legacy.children) {
+      const { children } = legacy;
+      const editors = children.map((child) => {
+        const editor = createCellEditor();
+        const content = {
+          root: {
+            children: [child],
+            direction: null,
+            format: "",
+            indent: 0,
+            type: "root",
+            version: 1
+          }
+        };
+        const editorState = editor.parseEditorState(content);
+        editor.setEditorState(editorState);
+        return editor;
+      });
+      node.__cellEditors = editors;
+    }
+    return node;
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: "grid-container",
+      cols: this.__cols,
+      gap: this.__gap,
+      cells: this.__cellEditors.map(
+        (editor) => editor.getEditorState().toJSON()
+      ),
+      version: 1
+    };
+  }
+  decorate(_editor, _config) {
+    return createElement(GridReadOnlyDecorator, {
+      cols: this.__cols,
+      gap: this.__gap,
+      cellEditors: this.__cellEditors
+    });
+  }
+};
+__publicField(_GridContainerNode, "slashMenuItems", [
+  {
+    title: "Grid",
+    icon: createElement(LayoutGrid, { size: 20 }),
+    description: "Grid layout container",
+    keywords: ["grid", "columns", "layout"],
+    section: "LAYOUT",
+    onSelect: (editor) => {
+      editor.update(() => {
+        $insertNodes([$createGridContainerNode(2)]);
+      });
+    }
+  }
+]);
+let GridContainerNode = _GridContainerNode;
+function $createGridContainerNode(cols = 2, gap) {
+  return new GridContainerNode(cols, gap);
+}
+function $isGridContainerNode(node) {
+  return node instanceof GridContainerNode;
+}
+function rgbaToThumbHash(w, h, rgba) {
+  if (w > 100 || h > 100) throw new Error(`${w}x${h} doesn't fit in 100x100`);
+  let { PI, round, max, cos, abs } = Math;
+  let avg_r = 0, avg_g = 0, avg_b = 0, avg_a = 0;
+  for (let i = 0, j = 0; i < w * h; i++, j += 4) {
+    let alpha = rgba[j + 3] / 255;
+    avg_r += alpha / 255 * rgba[j];
+    avg_g += alpha / 255 * rgba[j + 1];
+    avg_b += alpha / 255 * rgba[j + 2];
+    avg_a += alpha;
+  }
+  if (avg_a) {
+    avg_r /= avg_a;
+    avg_g /= avg_a;
+    avg_b /= avg_a;
+  }
+  let hasAlpha = avg_a < w * h;
+  let l_limit = hasAlpha ? 5 : 7;
+  let lx = max(1, round(l_limit * w / max(w, h)));
+  let ly = max(1, round(l_limit * h / max(w, h)));
+  let l = [];
+  let p = [];
+  let q = [];
+  let a = [];
+  for (let i = 0, j = 0; i < w * h; i++, j += 4) {
+    let alpha = rgba[j + 3] / 255;
+    let r = avg_r * (1 - alpha) + alpha / 255 * rgba[j];
+    let g = avg_g * (1 - alpha) + alpha / 255 * rgba[j + 1];
+    let b = avg_b * (1 - alpha) + alpha / 255 * rgba[j + 2];
+    l[i] = (r + g + b) / 3;
+    p[i] = (r + g) / 2 - b;
+    q[i] = r - g;
+    a[i] = alpha;
+  }
+  let encodeChannel = (channel, nx, ny) => {
+    let dc = 0, ac = [], scale = 0, fx = [];
+    for (let cy = 0; cy < ny; cy++) {
+      for (let cx = 0; cx * ny < nx * (ny - cy); cx++) {
+        let f = 0;
+        for (let x = 0; x < w; x++)
+          fx[x] = cos(PI / w * cx * (x + 0.5));
+        for (let y = 0; y < h; y++)
+          for (let x = 0, fy = cos(PI / h * cy * (y + 0.5)); x < w; x++)
+            f += channel[x + y * w] * fx[x] * fy;
+        f /= w * h;
+        if (cx || cy) {
+          ac.push(f);
+          scale = max(scale, abs(f));
+        } else {
+          dc = f;
+        }
+      }
+    }
+    if (scale)
+      for (let i = 0; i < ac.length; i++)
+        ac[i] = 0.5 + 0.5 / scale * ac[i];
+    return [dc, ac, scale];
+  };
+  let [l_dc, l_ac, l_scale] = encodeChannel(l, max(3, lx), max(3, ly));
+  let [p_dc, p_ac, p_scale] = encodeChannel(p, 3, 3);
+  let [q_dc, q_ac, q_scale] = encodeChannel(q, 3, 3);
+  let [a_dc, a_ac, a_scale] = hasAlpha ? encodeChannel(a, 5, 5) : [];
+  let isLandscape = w > h;
+  let header24 = round(63 * l_dc) | round(31.5 + 31.5 * p_dc) << 6 | round(31.5 + 31.5 * q_dc) << 12 | round(31 * l_scale) << 18 | hasAlpha << 23;
+  let header16 = (isLandscape ? ly : lx) | round(63 * p_scale) << 3 | round(63 * q_scale) << 9 | isLandscape << 15;
+  let hash = [header24 & 255, header24 >> 8 & 255, header24 >> 16, header16 & 255, header16 >> 8];
+  let ac_start = hasAlpha ? 6 : 5;
+  let ac_index = 0;
+  if (hasAlpha) hash.push(round(15 * a_dc) | round(15 * a_scale) << 4);
+  for (let ac of hasAlpha ? [l_ac, p_ac, q_ac, a_ac] : [l_ac, p_ac, q_ac])
+    for (let f of ac)
+      hash[ac_start + (ac_index >> 1)] |= round(15 * f) << ((ac_index++ & 1) << 2);
+  return new Uint8Array(hash);
+}
+function thumbHashToRGBA(hash) {
+  let { PI, min, max, cos, round } = Math;
+  let header24 = hash[0] | hash[1] << 8 | hash[2] << 16;
+  let header16 = hash[3] | hash[4] << 8;
+  let l_dc = (header24 & 63) / 63;
+  let p_dc = (header24 >> 6 & 63) / 31.5 - 1;
+  let q_dc = (header24 >> 12 & 63) / 31.5 - 1;
+  let l_scale = (header24 >> 18 & 31) / 31;
+  let hasAlpha = header24 >> 23;
+  let p_scale = (header16 >> 3 & 63) / 63;
+  let q_scale = (header16 >> 9 & 63) / 63;
+  let isLandscape = header16 >> 15;
+  let lx = max(3, isLandscape ? hasAlpha ? 5 : 7 : header16 & 7);
+  let ly = max(3, isLandscape ? header16 & 7 : hasAlpha ? 5 : 7);
+  let a_dc = hasAlpha ? (hash[5] & 15) / 15 : 1;
+  let a_scale = (hash[5] >> 4) / 15;
+  let ac_start = hasAlpha ? 6 : 5;
+  let ac_index = 0;
+  let decodeChannel = (nx, ny, scale) => {
+    let ac = [];
+    for (let cy = 0; cy < ny; cy++)
+      for (let cx = cy ? 0 : 1; cx * ny < nx * (ny - cy); cx++)
+        ac.push(((hash[ac_start + (ac_index >> 1)] >> ((ac_index++ & 1) << 2) & 15) / 7.5 - 1) * scale);
+    return ac;
+  };
+  let l_ac = decodeChannel(lx, ly, l_scale);
+  let p_ac = decodeChannel(3, 3, p_scale * 1.25);
+  let q_ac = decodeChannel(3, 3, q_scale * 1.25);
+  let a_ac = hasAlpha && decodeChannel(5, 5, a_scale);
+  let ratio = thumbHashToApproximateAspectRatio(hash);
+  let w = round(ratio > 1 ? 32 : 32 * ratio);
+  let h = round(ratio > 1 ? 32 / ratio : 32);
+  let rgba = new Uint8Array(w * h * 4), fx = [], fy = [];
+  for (let y = 0, i = 0; y < h; y++) {
+    for (let x = 0; x < w; x++, i += 4) {
+      let l = l_dc, p = p_dc, q = q_dc, a = a_dc;
+      for (let cx = 0, n = max(lx, hasAlpha ? 5 : 3); cx < n; cx++)
+        fx[cx] = cos(PI / w * (x + 0.5) * cx);
+      for (let cy = 0, n = max(ly, hasAlpha ? 5 : 3); cy < n; cy++)
+        fy[cy] = cos(PI / h * (y + 0.5) * cy);
+      for (let cy = 0, j = 0; cy < ly; cy++)
+        for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx * ly < lx * (ly - cy); cx++, j++)
+          l += l_ac[j] * fx[cx] * fy2;
+      for (let cy = 0, j = 0; cy < 3; cy++) {
+        for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx < 3 - cy; cx++, j++) {
+          let f = fx[cx] * fy2;
+          p += p_ac[j] * f;
+          q += q_ac[j] * f;
+        }
+      }
+      if (hasAlpha)
+        for (let cy = 0, j = 0; cy < 5; cy++)
+          for (let cx = cy ? 0 : 1, fy2 = fy[cy] * 2; cx < 5 - cy; cx++, j++)
+            a += a_ac[j] * fx[cx] * fy2;
+      let b = l - 2 / 3 * p;
+      let r = (3 * l - b + q) / 2;
+      let g = r - q;
+      rgba[i] = max(0, 255 * min(1, r));
+      rgba[i + 1] = max(0, 255 * min(1, g));
+      rgba[i + 2] = max(0, 255 * min(1, b));
+      rgba[i + 3] = max(0, 255 * min(1, a));
+    }
+  }
+  return { w, h, rgba };
+}
+function thumbHashToApproximateAspectRatio(hash) {
+  let header = hash[3];
+  let hasAlpha = hash[2] & 128;
+  let isLandscape = hash[4] & 128;
+  let lx = isLandscape ? hasAlpha ? 5 : 7 : header & 7;
+  let ly = isLandscape ? header & 7 : hasAlpha ? 5 : 7;
+  return lx / ly;
+}
+function rgbaToDataURL(w, h, rgba) {
+  let row = w * 4 + 1;
+  let idat = 6 + h * (5 + row);
+  let bytes = [
+    137,
+    80,
+    78,
+    71,
+    13,
+    10,
+    26,
+    10,
+    0,
+    0,
+    0,
+    13,
+    73,
+    72,
+    68,
+    82,
+    0,
+    0,
+    w >> 8,
+    w & 255,
+    0,
+    0,
+    h >> 8,
+    h & 255,
+    8,
+    6,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    idat >>> 24,
+    idat >> 16 & 255,
+    idat >> 8 & 255,
+    idat & 255,
+    73,
+    68,
+    65,
+    84,
+    120,
+    1
+  ];
+  let table = [
+    0,
+    498536548,
+    997073096,
+    651767980,
+    1994146192,
+    1802195444,
+    1303535960,
+    1342533948,
+    -306674912,
+    -267414716,
+    -690576408,
+    -882789492,
+    -1687895376,
+    -2032938284,
+    -1609899400,
+    -1111625188
+  ];
+  let a = 1, b = 0;
+  for (let y = 0, i = 0, end = row - 1; y < h; y++, end += row - 1) {
+    bytes.push(y + 1 < h ? 0 : 1, row & 255, row >> 8, ~row & 255, row >> 8 ^ 255, 0);
+    for (b = (b + a) % 65521; i < end; i++) {
+      let u = rgba[i] & 255;
+      bytes.push(u);
+      a = (a + u) % 65521;
+      b = (b + a) % 65521;
+    }
+  }
+  bytes.push(
+    b >> 8,
+    b & 255,
+    a >> 8,
+    a & 255,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    73,
+    69,
+    78,
+    68,
+    174,
+    66,
+    96,
+    130
+  );
+  for (let [start, end] of [[12, 29], [37, 41 + idat]]) {
+    let c = -1;
+    for (let i = start; i < end; i++) {
+      c ^= bytes[i];
+      c = c >>> 4 ^ table[c & 15];
+      c = c >>> 4 ^ table[c & 15];
+    }
+    c = ~c;
+    bytes[end++] = c >>> 24;
+    bytes[end++] = c >> 16 & 255;
+    bytes[end++] = c >> 8 & 255;
+    bytes[end++] = c & 255;
+  }
+  return "data:image/png;base64," + btoa(String.fromCharCode(...bytes));
+}
+function thumbHashToDataURL(hash) {
+  let image = thumbHashToRGBA(hash);
+  return rgbaToDataURL(image.w, image.h, image.rgba);
+}
+const MAX_DIM = 100;
+async function computeImageMeta(file) {
+  const url = URL.createObjectURL(file);
+  try {
+    const img = await loadImage(url);
+    const { naturalWidth: w, naturalHeight: h } = img;
+    const scale = Math.min(MAX_DIM / w, MAX_DIM / h, 1);
+    const sw = Math.round(w * scale);
+    const sh = Math.round(h * scale);
+    const canvas = document.createElement("canvas");
+    canvas.width = sw;
+    canvas.height = sh;
+    const ctx = canvas.getContext("2d");
+    ctx.drawImage(img, 0, 0, sw, sh);
+    const { data } = ctx.getImageData(0, 0, sw, sh);
+    const hash = rgbaToThumbHash(sw, sh, data);
+    const thumbhash = uint8ToBase64(hash);
+    return { width: w, height: h, thumbhash };
+  } finally {
+    URL.revokeObjectURL(url);
+  }
+}
+function decodeThumbHash(hash) {
+  try {
+    const bytes = base64ToUint8(hash);
+    return thumbHashToDataURL(bytes);
+  } catch {
+    return void 0;
+  }
+}
+function loadImage(src) {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => resolve(img);
+    img.onerror = reject;
+    img.src = src;
+  });
+}
+function uint8ToBase64(bytes) {
+  let bin = "";
+  for (const b of bytes) bin += String.fromCodePoint(b);
+  return btoa(bin);
+}
+function base64ToUint8(str) {
+  const bin = atob(str);
+  const bytes = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) bytes[i] = bin.codePointAt(i);
+  return bytes;
+}
+function ImageRenderer({
+  src,
+  altText,
+  width,
+  height,
+  caption,
+  thumbhash,
+  accent
+}) {
+  const [loaded, setLoaded] = useState(false);
+  const [zoomed, setZoomed] = useState(false);
+  const handleLoad = useCallback(() => setLoaded(true), []);
+  const handleZoomOpen = useCallback(() => {
+    if (!loaded) return;
+    setZoomed(true);
+  }, [loaded]);
+  const handleZoomClose = useCallback(() => setZoomed(false), []);
+  useEffect(() => {
+    if (!zoomed) return;
+    const onKeyDown = (e) => {
+      if (e.key === "Escape") setZoomed(false);
+    };
+    document.addEventListener("keydown", onKeyDown);
+    return () => document.removeEventListener("keydown", onKeyDown);
+  }, [zoomed]);
+  useEffect(() => {
+    if (!zoomed) return;
+    const prev = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    return () => {
+      document.body.style.overflow = prev;
+    };
+  }, [zoomed]);
+  const handleContainerKeyDown = useCallback(
+    (e) => {
+      if ((e.key === "Enter" || e.key === " ") && loaded) {
+        e.preventDefault();
+        setZoomed(true);
+      }
+    },
+    [loaded]
+  );
+  const placeholderUrl = useMemo(
+    () => thumbhash ? decodeThumbHash(thumbhash) : void 0,
+    [thumbhash]
+  );
+  const aspectStyle = width && height ? { aspectRatio: `${width} / ${height}`, maxWidth: "100%", width } : { maxWidth: "100%" };
+  return /* @__PURE__ */ jsxs("figure", { className: "rich-image", children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: `rich-image-container${loaded ? " rich-image-loaded" : ""}`,
+        style: {
+          ...aspectStyle,
+          backgroundColor: !loaded && !placeholderUrl ? accent : void 0,
+          backgroundImage: !loaded && placeholderUrl ? `url(${placeholderUrl})` : void 0,
+          backgroundSize: "cover",
+          cursor: loaded ? "zoom-in" : void 0
+        },
+        onClick: handleZoomOpen,
+        onKeyDown: handleContainerKeyDown,
+        role: "button",
+        tabIndex: loaded ? 0 : -1,
+        "aria-label": loaded ? `Zoom image: ${altText}` : void 0,
+        children: /* @__PURE__ */ jsx(
+          "img",
+          {
+            src,
+            alt: altText,
+            width,
+            height,
+            loading: "lazy",
+            onLoad: handleLoad,
+            style: { maxWidth: "100%", height: "auto" },
+            className: loaded ? "rich-image-visible" : "rich-image-hidden"
+          }
+        )
+      }
+    ),
+    caption && /* @__PURE__ */ jsx("figcaption", { children: caption }),
+    zoomed && /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "rich-image-zoom-overlay",
+        onClick: handleZoomClose,
+        role: "dialog",
+        "aria-modal": "true",
+        "aria-label": `Zoomed image: ${altText}`,
+        tabIndex: 0,
+        children: /* @__PURE__ */ jsx("img", { src, alt: altText, className: "rich-image-zoom-img" })
+      }
+    )
+  ] });
+}
+function sanitizeImageSrc(src) {
+  const trimmed = src.trim();
+  if (/^(javascript\s*:|vbscript\s*:|data\s*:(?!image\/))/i.test(trimmed)) {
+    return "";
+  }
+  return trimmed;
+}
+function sanitizeColor(value) {
+  if (!value) return void 0;
+  const trimmed = value.trim();
+  if (/^#[\da-f]{3,8}$/i.test(trimmed)) return trimmed;
+  if (/^(rgb|hsl)a?\([^)]+\)$/i.test(trimmed)) return trimmed;
+  if (/^[a-z]{3,20}$/i.test(trimmed)) return trimmed;
+  return void 0;
+}
+const _ImageNode = class _ImageNode extends DecoratorNode {
+  constructor(payload, key) {
+    super(key);
+    __publicField(this, "__src");
+    __publicField(this, "__altText");
+    __publicField(this, "__width");
+    __publicField(this, "__height");
+    __publicField(this, "__caption");
+    __publicField(this, "__thumbhash");
+    __publicField(this, "__accent");
+    this.__src = sanitizeImageSrc(payload.src);
+    this.__altText = payload.altText;
+    this.__width = payload.width;
+    this.__height = payload.height;
+    this.__caption = payload.caption;
+    this.__thumbhash = payload.thumbhash;
+    this.__accent = sanitizeColor(payload.accent);
+  }
+  static getType() {
+    return "image";
+  }
+  static clone(node) {
+    return new _ImageNode(
+      {
+        src: node.__src,
+        altText: node.__altText,
+        width: node.__width,
+        height: node.__height,
+        caption: node.__caption,
+        thumbhash: node.__thumbhash,
+        accent: node.__accent
+      },
+      node.__key
+    );
+  }
+  createDOM(_config) {
+    const div = document.createElement("div");
+    div.className = "rich-image-wrapper";
+    return div;
+  }
+  updateDOM() {
+    return false;
+  }
+  isInline() {
+    return false;
+  }
+  static importJSON(serializedNode) {
+    return $createImageNode({
+      src: serializedNode.src,
+      altText: serializedNode.altText,
+      width: serializedNode.width,
+      height: serializedNode.height,
+      caption: serializedNode.caption,
+      thumbhash: serializedNode.thumbhash,
+      accent: serializedNode.accent
+    });
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: "image",
+      src: this.__src,
+      altText: this.__altText,
+      width: this.__width,
+      height: this.__height,
+      caption: this.__caption,
+      thumbhash: this.__thumbhash,
+      accent: this.__accent,
+      version: 1
+    };
+  }
+  decorate(_editor, _config) {
+    return createRendererDecoration("Image", ImageRenderer, {
+      src: this.__src,
+      altText: this.__altText,
+      width: this.__width,
+      height: this.__height,
+      caption: this.__caption,
+      thumbhash: this.__thumbhash,
+      accent: this.__accent
+    });
+  }
+};
+__publicField(_ImageNode, "slashMenuItems", [
+  {
+    title: "Image",
+    icon: createElement(ImageIcon, { size: 20 }),
+    description: "Upload or embed an image",
+    keywords: ["image", "picture", "photo"],
+    section: "MEDIA",
+    onSelect: (editor) => {
+      editor.update(() => {
+        $insertNodes([$createImageNode({ src: "", altText: "" })]);
+      });
+    }
+  }
+]);
+let ImageNode = _ImageNode;
+function $createImageNode(payload) {
+  return new ImageNode(payload);
+}
+const _KaTeXBlockNode = class _KaTeXBlockNode extends DecoratorNode {
+  constructor(equation, key) {
+    super(key);
+    __publicField(this, "__equation");
+    this.__equation = equation;
+  }
+  static getType() {
+    return "katex-block";
+  }
+  static clone(node) {
+    return new _KaTeXBlockNode(node.__equation, node.__key);
+  }
+  createDOM(_config) {
+    const div = document.createElement("div");
+    div.className = "rich-katex-block-wrapper";
+    return div;
+  }
+  updateDOM() {
+    return false;
+  }
+  isInline() {
+    return false;
+  }
+  static importJSON(serializedNode) {
+    return $createKaTeXBlockNode(serializedNode.equation);
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: "katex-block",
+      equation: this.__equation,
+      version: 1
+    };
+  }
+  getEquation() {
+    return this.__equation;
+  }
+  setEquation(equation) {
+    const writable = this.getWritable();
+    writable.__equation = equation;
+  }
+  decorate(_editor, _config) {
+    return createRendererDecoration("KaTeX", KaTeXRenderer, {
+      equation: this.__equation,
+      displayMode: true
+    });
+  }
+};
+__publicField(_KaTeXBlockNode, "slashMenuItems", [
+  {
+    title: "Math Equation",
+    icon: createElement(Sigma, { size: 20 }),
+    description: "KaTeX block formula",
+    keywords: ["math", "equation", "latex", "katex"],
+    section: "ADVANCED",
+    onSelect: (editor) => {
+      editor.update(() => {
+        $insertNodes([$createKaTeXBlockNode("")]);
+      });
+    }
+  }
+]);
+let KaTeXBlockNode = _KaTeXBlockNode;
+function $createKaTeXBlockNode(equation) {
+  return new KaTeXBlockNode(equation);
+}
+function $isKaTeXBlockNode(node) {
+  return node instanceof KaTeXBlockNode;
+}
+function LinkCardRenderer({
+  url,
+  title,
+  description,
+  favicon,
+  image
+}) {
+  const displayTitle = title || url;
+  return /* @__PURE__ */ jsxs(
+    "a",
+    {
+      className: "rich-link-card",
+      href: url,
+      target: "_blank",
+      rel: "noopener noreferrer",
+      children: [
+        image && /* @__PURE__ */ jsx("span", { className: "rich-link-card-image", children: /* @__PURE__ */ jsx("img", { src: image, alt: "", loading: "lazy" }) }),
+        /* @__PURE__ */ jsxs("span", { className: "rich-link-card-content", children: [
+          /* @__PURE__ */ jsxs("span", { className: "rich-link-card-title", children: [
+            favicon && /* @__PURE__ */ jsx(
+              "img",
+              {
+                className: "rich-link-card-favicon",
+                src: favicon,
+                alt: "",
+                width: 16,
+                height: 16,
+                onError: (e) => {
+                  e.target.style.display = "none";
+                }
+              }
+            ),
+            displayTitle
+          ] }),
+          description && /* @__PURE__ */ jsx("span", { className: "rich-link-card-description", children: description }),
+          /* @__PURE__ */ jsx("span", { className: "rich-link-card-url", children: url })
+        ] })
+      ]
+    }
+  );
+}
+const _LinkCardNode = class _LinkCardNode extends DecoratorNode {
+  constructor(payload, key) {
+    super(key);
+    __publicField(this, "__url");
+    __publicField(this, "__source");
+    __publicField(this, "__id");
+    __publicField(this, "__title");
+    __publicField(this, "__description");
+    __publicField(this, "__favicon");
+    __publicField(this, "__image");
+    this.__url = payload.url;
+    this.__source = payload.source;
+    this.__id = payload.id;
+    this.__title = payload.title;
+    this.__description = payload.description;
+    this.__favicon = payload.favicon;
+    this.__image = payload.image;
+  }
+  static getType() {
+    return "link-card";
+  }
+  static clone(node) {
+    return new _LinkCardNode(
+      {
+        url: node.__url,
+        source: node.__source,
+        id: node.__id,
+        title: node.__title,
+        description: node.__description,
+        favicon: node.__favicon,
+        image: node.__image
+      },
+      node.__key
+    );
+  }
+  createDOM(_config) {
+    const div = document.createElement("div");
+    div.className = "rich-link-card-wrapper";
+    return div;
+  }
+  updateDOM() {
+    return false;
+  }
+  isInline() {
+    return false;
+  }
+  static importJSON(serializedNode) {
+    return $createLinkCardNode({
+      url: serializedNode.url,
+      source: serializedNode.source,
+      id: serializedNode.id,
+      title: serializedNode.title,
+      description: serializedNode.description,
+      favicon: serializedNode.favicon,
+      image: serializedNode.image
+    });
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: "link-card",
+      url: this.__url,
+      source: this.__source,
+      id: this.__id,
+      title: this.__title,
+      description: this.__description,
+      favicon: this.__favicon,
+      image: this.__image,
+      version: 1
+    };
+  }
+  getUrl() {
+    return this.getLatest().__url;
+  }
+  setUrl(url) {
+    const writable = this.getWritable();
+    writable.__url = url;
+  }
+  getSource() {
+    return this.getLatest().__source;
+  }
+  setSource(source) {
+    const writable = this.getWritable();
+    writable.__source = source;
+  }
+  getId() {
+    return this.getLatest().__id;
+  }
+  setId(id) {
+    const writable = this.getWritable();
+    writable.__id = id;
+  }
+  decorate(_editor, _config) {
+    return createRendererDecoration("LinkCard", LinkCardRenderer, {
+      url: this.__url,
+      source: this.__source,
+      id: this.__id,
+      title: this.__title,
+      description: this.__description,
+      favicon: this.__favicon,
+      image: this.__image
+    });
+  }
+};
+__publicField(_LinkCardNode, "slashMenuItems", [
+  {
+    title: "Link Card",
+    icon: createElement(Link, { size: 20 }),
+    description: "Link preview card",
+    keywords: ["link", "card", "bookmark", "embed"],
+    section: "MEDIA",
+    onSelect: (editor) => {
+      editor.update(() => {
+        $insertNodes([$createLinkCardNode({ url: "" })]);
+      });
+    }
+  }
+]);
+let LinkCardNode = _LinkCardNode;
+function $createLinkCardNode(payload) {
+  return new LinkCardNode(payload);
+}
+function $isLinkCardNode(node) {
+  return node instanceof LinkCardNode;
+}
+function MermaidRenderer({ content }) {
+  return /* @__PURE__ */ jsx("div", { className: "rich-mermaid-block", children: /* @__PURE__ */ jsx("pre", { children: /* @__PURE__ */ jsx("code", { children: content }) }) });
+}
+const _MermaidNode = class _MermaidNode extends DecoratorNode {
+  constructor(diagram, key) {
+    super(key);
+    __publicField(this, "__diagram");
+    this.__diagram = diagram;
+  }
+  static getType() {
+    return "mermaid";
+  }
+  static clone(node) {
+    return new _MermaidNode(node.__diagram, node.__key);
+  }
+  createDOM(_config) {
+    const div = document.createElement("div");
+    div.className = "rich-mermaid-wrapper";
+    return div;
+  }
+  updateDOM() {
+    return false;
+  }
+  isInline() {
+    return false;
+  }
+  static importJSON(serializedNode) {
+    return $createMermaidNode(serializedNode.diagram);
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: "mermaid",
+      diagram: this.__diagram,
+      version: 1
+    };
+  }
+  getDiagram() {
+    return this.__diagram;
+  }
+  setDiagram(diagram) {
+    const writable = this.getWritable();
+    writable.__diagram = diagram;
+  }
+  decorate(editor, _config) {
+    const nodeKey = this.__key;
+    return createRendererDecoration("Mermaid", MermaidRenderer, {
+      content: this.__diagram,
+      onContentChange: (newDiagram) => {
+        editor.update(() => {
+          const node = $getNodeByKey(nodeKey);
+          if (node) {
+            node.setDiagram(newDiagram);
+          }
+        });
+      }
+    });
+  }
+};
+__publicField(_MermaidNode, "slashMenuItems", [
+  {
+    title: "Mermaid Diagram",
+    icon: createElement(Workflow, { size: 20 }),
+    description: "Flowchart, sequence diagram",
+    keywords: ["mermaid", "diagram", "chart", "flowchart"],
+    section: "MEDIA",
+    onSelect: (editor) => {
+      editor.update(() => {
+        $insertNodes([
+          $createMermaidNode("graph TD\n    A[Start] --> B[End]")
+        ]);
+      });
+    }
+  }
+]);
+let MermaidNode = _MermaidNode;
+function $createMermaidNode(diagram) {
+  return new MermaidNode(diagram);
+}
+function $isMermaidNode(node) {
+  return node instanceof MermaidNode;
+}
+function VideoRenderer({
+  src,
+  poster,
+  width,
+  height
+}) {
+  return /* @__PURE__ */ jsx("figure", { className: "rich-video", children: /* @__PURE__ */ jsx(
+    "video",
+    {
+      src,
+      poster,
+      width,
+      height,
+      controls: true,
+      preload: "metadata",
+      style: { maxWidth: "100%", height: "auto" }
+    }
+  ) });
+}
+const _VideoNode = class _VideoNode extends DecoratorNode {
+  constructor(payload, key) {
+    super(key);
+    __publicField(this, "__src");
+    __publicField(this, "__poster");
+    __publicField(this, "__width");
+    __publicField(this, "__height");
+    this.__src = payload.src;
+    this.__poster = payload.poster;
+    this.__width = payload.width;
+    this.__height = payload.height;
+  }
+  static getType() {
+    return "video";
+  }
+  static clone(node) {
+    return new _VideoNode(
+      {
+        src: node.__src,
+        poster: node.__poster,
+        width: node.__width,
+        height: node.__height
+      },
+      node.__key
+    );
+  }
+  createDOM(_config) {
+    const div = document.createElement("div");
+    div.className = "rich-video-wrapper";
+    return div;
+  }
+  updateDOM() {
+    return false;
+  }
+  isInline() {
+    return false;
+  }
+  static importJSON(serializedNode) {
+    return $createVideoNode({
+      src: serializedNode.src,
+      poster: serializedNode.poster,
+      width: serializedNode.width,
+      height: serializedNode.height
+    });
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: "video",
+      src: this.__src,
+      poster: this.__poster,
+      width: this.__width,
+      height: this.__height,
+      version: 1
+    };
+  }
+  getSrc() {
+    return this.getLatest().__src;
+  }
+  setSrc(src) {
+    const writable = this.getWritable();
+    writable.__src = src;
+  }
+  decorate(_editor, _config) {
+    return createRendererDecoration("Video", VideoRenderer, {
+      src: this.__src,
+      poster: this.__poster,
+      width: this.__width,
+      height: this.__height
+    });
+  }
+};
+__publicField(_VideoNode, "slashMenuItems", [
+  {
+    title: "Video",
+    icon: createElement(Video, { size: 20 }),
+    description: "Embed a video",
+    keywords: ["video", "media", "mp4"],
+    section: "MEDIA",
+    onSelect: (editor) => {
+      editor.update(() => {
+        $insertNodes([$createVideoNode({ src: "" })]);
+      });
+    }
+  }
+]);
+let VideoNode = _VideoNode;
+function $createVideoNode(payload) {
+  return new VideoNode(payload);
+}
+const builtinNodes = [
+  HeadingNode,
+  QuoteNode,
+  ListNode,
+  ListItemNode,
+  LinkNode,
+  AutoLinkNode,
+  HorizontalRuleNode,
+  TableNode,
+  TableCellNode,
+  TableRowNode,
+  CodeNode
+];
+const customNodes = [
+  SpoilerNode,
+  MentionNode,
+  KaTeXInlineNode,
+  KaTeXBlockNode,
+  ImageNode,
+  AlertQuoteNode,
+  CodeBlockNode,
+  FootnoteNode,
+  FootnoteSectionNode,
+  TaskListItemNode,
+  VideoNode,
+  LinkCardNode,
+  DetailsNode,
+  GridContainerNode,
+  BannerNode,
+  MermaidNode
+];
+const allNodes = [
+  ...builtinNodes,
+  ...customNodes
+];
+function FootnotePlugin({ children }) {
+  const [editor] = useLexicalComposerContext();
+  const [definitions, setDefinitions] = useState({});
+  const [displayNumberMap, setDisplayNumberMap] = useState({});
+  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({});
+        }
+      });
+    });
+  }, [editor]);
+  return /* @__PURE__ */ jsx(
+    FootnoteDefinitionsProvider,
+    {
+      definitions,
+      displayNumberMap,
+      children
+    }
+  );
+}
+var articleVariant = "v10dui1 r8uj4t0 _17pm0gw0 v10dui0";
+var darkArticleVariant = "v10dui2 r8uj4t0 _17pm0gw2 v10dui0";
+var commentVariant = "_14ko36c1 r8uj4t0 _17pm0gw1 _14ko36c0";
+var darkCommentVariant = "_14ko36c2 r8uj4t0 _17pm0gw3 _14ko36c0";
+var noteVariant = "ys4fw91 r8uj4t0 _17pm0gw4 ys4fw90";
+var darkNoteVariant = "ys4fw92 r8uj4t0 _17pm0gw5 ys4fw90";
+function clsx(...args) {
+  return args.filter(Boolean).join(" ");
+}
+function getVariantClass(variant, colorScheme) {
+  if (variant === "comment") {
+    return colorScheme === "dark" ? darkCommentVariant : commentVariant;
+  }
+  if (variant === "note") {
+    return colorScheme === "dark" ? darkNoteVariant : noteVariant;
+  }
+  return colorScheme === "dark" ? darkArticleVariant : articleVariant;
+}
+export {
+  $createFootnoteSectionNode as $,
+  ALERT_LABELS as A,
+  BANNER_LABELS as B,
+  ColorSchemeProvider as C,
+  darkArticleVariant as D,
+  darkCommentVariant as E,
+  FootnotePlugin as F,
+  GridContainerNode as G,
+  darkNoteVariant as H,
+  decodeThumbHash as I,
+  noteVariant as J,
+  KaTeXBlockNode as K,
+  LinkCardNode as L,
+  MermaidNode as M,
+  NESTED_EDITOR_NODES as N,
+  useColorScheme as O,
+  PortalThemeProvider as P,
+  useFootnoteContent as Q,
+  RendererConfigProvider as R,
+  useFootnoteDefinitions as S,
+  useFootnoteDisplayNumber as T,
+  useRendererConfig as U,
+  useRendererMode as V,
+  $isAlertQuoteNode as W,
+  RendererWrapper as X,
+  AlertRenderer as Y,
+  AlertQuoteNode as Z,
+  $isBannerNode as _,
+  allNodes as a,
+  BannerRenderer as a0,
+  BannerNode as a1,
+  normalizeBannerType as a2,
+  $isCodeBlockNode as a3,
+  CodeBlockRenderer as a4,
+  CodeBlockNode as a5,
+  SpoilerNode as a6,
+  MentionNode as a7,
+  ImageNode as a8,
+  FootnoteNode as a9,
+  TaskListItemNode as aa,
+  VideoNode as ab,
+  DetailsNode as ac,
+  $createAlertQuoteNode as ad,
+  $createImageNode as ae,
+  $createKaTeXInlineNode as af,
+  $createKaTeXBlockNode as ag,
+  $createBannerNode as ah,
+  $createDetailsNode as ai,
+  $isDetailsNode as aj,
+  $createFootnoteNode as ak,
+  $isFootnoteNode as al,
+  $createMentionNode as am,
+  $isMentionNode as an,
+  $createSpoilerNode as ao,
+  $isSpoilerNode as ap,
+  $createTaskListItemNode as aq,
+  $isTaskListItemNode as ar,
+  builtinNodes as b,
+  customNodes as c,
+  clsx as d,
+  editorTheme as e,
+  $createGridContainerNode as f,
+  getVariantClass as g,
+  $createLinkCardNode as h,
+  $createMermaidNode as i,
+  $isFootnoteSectionNode as j,
+  $isGridContainerNode as k,
+  $isKaTeXBlockNode as l,
+  $isKaTeXInlineNode as m,
+  $isLinkCardNode as n,
+  $isMermaidNode as o,
+  ALERT_TYPES as p,
+  BANNER_TYPES as q,
+  FootnoteDefinitionsProvider as r,
+  FootnoteSectionNode as s,
+  KaTeXInlineNode as t,
+  KaTeXRenderer as u,
+  LinkCardRenderer as v,
+  articleVariant as w,
+  commentVariant as x,
+  computeImageMeta as y,
+  createRendererDecoration as z
+};