composeai 0.1.1

package/dist/index.cjs

@@ -0,0 +1,4750 @@
+'use strict';
+
+var react = require('react');
+var LexicalComposer = require('@lexical/react/LexicalComposer');
+var LexicalComposerContext = require('@lexical/react/LexicalComposerContext');
+var lexical = require('lexical');
+var jsxRuntime = require('react/jsx-runtime');
+var LexicalRichTextPlugin = require('@lexical/react/LexicalRichTextPlugin');
+var LexicalPlainTextPlugin = require('@lexical/react/LexicalPlainTextPlugin');
+var LexicalContentEditable = require('@lexical/react/LexicalContentEditable');
+var LexicalErrorBoundary = require('@lexical/react/LexicalErrorBoundary');
+var LexicalHistoryPlugin = require('@lexical/react/LexicalHistoryPlugin');
+var reactDom = require('react-dom');
+var LexicalTypeaheadMenuPlugin = require('@lexical/react/LexicalTypeaheadMenuPlugin');
+
+// src/Composer.tsx
+function normalize(text) {
+  return text.replace(/\r\n?/g, "\n");
+}
+function $insertTextWithParagraphBreaks(text) {
+  const lines = normalize(text).split("\n");
+  const current = () => {
+    const s = lexical.$getSelection();
+    return lexical.$isRangeSelection(s) ? s : null;
+  };
+  let sel = current();
+  if (!sel) {
+    const root = lexical.$getRoot();
+    const last = root.getLastChild();
+    if (last && "selectEnd" in last && typeof last.selectEnd === "function") {
+      last.selectEnd();
+    } else {
+      root.selectEnd();
+    }
+    sel = current();
+    if (!sel) return;
+  }
+  if (!sel.isCollapsed()) {
+    sel.removeText();
+    sel = current();
+    if (!sel) return;
+  }
+  for (let i = 0; i < lines.length; i++) {
+    if (i > 0) {
+      sel.insertParagraph();
+      sel = current();
+      if (!sel) return;
+    }
+    if (lines[i].length > 0) {
+      sel.insertText(lines[i]);
+      sel = current();
+      if (!sel) return;
+    }
+  }
+}
+function $seedInitialValue(text) {
+  const root = lexical.$getRoot();
+  root.clear();
+  const lines = normalize(text).split("\n");
+  if (lines.length === 0) {
+    const para = lexical.$createParagraphNode();
+    root.append(para);
+    para.selectEnd();
+    return;
+  }
+  let last = null;
+  for (const line of lines) {
+    const para = lexical.$createParagraphNode();
+    if (line.length > 0) para.append(lexical.$createTextNode(line));
+    root.append(para);
+    last = para;
+  }
+  last?.selectEnd();
+}
+
+// src/internal/cn.ts
+function cn(...inputs) {
+  const out = [];
+  walk(inputs, out);
+  return out.join(" ");
+}
+function walk(value, out) {
+  if (!value) return;
+  if (typeof value === "string") {
+    if (value.length > 0) out.push(value);
+    return;
+  }
+  if (typeof value === "number") {
+    out.push(String(value));
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const v of value) walk(v, out);
+    return;
+  }
+  if (typeof value === "object") {
+    for (const key in value) {
+      if (value[key]) out.push(key);
+    }
+  }
+}
+
+// src/internal/color.ts
+var COMPONENT_RE = /^\s*(\d+(?:\.\d+)?)\s+(\d+(?:\.\d+)?)%\s+(\d+(?:\.\d+)?)%\s*$/;
+var HSL_FN_RE = /^\s*hsla?\(\s*(\d+(?:\.\d+)?)(?:deg)?\s*[,\s]\s*(\d+(?:\.\d+)?)%\s*[,\s]\s*(\d+(?:\.\d+)?)%/i;
+var HEX_RE = /^\s*#([0-9a-f]{3}|[0-9a-f]{6})\s*$/i;
+var RGB_FN_RE = /^\s*rgba?\(\s*(\d+(?:\.\d+)?)\s*[,\s]\s*(\d+(?:\.\d+)?)\s*[,\s]\s*(\d+(?:\.\d+)?)/i;
+function parseToHsl(value) {
+  if (typeof value !== "string") return null;
+  const components = value.match(COMPONENT_RE);
+  if (components) {
+    return {
+      h: parseFloat(components[1]),
+      s: parseFloat(components[2]),
+      l: parseFloat(components[3])
+    };
+  }
+  const hslFn = value.match(HSL_FN_RE);
+  if (hslFn) {
+    return {
+      h: parseFloat(hslFn[1]),
+      s: parseFloat(hslFn[2]),
+      l: parseFloat(hslFn[3])
+    };
+  }
+  const hex = value.match(HEX_RE);
+  if (hex) {
+    let h = hex[1];
+    if (h.length === 3) {
+      h = h.split("").map((c) => c + c).join("");
+    }
+    const r = parseInt(h.slice(0, 2), 16) / 255;
+    const g = parseInt(h.slice(2, 4), 16) / 255;
+    const b = parseInt(h.slice(4, 6), 16) / 255;
+    return rgbToHsl(r, g, b);
+  }
+  const rgbFn = value.match(RGB_FN_RE);
+  if (rgbFn) {
+    return rgbToHsl(
+      clamp01(parseFloat(rgbFn[1]) / 255),
+      clamp01(parseFloat(rgbFn[2]) / 255),
+      clamp01(parseFloat(rgbFn[3]) / 255)
+    );
+  }
+  return null;
+}
+function clamp01(n) {
+  return Math.min(1, Math.max(0, n));
+}
+function clampPct(n) {
+  return Math.min(100, Math.max(0, n));
+}
+function rgbToHsl(r, g, b) {
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  let h = 0;
+  let s = 0;
+  if (max !== min) {
+    const d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    switch (max) {
+      case r:
+        h = (g - b) / d + (g < b ? 6 : 0);
+        break;
+      case g:
+        h = (b - r) / d + 2;
+        break;
+      case b:
+        h = (r - g) / d + 4;
+        break;
+    }
+    h /= 6;
+  }
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+}
+function formatHslComponents(triple) {
+  return `${triple.h} ${triple.s}% ${triple.l}%`;
+}
+function deriveColorTokens(value) {
+  const base = parseToHsl(value);
+  if (!base) return null;
+  const isLightBase = base.l >= 50;
+  const primary = formatHslComponents(base);
+  const primaryForeground = formatHslComponents({
+    h: base.h,
+    s: Math.min(base.s, 30),
+    l: isLightBase ? 10 : 98
+  });
+  const accent = formatHslComponents({
+    h: base.h,
+    s: clampPct(Math.min(base.s, 70)),
+    l: 95
+  });
+  const accentForeground = formatHslComponents({
+    h: base.h,
+    s: clampPct(Math.max(base.s, 40)),
+    l: 30
+  });
+  return {
+    primary,
+    primaryForeground,
+    accent,
+    accentForeground,
+    ring: primary
+  };
+}
+
+// src/internal/sx.ts
+var COLOR_TOKENS = {
+  primary: "var(--primary)",
+  "primary-foreground": "var(--primary-foreground)",
+  primaryForeground: "var(--primary-foreground)",
+  accent: "var(--accent)",
+  "accent-foreground": "var(--accent-foreground)",
+  accentForeground: "var(--accent-foreground)",
+  background: "var(--background)",
+  foreground: "var(--foreground)",
+  card: "var(--card)",
+  "card-foreground": "var(--card-foreground)",
+  cardForeground: "var(--card-foreground)",
+  popover: "var(--popover)",
+  "popover-foreground": "var(--popover-foreground)",
+  popoverForeground: "var(--popover-foreground)",
+  muted: "var(--muted)",
+  "muted-foreground": "var(--muted-foreground)",
+  mutedForeground: "var(--muted-foreground)",
+  border: "var(--border)",
+  ring: "var(--ring)",
+  input: "var(--input)",
+  destructive: "var(--destructive)",
+  "destructive-foreground": "var(--destructive-foreground)",
+  destructiveForeground: "var(--destructive-foreground)",
+  success: "var(--success)",
+  "success-foreground": "var(--success-foreground)",
+  successForeground: "var(--success-foreground)",
+  warning: "var(--warning)",
+  "warning-foreground": "var(--warning-foreground)",
+  warningForeground: "var(--warning-foreground)"
+};
+var COLOR_KEYS = /* @__PURE__ */ new Set([
+  "color",
+  "backgroundColor",
+  "borderColor",
+  "borderTopColor",
+  "borderRightColor",
+  "borderBottomColor",
+  "borderLeftColor",
+  "outlineColor",
+  "fill",
+  "stroke",
+  "caretColor",
+  "textDecorationColor"
+]);
+function expandColor(value) {
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  const tokenVar = COLOR_TOKENS[trimmed];
+  if (!tokenVar) return value;
+  return `hsl(${tokenVar})`;
+}
+function resolveSx(value) {
+  if (!value) return void 0;
+  const out = {};
+  for (const key in value) {
+    const raw = value[key];
+    if (raw === void 0) continue;
+    if (key === "bg") {
+      out.backgroundColor = expandColor(raw);
+      continue;
+    }
+    if (COLOR_KEYS.has(key)) {
+      out[key] = expandColor(raw);
+      continue;
+    }
+    out[key] = raw;
+  }
+  return out;
+}
+function slotProps(slot, base, classNames, sx, baseStyle) {
+  const className = cn(base, classNames?.[slot]);
+  const resolved = resolveSx(sx?.[slot]);
+  if (!resolved && !baseStyle) {
+    return { className };
+  }
+  return {
+    className,
+    style: { ...baseStyle, ...resolved }
+  };
+}
+var COLOR_TOKEN_KEYS = [
+  "primary",
+  "primaryForeground",
+  "accent",
+  "accentForeground",
+  "background",
+  "foreground",
+  "card",
+  "cardForeground",
+  "popover",
+  "popoverForeground",
+  "muted",
+  "mutedForeground",
+  "border",
+  "ring",
+  "input",
+  "destructive",
+  "destructiveForeground",
+  "success",
+  "successForeground",
+  "warning",
+  "warningForeground"
+];
+var COLOR_TOKEN_VAR = {
+  primary: "--primary",
+  primaryForeground: "--primary-foreground",
+  accent: "--accent",
+  accentForeground: "--accent-foreground",
+  background: "--background",
+  foreground: "--foreground",
+  card: "--card",
+  cardForeground: "--card-foreground",
+  popover: "--popover",
+  popoverForeground: "--popover-foreground",
+  muted: "--muted",
+  mutedForeground: "--muted-foreground",
+  border: "--border",
+  ring: "--ring",
+  input: "--input",
+  destructive: "--destructive",
+  destructiveForeground: "--destructive-foreground",
+  success: "--success",
+  successForeground: "--success-foreground",
+  warning: "--warning",
+  warningForeground: "--warning-foreground"
+};
+function asLength(value) {
+  return typeof value === "number" ? `${value}px` : value;
+}
+function tokensToStyle(tokens) {
+  if (!tokens) return void 0;
+  const out = {};
+  for (const key of COLOR_TOKEN_KEYS) {
+    const v = tokens[key];
+    if (typeof v === "string" && v.length > 0) {
+      out[COLOR_TOKEN_VAR[key]] = v;
+    }
+  }
+  if (tokens.radius !== void 0) out["--composer-radius"] = asLength(tokens.radius);
+  if (tokens.fontSize !== void 0) out["--composer-font-size"] = asLength(tokens.fontSize);
+  if (tokens.fontFamily !== void 0) out["--composer-font-family"] = tokens.fontFamily;
+  return Object.keys(out).length ? out : void 0;
+}
+function makeIcon(displayName, paths) {
+  const Icon = (props) => /* @__PURE__ */ jsxRuntime.jsx(
+    "svg",
+    {
+      xmlns: "http://www.w3.org/2000/svg",
+      width: "24",
+      height: "24",
+      viewBox: "0 0 24 24",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: 2,
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      "aria-hidden": "true",
+      focusable: "false",
+      ...props,
+      children: paths
+    }
+  );
+  Icon.displayName = displayName;
+  return Icon;
+}
+var IconSend = makeIcon(
+  "IconSend",
+  /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M12 5v14" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "m19 12-7-7-7 7" })
+  ] })
+);
+var IconStop = makeIcon(
+  "IconStop",
+  /* @__PURE__ */ jsxRuntime.jsx("rect", { width: "14", height: "14", x: "5", y: "5", rx: "2" })
+);
+var IconAttach = makeIcon(
+  "IconAttach",
+  /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M13.234 20.252 21 12.3" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "m16 6-8.414 8.586a2 2 0 0 0 0 2.828 2 2 0 0 0 2.828 0l8.414-8.586a4 4 0 0 0 0-5.656 4 4 0 0 0-5.656 0l-8.415 8.585a6 6 0 1 0 8.486 8.486" })
+  ] })
+);
+var IconImage = makeIcon(
+  "IconImage",
+  /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("rect", { width: "18", height: "18", x: "3", y: "3", rx: "2", ry: "2" }),
+    /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "9", cy: "9", r: "2" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21" })
+  ] })
+);
+var IconVoice = makeIcon(
+  "IconVoice",
+  /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M12 2a3 3 0 0 0-3 3v7a3 3 0 0 0 6 0V5a3 3 0 0 0-3-3Z" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M19 10v2a7 7 0 0 1-14 0v-2" }),
+    /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "12", x2: "12", y1: "19", y2: "22" })
+  ] })
+);
+var IconVoiceRecording = makeIcon(
+  "IconVoiceRecording",
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M21 12a9 9 0 1 1-6.219-8.56" })
+);
+var IconWeb = makeIcon(
+  "IconWeb",
+  /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "12", cy: "12", r: "10" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M12 2a14.5 14.5 0 0 0 0 20 14.5 14.5 0 0 0 0-20" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M2 12h20" })
+  ] })
+);
+var IconClose = makeIcon(
+  "IconClose",
+  /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M18 6 6 18" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "m6 6 12 12" })
+  ] })
+);
+var IconZoom = makeIcon(
+  "IconZoom",
+  /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "11", cy: "11", r: "8" }),
+    /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "21", x2: "16.65", y1: "21", y2: "16.65" }),
+    /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "11", x2: "11", y1: "8", y2: "14" }),
+    /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "8", x2: "14", y1: "11", y2: "11" })
+  ] })
+);
+var IconFile = makeIcon(
+  "IconFile",
+  /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M14.5 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7.5L14.5 2z" }),
+    /* @__PURE__ */ jsxRuntime.jsx("polyline", { points: "14 2 14 8 20 8" }),
+    /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "16", x2: "8", y1: "13", y2: "13" }),
+    /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "16", x2: "8", y1: "17", y2: "17" }),
+    /* @__PURE__ */ jsxRuntime.jsx("line", { x1: "10", x2: "8", y1: "9", y2: "9" })
+  ] })
+);
+var IconAudio = makeIcon(
+  "IconAudio",
+  /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M9 18V5l12-2v13" }),
+    /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "6", cy: "18", r: "3" }),
+    /* @__PURE__ */ jsxRuntime.jsx("circle", { cx: "18", cy: "16", r: "3" })
+  ] })
+);
+var IconSparkle = makeIcon(
+  "IconSparkle",
+  /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "m12 3-1.912 5.813a2 2 0 0 1-1.275 1.275L3 12l5.813 1.912a2 2 0 0 1 1.275 1.275L12 21l1.912-5.813a2 2 0 0 1 1.275-1.275L21 12l-5.813-1.912a2 2 0 0 1-1.275-1.275Z" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M5 3v4" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M19 17v4" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M3 5h4" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M17 19h4" })
+  ] })
+);
+var IconSpinner = makeIcon(
+  "IconSpinner",
+  /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M21 12a9 9 0 1 1-6.219-8.56" })
+);
+var IconWarning = makeIcon(
+  "IconWarning",
+  /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3Z" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M12 9v4" }),
+    /* @__PURE__ */ jsxRuntime.jsx("path", { d: "M12 17h.01" })
+  ] })
+);
+var DEFAULT_ICONS = {
+  send: IconSend,
+  stop: IconStop,
+  attach: IconAttach,
+  image: IconImage,
+  voice: IconVoice,
+  voiceRecording: IconVoiceRecording,
+  web: IconWeb,
+  close: IconClose,
+  zoom: IconZoom,
+  file: IconFile,
+  audio: IconAudio,
+  sparkle: IconSparkle,
+  spinner: IconSpinner,
+  warning: IconWarning
+};
+function resolveIcons(overrides) {
+  if (!overrides) return DEFAULT_ICONS;
+  return { ...DEFAULT_ICONS, ...overrides };
+}
+var ComposerContext = react.createContext(null);
+var DEFAULT_FEATURES = {
+  markdown: true,
+  attachments: true,
+  mentions: false,
+  slashCommands: false,
+  voice: true,
+  mermaid: true,
+  web: true,
+  // Off by default — ghost autocomplete is an opt-in input affordance that
+  // only makes sense when the consumer has a curated list of completions.
+  ghostedAutoComplete: false
+};
+var DEFAULT_ATTACHMENTS = {
+  // Show only the generic paperclip by default — its `accept` string already
+  // includes images, so users can still attach photos via the OS dialog.
+  // The dedicated image button is opt-in (`attachments: { image: true }`),
+  // primarily for chat-heavy apps where jumping straight to the mobile
+  // camera-roll picker is a UX win worth the second button.
+  file: true,
+  image: false,
+  accept: "image/*,application/pdf,text/*,audio/*,video/*",
+  // No type-picker popover by default — the paperclip opens the OS file
+  // picker directly. When the consumer supplies a non-empty `types` list,
+  // the paperclip flips into a small dropdown that lets the user pick a
+  // category first, scoping the OS dialog to that type's `accept`.
+  types: [],
+  maxSize: 25 * 1024 * 1024,
+  maxCount: 10
+};
+function normalizeFeatures(features) {
+  if (!features) return DEFAULT_FEATURES;
+  return {
+    markdown: features.markdown ?? DEFAULT_FEATURES.markdown,
+    attachments: features.attachments ?? DEFAULT_FEATURES.attachments,
+    mentions: features.mentions ?? DEFAULT_FEATURES.mentions,
+    slashCommands: features.slashCommands ?? DEFAULT_FEATURES.slashCommands,
+    voice: features.voice ?? DEFAULT_FEATURES.voice,
+    mermaid: features.mermaid ?? DEFAULT_FEATURES.mermaid,
+    web: features.web ?? DEFAULT_FEATURES.web,
+    ghostedAutoComplete: features.ghostedAutoComplete ?? DEFAULT_FEATURES.ghostedAutoComplete
+  };
+}
+function detectKind(file) {
+  if (file.type.startsWith("image/")) return "image";
+  if (file.type.startsWith("audio/")) return "audio";
+  return "file";
+}
+var EMPTY_SLOTS = Object.freeze({});
+function ComposerProvider({
+  features,
+  isStreaming,
+  closeMenusOnOutsideClick = true,
+  attachmentOptions,
+  mode = "markdown",
+  multiline = true,
+  submitOnEnter = true,
+  smartNewline = true,
+  focusShortcut = "mod+/",
+  icons,
+  slots,
+  renderDiagram,
+  dir,
+  classNames,
+  sx,
+  tokenStyle,
+  children
+}) {
+  const resolvedIcons = react.useMemo(() => resolveIcons(icons), [icons]);
+  const normalizedFeatures = react.useMemo(() => normalizeFeatures(features), [features]);
+  const markdownMode = react.useMemo(() => {
+    const md = normalizedFeatures.markdown;
+    if (typeof md === "object" && md.mode) return md.mode;
+    return "hybrid";
+  }, [normalizedFeatures.markdown]);
+  const attachmentsConfig = react.useMemo(() => {
+    if (typeof normalizedFeatures.attachments === "object") {
+      return { ...DEFAULT_ATTACHMENTS, ...normalizedFeatures.attachments };
+    }
+    return DEFAULT_ATTACHMENTS;
+  }, [normalizedFeatures.attachments]);
+  const [attachments, setAttachments] = react.useState([]);
+  const [webEnabled, setWebEnabled] = react.useState(false);
+  const [isDraggingFiles, setIsDraggingFiles] = react.useState(false);
+  const submitSubsRef = react.useRef(/* @__PURE__ */ new Set());
+  const addFilesSubsRef = react.useRef(/* @__PURE__ */ new Set());
+  const runPromptSubsRef = react.useRef(/* @__PURE__ */ new Set());
+  const normalizedAttachmentOptions = react.useMemo(
+    () => ({
+      uploadFirst: !!attachmentOptions?.uploadFirst,
+      onUpload: attachmentOptions?.onUpload,
+      canSendOnlyAttachment: attachmentOptions?.canSendOnlyAttachment ?? true
+    }),
+    [
+      attachmentOptions?.uploadFirst,
+      attachmentOptions?.onUpload,
+      attachmentOptions?.canSendOnlyAttachment
+    ]
+  );
+  const uploadHandlerRef = react.useRef(
+    attachmentOptions?.onUpload
+  );
+  uploadHandlerRef.current = attachmentOptions?.onUpload;
+  const uploadFirstRef = react.useRef(
+    !!attachmentOptions?.uploadFirst
+  );
+  uploadFirstRef.current = !!attachmentOptions?.uploadFirst;
+  const removeAttachment = react.useCallback((id) => {
+    setAttachments((prev) => {
+      const next = prev.filter((a) => a.id !== id);
+      const removed = prev.find((a) => a.id === id);
+      if (removed?.previewUrl) URL.revokeObjectURL(removed.previewUrl);
+      return next;
+    });
+  }, []);
+  const clearAttachments = react.useCallback(() => {
+    setAttachments((prev) => {
+      prev.forEach((a) => a.previewUrl && URL.revokeObjectURL(a.previewUrl));
+      return [];
+    });
+  }, []);
+  const attachmentsCountRef = react.useRef(0);
+  attachmentsCountRef.current = attachments.length;
+  const addFiles = react.useCallback(
+    (files) => {
+      if (files.length === 0) return;
+      const enabled = !!normalizedFeatures.attachments;
+      if (!enabled) return;
+      const accepted = [];
+      let remaining = (attachmentsConfig.maxCount ?? Infinity) - attachmentsCountRef.current;
+      const shouldUpload = uploadFirstRef.current && !!uploadHandlerRef.current;
+      for (const file of files) {
+        if (remaining <= 0) break;
+        if (file.size > (attachmentsConfig.maxSize ?? Infinity)) continue;
+        const kind = detectKind(file);
+        accepted.push({
+          id: `att-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+          kind,
+          name: file.name || `attachment.${kind}`,
+          mimeType: file.type,
+          size: file.size,
+          file,
+          previewUrl: kind === "image" || kind === "audio" ? URL.createObjectURL(file) : void 0,
+          status: shouldUpload ? "uploading" : void 0
+        });
+        remaining -= 1;
+      }
+      if (accepted.length === 0) return;
+      setAttachments((prev) => [...prev, ...accepted]);
+      addFilesSubsRef.current.forEach((cb) => cb(files));
+      if (shouldUpload) {
+        const handler = uploadHandlerRef.current;
+        for (const att of accepted) {
+          Promise.resolve().then(() => handler(att.file)).then((ok) => {
+            setAttachments(
+              (prev) => prev.map(
+                (a) => a.id === att.id ? {
+                  ...a,
+                  status: ok ? "uploaded" : "failed",
+                  error: ok ? void 0 : "Upload failed"
+                } : a
+              )
+            );
+          }).catch((err) => {
+            const message = err instanceof Error ? err.message : String(err ?? "Upload failed");
+            setAttachments(
+              (prev) => prev.map(
+                (a) => a.id === att.id ? { ...a, status: "failed", error: message } : a
+              )
+            );
+          });
+        }
+      }
+    },
+    [
+      attachmentsConfig.maxCount,
+      attachmentsConfig.maxSize,
+      normalizedFeatures.attachments
+    ]
+  );
+  const registerAddFiles = react.useCallback(
+    (cb) => {
+      addFilesSubsRef.current.add(cb);
+      return () => {
+        addFilesSubsRef.current.delete(cb);
+      };
+    },
+    []
+  );
+  const registerSubmit = react.useCallback(
+    (cb) => {
+      submitSubsRef.current.add(cb);
+      return () => {
+        submitSubsRef.current.delete(cb);
+      };
+    },
+    []
+  );
+  const triggerSubmit = react.useCallback(() => {
+    submitSubsRef.current.forEach((cb) => cb());
+  }, []);
+  const registerRunPrompt = react.useCallback((cb) => {
+    runPromptSubsRef.current.add(cb);
+    return () => {
+      runPromptSubsRef.current.delete(cb);
+    };
+  }, []);
+  const runPrompt = react.useCallback((prompt, behavior) => {
+    runPromptSubsRef.current.forEach((cb) => cb(prompt, behavior));
+  }, []);
+  const toggleWeb = react.useCallback(() => setWebEnabled((w) => !w), []);
+  const value = react.useMemo(
+    () => ({
+      features: normalizedFeatures,
+      attachmentsConfig,
+      attachments,
+      addFiles,
+      removeAttachment,
+      clearAttachments,
+      registerAddFiles,
+      registerSubmit,
+      triggerSubmit,
+      registerRunPrompt,
+      runPrompt,
+      webEnabled,
+      toggleWeb,
+      isStreaming: !!isStreaming,
+      isDraggingFiles,
+      setIsDraggingFiles,
+      closeMenusOnOutsideClick,
+      attachmentOptions: normalizedAttachmentOptions,
+      markdownMode,
+      mode,
+      multiline,
+      submitOnEnter,
+      smartNewline,
+      focusShortcut: focusShortcut || null,
+      icons: resolvedIcons,
+      slots: slots ?? EMPTY_SLOTS,
+      renderDiagram,
+      dir,
+      classNames,
+      sx,
+      tokenStyle
+    }),
+    [
+      normalizedFeatures,
+      attachmentsConfig,
+      attachments,
+      addFiles,
+      removeAttachment,
+      clearAttachments,
+      registerAddFiles,
+      registerSubmit,
+      triggerSubmit,
+      registerRunPrompt,
+      runPrompt,
+      webEnabled,
+      toggleWeb,
+      isStreaming,
+      isDraggingFiles,
+      closeMenusOnOutsideClick,
+      normalizedAttachmentOptions,
+      markdownMode,
+      mode,
+      multiline,
+      submitOnEnter,
+      smartNewline,
+      focusShortcut,
+      resolvedIcons,
+      slots,
+      renderDiagram,
+      dir,
+      classNames,
+      sx,
+      tokenStyle
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(ComposerContext.Provider, { value, children });
+}
+function useComposerContext() {
+  const ctx = react.useContext(ComposerContext);
+  if (!ctx) {
+    throw new Error("useComposerContext must be used inside <ComposerProvider>");
+  }
+  return ctx;
+}
+function EditorShell({
+  placeholder,
+  mode,
+  multiline,
+  header,
+  toolbar,
+  sendButton,
+  footer
+}) {
+  const { classNames, sx, dir } = useComposerContext();
+  const isMarkdown = mode === "markdown";
+  const editorClass = multiline ? "composer-editor min-h-[44px] max-h-56 scrollbar-thin overflow-y-auto px-5 py-3.5" : "composer-editor composer-editor--inline h-9 overflow-x-auto overflow-y-hidden whitespace-nowrap px-2 leading-9";
+  const editor = slotProps("editor", editorClass, classNames, sx);
+  const editorResolved = resolveSx(sx?.editor);
+  const placeholderBase = mirrorEditorPadding(editorResolved);
+  const placeholderClass = multiline ? "composer-placeholder pointer-events-none absolute inset-x-0 top-0 select-none px-5 py-3.5 text-[15px] leading-relaxed text-muted-foreground" : "composer-placeholder pointer-events-none absolute inset-y-0 inset-x-0 select-none px-2 text-[15px] leading-9 text-muted-foreground truncate";
+  const placeholderProps = slotProps(
+    "placeholder",
+    placeholderClass,
+    classNames,
+    sx,
+    placeholderBase
+  );
+  const contentEditable = /* @__PURE__ */ jsxRuntime.jsx(LexicalContentEditable.ContentEditable, { ...editor, "aria-label": "Message", spellCheck: true, dir });
+  const placeholderEl = /* @__PURE__ */ jsxRuntime.jsx("div", { ...placeholderProps, dir, children: placeholder });
+  const editorBlock = /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      className: cn(
+        "composer-editor-block relative min-w-0",
+        // Inline: the editor block is the flex child that fills the row.
+        !multiline && "flex-1"
+      ),
+      children: isMarkdown ? /* @__PURE__ */ jsxRuntime.jsx(
+        LexicalRichTextPlugin.RichTextPlugin,
+        {
+          contentEditable,
+          placeholder: placeholderEl,
+          ErrorBoundary: LexicalErrorBoundary.LexicalErrorBoundary
+        }
+      ) : /* @__PURE__ */ jsxRuntime.jsx(
+        LexicalPlainTextPlugin.PlainTextPlugin,
+        {
+          contentEditable,
+          placeholder: placeholderEl,
+          ErrorBoundary: LexicalErrorBoundary.LexicalErrorBoundary
+        }
+      )
+    }
+  );
+  if (!multiline) {
+    return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      header,
+      /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "composer-inline-row flex items-center gap-1 px-2 py-1.5", children: [
+        toolbar && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "composer-inline-toolbar flex shrink-0 items-center", children: toolbar }),
+        editorBlock,
+        sendButton && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "composer-inline-send flex shrink-0 items-center", children: sendButton })
+      ] }),
+      /* @__PURE__ */ jsxRuntime.jsx(LexicalHistoryPlugin.HistoryPlugin, {})
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    header,
+    editorBlock,
+    (toolbar || sendButton) && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center justify-between px-3 pb-2.5", children: [
+      toolbar ?? /* @__PURE__ */ jsxRuntime.jsx("span", {}),
+      sendButton
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(LexicalHistoryPlugin.HistoryPlugin, {}),
+    footer
+  ] });
+}
+var PLACEHOLDER_MIRROR_KEYS = [
+  "padding",
+  "paddingInline",
+  "paddingInlineStart",
+  "paddingInlineEnd",
+  "paddingBlock",
+  "paddingBlockStart",
+  "paddingTop",
+  "paddingLeft",
+  "paddingRight",
+  "fontSize",
+  "fontFamily",
+  "lineHeight",
+  "letterSpacing"
+];
+function mirrorEditorPadding(editorStyle) {
+  if (!editorStyle) return void 0;
+  const out = {};
+  for (const key of PLACEHOLDER_MIRROR_KEYS) {
+    const v = editorStyle[key];
+    if (v !== void 0) out[key] = v;
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+
+// src/core/theme.ts
+var composerTheme = {
+  paragraph: "composer-paragraph",
+  quote: "composer-quote",
+  heading: {
+    h1: "composer-h1",
+    h2: "composer-h2",
+    h3: "composer-h3",
+    h4: "composer-h4",
+    h5: "composer-h5",
+    h6: "composer-h6"
+  },
+  list: {
+    ul: "composer-ul",
+    ol: "composer-ol",
+    listitem: "composer-li",
+    nested: {
+      listitem: "composer-li-nested"
+    }
+  },
+  text: {
+    bold: "composer-bold",
+    italic: "composer-italic",
+    underline: "composer-underline",
+    strikethrough: "composer-strike",
+    underlineStrikethrough: "composer-underline composer-strike",
+    code: "composer-code"
+  },
+  code: "composer-code-block",
+  codeHighlight: {
+    atrule: "composer-token-attr",
+    attr: "composer-token-attr",
+    boolean: "composer-token-property",
+    builtin: "composer-token-selector",
+    cdata: "composer-token-comment",
+    char: "composer-token-selector",
+    class: "composer-token-function",
+    "class-name": "composer-token-function",
+    comment: "composer-token-comment",
+    constant: "composer-token-property",
+    deleted: "composer-token-property",
+    doctype: "composer-token-comment",
+    entity: "composer-token-operator",
+    function: "composer-token-function",
+    important: "composer-token-variable",
+    inserted: "composer-token-selector",
+    keyword: "composer-token-attr",
+    namespace: "composer-token-variable",
+    number: "composer-token-property",
+    operator: "composer-token-operator",
+    prolog: "composer-token-comment",
+    property: "composer-token-property",
+    punctuation: "composer-token-punctuation",
+    regex: "composer-token-variable",
+    selector: "composer-token-selector",
+    string: "composer-token-selector",
+    symbol: "composer-token-property",
+    tag: "composer-token-property",
+    url: "composer-token-operator",
+    variable: "composer-token-variable"
+  },
+  link: "composer-link"
+};
+var MentionNode = class _MentionNode extends lexical.ElementNode {
+  /** Stable identifier supplied by the consumer's MentionItem. */
+  __id;
+  /** Trigger character shown via CSS `::before` (e.g. "@" or "#"). */
+  __prefix;
+  static getType() {
+    return "composeai-mention";
+  }
+  static clone(node) {
+    return new _MentionNode(node.__id, node.__prefix, node.__key);
+  }
+  constructor(id, prefix = "@", key) {
+    super(key);
+    this.__id = id;
+    this.__prefix = prefix;
+  }
+  // ── Stable accessors ────────────────────────────────────────────────
+  getMentionId() {
+    return this.__id;
+  }
+  getMentionPrefix() {
+    return this.__prefix;
+  }
+  /**
+   * The current label text. Reflects user edits — if the user backspaced
+   * "@John Doe" down to "@John", this returns "John".
+   */
+  getMentionLabel() {
+    return this.getTextContent();
+  }
+  // ── Behavior flags ──────────────────────────────────────────────────
+  isInline() {
+    return true;
+  }
+  /**
+   * Returning false makes Lexical auto-remove the element as soon as its
+   * children collection becomes empty. That implements "delete the whole
+   * mention when I remove all the text" with zero plugin code.
+   */
+  canBeEmpty() {
+    return false;
+  }
+  /**
+   * Prevent adjacent text outside the chip from accidentally merging
+   * INTO the chip — typing "x" right after a mention should produce
+   * "@John|x", not "@Johnx".
+   */
+  canInsertTextBefore() {
+    return false;
+  }
+  canInsertTextAfter() {
+    return false;
+  }
+  // ── DOM ─────────────────────────────────────────────────────────────
+  createDOM(_config) {
+    const span = document.createElement("span");
+    span.className = "composer-mention";
+    span.setAttribute("data-mention-id", this.__id);
+    span.setAttribute("data-mention-prefix", this.__prefix);
+    return span;
+  }
+  updateDOM(prev, dom) {
+    if (prev.__id !== this.__id) dom.setAttribute("data-mention-id", this.__id);
+    if (prev.__prefix !== this.__prefix) {
+      dom.setAttribute("data-mention-prefix", this.__prefix);
+    }
+    return false;
+  }
+  exportDOM() {
+    const el = document.createElement("span");
+    el.setAttribute("data-mention-id", this.__id);
+    el.setAttribute("data-mention-prefix", this.__prefix);
+    el.textContent = `${this.__prefix}${this.getTextContent()}`;
+    return { element: el };
+  }
+  static importDOM() {
+    return {
+      span: (node) => {
+        if (!node.hasAttribute("data-mention-id")) return null;
+        return {
+          conversion: () => {
+            const id = node.getAttribute("data-mention-id") ?? "";
+            const prefix = node.getAttribute("data-mention-prefix") ?? "@";
+            const rawText = node.textContent ?? "";
+            const label = rawText.startsWith(prefix) ? rawText.slice(prefix.length) : rawText;
+            const mention = $createMentionNode(id, prefix);
+            if (label) {
+              mention.append(lexical.$createTextNode(label));
+            }
+            return { node: mention };
+          },
+          priority: 1
+        };
+      }
+    };
+  }
+  // ── JSON ────────────────────────────────────────────────────────────
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: _MentionNode.getType(),
+      version: 1,
+      mentionId: this.__id,
+      mentionPrefix: this.__prefix
+    };
+  }
+  static importJSON(json) {
+    return $createMentionNode(json.mentionId, json.mentionPrefix ?? "@");
+  }
+};
+function $createMentionNode(id, prefix = "@") {
+  return lexical.$applyNodeReplacement(new MentionNode(id, prefix));
+}
+function $isMentionNode(node) {
+  return node instanceof MentionNode;
+}
+var TOKEN_CLASS = "composer-md-token";
+var MarkdownTokenNode = class _MarkdownTokenNode extends lexical.TextNode {
+  static getType() {
+    return "composeai-md-token";
+  }
+  static clone(node) {
+    return new _MarkdownTokenNode(node.__text, node.__key);
+  }
+  constructor(text = "", key) {
+    super(text, key);
+  }
+  createDOM(config) {
+    const dom = super.createDOM(config);
+    lexical.addClassNamesToElement(dom, TOKEN_CLASS);
+    return dom;
+  }
+  static importJSON(serializedNode) {
+    return $createMarkdownTokenNode().updateFromJSON(serializedNode);
+  }
+  updateFromJSON(serializedNode) {
+    return super.updateFromJSON(serializedNode);
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: _MarkdownTokenNode.getType(),
+      version: 1
+    };
+  }
+};
+function $createMarkdownTokenNode(text = "") {
+  return lexical.$applyNodeReplacement(new MarkdownTokenNode(text));
+}
+function $isMarkdownTokenNode(node) {
+  return node instanceof MarkdownTokenNode;
+}
+var BlockParagraphNode = class _BlockParagraphNode extends lexical.ParagraphNode {
+  __blockMarker;
+  constructor(key) {
+    super(key);
+    this.__blockMarker = "";
+  }
+  static getType() {
+    return "composeai-block-paragraph";
+  }
+  static clone(node) {
+    const next = new _BlockParagraphNode(node.__key);
+    next.__blockMarker = node.__blockMarker;
+    return next;
+  }
+  static importJSON(serializedNode) {
+    return $createBlockParagraphNode().updateFromJSON(serializedNode);
+  }
+  updateFromJSON(serializedNode) {
+    super.updateFromJSON(serializedNode);
+    const writable = this.getWritable();
+    writable.__blockMarker = serializedNode.blockMarker ?? "";
+    return writable;
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: _BlockParagraphNode.getType(),
+      version: 1,
+      blockMarker: this.getBlockMarker()
+    };
+  }
+  getBlockMarker() {
+    return this.getLatest().__blockMarker;
+  }
+  setBlockMarker(marker) {
+    const writable = this.getWritable();
+    writable.__blockMarker = marker;
+    return writable;
+  }
+  hasBlockMarker() {
+    return this.getLatest().__blockMarker.length > 0;
+  }
+  // Enter inside a block paragraph should start a clean paragraph below —
+  // headings, quotes, lists, fences etc. don't bleed into the next line.
+  insertNewAfter(rangeSelection, restoreSelection = false) {
+    const next = super.insertNewAfter(rangeSelection, restoreSelection);
+    if (next instanceof _BlockParagraphNode) {
+      next.setBlockMarker("");
+    }
+    return next;
+  }
+};
+function $createBlockParagraphNode() {
+  return lexical.$applyNodeReplacement(new BlockParagraphNode());
+}
+function $isBlockParagraphNode(node) {
+  return node instanceof BlockParagraphNode;
+}
+var LINK_CLASS = "composer-link";
+var LinkTextNode = class _LinkTextNode extends lexical.TextNode {
+  __url;
+  constructor(text = "", url = "", key) {
+    super(text, key);
+    this.__url = url;
+  }
+  static getType() {
+    return "composeai-link-text";
+  }
+  static clone(node) {
+    return new _LinkTextNode(node.__text, node.__url, node.__key);
+  }
+  createDOM(config) {
+    const dom = super.createDOM(config);
+    lexical.addClassNamesToElement(dom, LINK_CLASS);
+    if (this.__url) dom.setAttribute("data-url", this.__url);
+    return dom;
+  }
+  updateDOM(prevNode, dom, config) {
+    const updated = super.updateDOM(prevNode, dom, config);
+    if (prevNode.__url !== this.__url) {
+      if (this.__url) dom.setAttribute("data-url", this.__url);
+      else dom.removeAttribute("data-url");
+    }
+    return updated;
+  }
+  static importJSON(serializedNode) {
+    return $createLinkTextNode("", "").updateFromJSON(serializedNode);
+  }
+  updateFromJSON(serializedNode) {
+    super.updateFromJSON(serializedNode);
+    const writable = this.getWritable();
+    writable.__url = serializedNode.url ?? "";
+    return writable;
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: _LinkTextNode.getType(),
+      version: 1,
+      url: this.getUrl()
+    };
+  }
+  getUrl() {
+    return this.getLatest().__url;
+  }
+  setUrl(url) {
+    const writable = this.getWritable();
+    writable.__url = url;
+    return writable;
+  }
+  // Typing at the boundary of the link should NOT extend the link — the
+  // user wants their next char to be plain text, not "part of the link
+  // label". Lexical honours these by creating a new sibling TextNode for
+  // boundary insertions. Internal edits (cursor between chars) still go
+  // into this node, which keeps label editing natural.
+  canInsertTextBefore() {
+    return false;
+  }
+  canInsertTextAfter() {
+    return false;
+  }
+};
+function $createLinkTextNode(text = "", url = "") {
+  return lexical.$applyNodeReplacement(new LinkTextNode(text, url));
+}
+function $isLinkTextNode(node) {
+  return node instanceof LinkTextNode;
+}
+var HEADING_RE = /^(#{1,6}) /;
+var QUOTE_RE = /^> /;
+var BULLET_RE = /^[-*+] /;
+var NUMBERED_RE = /^\d+\. /;
+var HR_RE = /^(?:---|\*\*\*|___)\s*$/;
+var FENCE_OPEN_RE = /^```([A-Za-z0-9_-]*)(?:\s.*)?$/;
+var FENCE_CLOSE_RE = /^```\s*$/;
+var PLAIN = { kind: "paragraph", markerLen: 0 };
+function detectFromMarker(marker) {
+  if (marker.length === 0) return null;
+  if (FENCE_OPEN_RE.test(marker)) {
+    const m = marker.match(FENCE_OPEN_RE);
+    return {
+      kind: "code-fence-open",
+      markerLen: 0,
+      lang: m && m[1] || void 0
+    };
+  }
+  if (FENCE_CLOSE_RE.test(marker)) {
+    return { kind: "code-fence-close", markerLen: 0 };
+  }
+  const probed = detectBlock(`${marker}x`, false);
+  if (probed.kind === "paragraph") return null;
+  return { ...probed, markerLen: 0 };
+}
+function detectBlock(text, insideCode) {
+  if (insideCode) {
+    if (FENCE_CLOSE_RE.test(text)) {
+      return { kind: "code-fence-close", markerLen: 0 };
+    }
+    return { kind: "code-line", markerLen: 0 };
+  }
+  const openMatch = text.match(FENCE_OPEN_RE);
+  if (openMatch) {
+    return { kind: "code-fence-open", markerLen: 0, lang: openMatch[1] || void 0 };
+  }
+  if (text.length === 0) return PLAIN;
+  const h = text.match(HEADING_RE);
+  if (h) {
+    const level = h[1].length;
+    return { kind: `heading-${level}`, markerLen: h[0].length };
+  }
+  if (QUOTE_RE.test(text)) {
+    return { kind: "quote", markerLen: 2 };
+  }
+  if (BULLET_RE.test(text)) {
+    return { kind: "list-bullet", markerLen: 2 };
+  }
+  const num = text.match(NUMBERED_RE);
+  if (num) {
+    return { kind: "list-numbered", markerLen: num[0].length };
+  }
+  if (HR_RE.test(text)) {
+    return { kind: "hr", markerLen: 0 };
+  }
+  return PLAIN;
+}
+function $resolveBlockFor(paragraph, insideCode) {
+  if ($isBlockParagraphNode(paragraph) && paragraph.hasBlockMarker()) {
+    const fromMarker = detectFromMarker(paragraph.getBlockMarker());
+    if (fromMarker !== null) {
+      if (insideCode && fromMarker.kind !== "code-fence-close") {
+        return { kind: "code-line", markerLen: 0 };
+      }
+      return fromMarker;
+    }
+  }
+  return detectBlock(paragraph.getTextContent(), insideCode);
+}
+function $computeBlockMap() {
+  const map = /* @__PURE__ */ new Map();
+  const root = lexical.$getRoot();
+  let insideCode = false;
+  for (const child of root.getChildren()) {
+    if (!lexical.$isParagraphNode(child)) continue;
+    const info = $resolveBlockFor(child, insideCode);
+    map.set(child.getKey(), info);
+    if (info.kind === "code-fence-open") insideCode = true;
+    else if (info.kind === "code-fence-close") insideCode = false;
+  }
+  return map;
+}
+function $isParagraphInsideCodeFence(paragraph) {
+  const root = paragraph.getParent();
+  if (!root) return false;
+  let inside = false;
+  for (const child of root.getChildren()) {
+    if (child === paragraph) return inside;
+    if (!lexical.$isParagraphNode(child)) continue;
+    if ($isBlockParagraphNode(child) && child.hasBlockMarker()) {
+      const marker = child.getBlockMarker();
+      if (inside) {
+        if (FENCE_CLOSE_RE.test(marker)) inside = false;
+      } else {
+        if (FENCE_OPEN_RE.test(marker)) inside = true;
+      }
+      continue;
+    }
+    const text = child.getTextContent();
+    if (inside) {
+      if (FENCE_CLOSE_RE.test(text)) inside = false;
+    } else {
+      if (FENCE_OPEN_RE.test(text)) inside = true;
+    }
+  }
+  return inside;
+}
+function $detectBlockFor(paragraph) {
+  const inside = $isParagraphInsideCodeFence(paragraph);
+  return $resolveBlockFor(paragraph, inside);
+}
+
+// src/core/serializer.ts
+function collectPlainAndMentions(editor) {
+  return editor.getEditorState().read(() => {
+    const root = lexical.$getRoot();
+    const mentions = [];
+    const walkInline = (parent) => {
+      if (!lexical.$isElementNode(parent)) return "";
+      let out = "";
+      for (const child of parent.getChildren()) {
+        if ($isMentionNode(child)) {
+          const label = child.getMentionLabel();
+          mentions.push({
+            id: child.getMentionId(),
+            label
+          });
+          out += `${child.getMentionPrefix()}${label}`;
+          continue;
+        }
+        if ($isMarkdownTokenNode(child)) continue;
+        if (lexical.$isLineBreakNode(child)) {
+          out += "\n";
+          continue;
+        }
+        if (lexical.$isTextNode(child)) {
+          out += child.getTextContent();
+          continue;
+        }
+        if (lexical.$isElementNode(child)) {
+          out += walkInline(child);
+        }
+      }
+      return out;
+    };
+    const blocks = [];
+    for (const child of root.getChildren()) {
+      if (lexical.$isElementNode(child)) {
+        blocks.push(walkInline(child));
+      } else if (lexical.$isTextNode(child)) {
+        blocks.push(child.getTextContent());
+      }
+    }
+    return { text: blocks.join("\n").replace(/\n+$/g, ""), mentions };
+  });
+}
+var FORMAT_BIT = {
+  bold: 1,
+  italic: 2,
+  strike: 4,
+  // underline (8) — no widely-supported markdown syntax; we drop it on
+  // serialize rather than invent one.
+  code: 16
+};
+function wrapByFormat(text, format) {
+  if (!text) return text;
+  let out = text;
+  if (format & FORMAT_BIT.code) out = `\`${out}\``;
+  if (format & FORMAT_BIT.bold) out = `**${out}**`;
+  if (format & FORMAT_BIT.italic) out = `*${out}*`;
+  if (format & FORMAT_BIT.strike) out = `~~${out}~~`;
+  return out;
+}
+function toMarkdown(editor) {
+  return editor.getEditorState().read(() => {
+    const root = lexical.$getRoot();
+    let usingLive = true;
+    const scan = (node) => {
+      if ($isMarkdownTokenNode(node)) {
+        const prev = node.getPreviousSibling();
+        if (prev !== null) usingLive = false;
+      } else if (lexical.$isElementNode(node)) {
+        for (const child of node.getChildren()) {
+          if (!usingLive) return;
+          scan(child);
+        }
+      }
+    };
+    for (const child of root.getChildren()) {
+      if (!usingLive) break;
+      scan(child);
+    }
+    const lines = [];
+    const serializeParagraph = (paragraph) => {
+      if (!lexical.$isElementNode(paragraph)) return "";
+      let out = "";
+      for (const child of paragraph.getChildren()) {
+        if ($isMentionNode(child)) {
+          out += `${child.getMentionPrefix()}${child.getMentionLabel()}`;
+          continue;
+        }
+        if (lexical.$isLineBreakNode(child)) {
+          out += "\n";
+          continue;
+        }
+        if ($isMarkdownTokenNode(child)) {
+          out += child.getTextContent();
+          continue;
+        }
+        if ($isLinkTextNode(child)) {
+          const label = child.getTextContent();
+          const url = child.getUrl();
+          out += url ? `[${label}](${url})` : label;
+          continue;
+        }
+        if (lexical.$isTextNode(child)) {
+          const text = child.getTextContent();
+          if (usingLive) {
+            out += wrapByFormat(text, child.getFormat());
+          } else {
+            out += text;
+          }
+          continue;
+        }
+        if (lexical.$isElementNode(child)) {
+          out += serializeParagraph(child);
+        }
+      }
+      return out;
+    };
+    for (const child of root.getChildren()) {
+      if (lexical.$isParagraphNode(child)) {
+        const body = serializeParagraph(child);
+        if ($isBlockParagraphNode(child) && child.hasBlockMarker()) {
+          lines.push(child.getBlockMarker() + body);
+        } else {
+          lines.push(body);
+        }
+      } else if (lexical.$isTextNode(child)) {
+        lines.push(child.getTextContent());
+      }
+    }
+    return joinWithCommonMarkSpacing(lines).trim();
+  });
+}
+function isLazyContinuationBlock(kind) {
+  return kind === "list-bullet" || kind === "list-numbered" || kind === "quote";
+}
+function joinWithCommonMarkSpacing(lines) {
+  if (lines.length === 0) return "";
+  let insideCode = false;
+  const blocks = lines.map((line) => {
+    const info = detectBlock(line, insideCode);
+    if (info.kind === "code-fence-open") insideCode = true;
+    else if (info.kind === "code-fence-close") insideCode = false;
+    return info;
+  });
+  let out = lines[0];
+  for (let i = 1; i < lines.length; i++) {
+    const prev = blocks[i - 1];
+    const next = blocks[i];
+    const nextText = lines[i];
+    const needsBlankSeparator = isLazyContinuationBlock(prev.kind) && next.kind === "paragraph" && nextText.length > 0;
+    out += needsBlankSeparator ? "\n\n" : "\n";
+    out += nextText;
+  }
+  return out;
+}
+function $isInsideCodeFence() {
+  const selection = lexical.$getSelection();
+  if (!lexical.$isRangeSelection(selection)) return false;
+  const anchorNode = selection.anchor.getNode();
+  const top = anchorNode.getTopLevelElement();
+  if (!top || !lexical.$isParagraphNode(top)) return false;
+  const block = $detectBlockFor(top);
+  return block.kind === "code-line" || block.kind === "code-fence-open";
+}
+function $hasMultiLineContent() {
+  const root = lexical.$getRoot();
+  if (root.getChildrenSize() > 1) return true;
+  return root.getTextContent().includes("\n");
+}
+function $offsetWithinParagraph(paragraph, point) {
+  if (point.type === "element") {
+    const children = paragraph.getChildren();
+    let offset2 = 0;
+    const limit = Math.min(point.offset, children.length);
+    for (let i = 0; i < limit; i++) {
+      offset2 += children[i].getTextContentSize();
+    }
+    return offset2;
+  }
+  const anchorKey = point.getNode().getKey();
+  let offset = 0;
+  for (const child of paragraph.getChildren()) {
+    if (child.getKey() === anchorKey) return offset + point.offset;
+    offset += child.getTextContentSize();
+  }
+  return offset + point.offset;
+}
+function $handleListContinuation() {
+  const selection = lexical.$getSelection();
+  if (!lexical.$isRangeSelection(selection)) return false;
+  if (!selection.isCollapsed()) return false;
+  const anchorNode = selection.anchor.getNode();
+  const top = anchorNode.getTopLevelElement();
+  if (!top || !lexical.$isParagraphNode(top)) return false;
+  const block = $detectBlockFor(top);
+  if (block.kind !== "list-bullet" && block.kind !== "list-numbered") {
+    return false;
+  }
+  const text = top.getTextContent();
+  const contentAfterMarker = text.slice(block.markerLen);
+  const cursorOffset = $offsetWithinParagraph(top, selection.anchor);
+  if (cursorOffset < block.markerLen) return false;
+  if (contentAfterMarker.length === 0) {
+    top.clear();
+    top.select(0, 0);
+    return true;
+  }
+  let nextMarker;
+  if (block.kind === "list-bullet") {
+    const ch = text.charAt(0) || "-";
+    nextMarker = `${ch} `;
+  } else {
+    const numMatch = text.match(/^(\d+)/);
+    const n = numMatch ? parseInt(numMatch[1], 10) + 1 : 2;
+    nextMarker = `${n}. `;
+  }
+  selection.insertParagraph();
+  const newSelection = lexical.$getSelection();
+  if (lexical.$isRangeSelection(newSelection)) {
+    newSelection.insertText(nextMarker);
+  }
+  return true;
+}
+function KeyboardPlugin({ onSubmit }) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const {
+    triggerSubmit,
+    multiline,
+    submitOnEnter,
+    smartNewline,
+    mode
+  } = useComposerContext();
+  react.useEffect(() => {
+    const trySubmit = (event) => {
+      event.preventDefault();
+      triggerSubmit();
+      onSubmit();
+      return true;
+    };
+    return editor.registerCommand(
+      lexical.KEY_ENTER_COMMAND,
+      (event) => {
+        if (!event) return false;
+        if (document.querySelector('[data-composer-popover="open"]')) {
+          return false;
+        }
+        const isModEnter = event.metaKey || event.ctrlKey;
+        const isShiftEnter = event.shiftKey;
+        if (isModEnter) return trySubmit(event);
+        if (isShiftEnter) {
+          if (!multiline) {
+            event.preventDefault();
+            return true;
+          }
+          const selection = lexical.$getSelection();
+          if (!lexical.$isRangeSelection(selection)) return false;
+          selection.insertParagraph();
+          event.preventDefault();
+          return true;
+        }
+        let inCodeFence = false;
+        let hasMultiLine = false;
+        editor.getEditorState().read(() => {
+          inCodeFence = $isInsideCodeFence();
+          hasMultiLine = $hasMultiLineContent();
+        });
+        if (inCodeFence) {
+          if (!multiline) {
+            event.preventDefault();
+            return true;
+          }
+          return false;
+        }
+        if (!multiline) {
+          if (!submitOnEnter) {
+            event.preventDefault();
+            return true;
+          }
+          return trySubmit(event);
+        }
+        if (smartNewline && mode === "markdown") {
+          if ($handleListContinuation()) {
+            event.preventDefault();
+            return true;
+          }
+        }
+        if (smartNewline && hasMultiLine) return false;
+        if (!submitOnEnter) return false;
+        return trySubmit(event);
+      },
+      lexical.COMMAND_PRIORITY_HIGH
+    );
+  }, [
+    editor,
+    onSubmit,
+    triggerSubmit,
+    multiline,
+    submitOnEnter,
+    smartNewline,
+    mode
+  ]);
+  return null;
+}
+
+// src/internal/focusEditor.ts
+function focusEditor(editor) {
+  editor.focus(
+    () => {
+      const active = document.activeElement;
+      const root = editor.getRootElement();
+      if (root !== null && (active === null || !root.contains(active))) {
+        root.focus({ preventScroll: true });
+      }
+    },
+    { defaultSelection: "rootEnd" }
+  );
+}
+
+// src/plugins/AutoFocusPlugin.tsx
+function AutoFocusPlugin({ enabled }) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  react.useEffect(() => {
+    if (!enabled) return;
+    focusEditor(editor);
+  }, [editor, enabled]);
+  return null;
+}
+function PasteDropPlugin() {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const { addFiles, features, multiline, setIsDraggingFiles } = useComposerContext();
+  react.useEffect(() => {
+    return editor.registerCommand(
+      lexical.PASTE_COMMAND,
+      (event) => {
+        if (!(event instanceof ClipboardEvent)) return false;
+        const clipboard = event.clipboardData;
+        if (!clipboard) return false;
+        if (features.attachments) {
+          const files = [];
+          for (const item of clipboard.items) {
+            if (item.kind === "file") {
+              const file = item.getAsFile();
+              if (file) files.push(file);
+            }
+          }
+          if (files.length > 0) {
+            event.preventDefault();
+            addFiles(files);
+            return true;
+          }
+        }
+        const text = clipboard.getData("text/plain");
+        if (!text) return false;
+        if (!multiline) {
+          if (!text.includes("\n") && !text.includes("\r")) return false;
+          event.preventDefault();
+          const flat = text.replace(/\r\n?|\n/g, " ").replace(/\s+/g, " ");
+          editor.update(() => {
+            $insertTextWithParagraphBreaks(flat);
+          });
+          return true;
+        }
+        if (!text.includes("\n")) return false;
+        event.preventDefault();
+        editor.update(() => {
+          $insertTextWithParagraphBreaks(text);
+        });
+        return true;
+      },
+      lexical.COMMAND_PRIORITY_HIGH
+    );
+  }, [editor, features.attachments, multiline, addFiles]);
+  react.useEffect(() => {
+    if (!features.attachments) return;
+    const root = editor.getRootElement();
+    if (!root) return;
+    let dragDepth = 0;
+    const onDragEnter = (event) => {
+      if (!event.dataTransfer?.types.includes("Files")) return;
+      dragDepth += 1;
+      setIsDraggingFiles(true);
+    };
+    const onDragOver = (event) => {
+      if (event.dataTransfer?.types.includes("Files")) {
+        event.preventDefault();
+        if (event.dataTransfer) event.dataTransfer.dropEffect = "copy";
+      }
+    };
+    const onDragLeave = (event) => {
+      if (!event.dataTransfer?.types.includes("Files")) return;
+      dragDepth = Math.max(0, dragDepth - 1);
+      if (dragDepth === 0) setIsDraggingFiles(false);
+    };
+    const onDrop = (event) => {
+      dragDepth = 0;
+      setIsDraggingFiles(false);
+      const files = event.dataTransfer?.files;
+      if (files && files.length > 0) {
+        event.preventDefault();
+        addFiles(Array.from(files));
+      }
+    };
+    root.addEventListener("dragenter", onDragEnter);
+    root.addEventListener("dragover", onDragOver);
+    root.addEventListener("dragleave", onDragLeave);
+    root.addEventListener("drop", onDrop);
+    return () => {
+      root.removeEventListener("dragenter", onDragEnter);
+      root.removeEventListener("dragover", onDragOver);
+      root.removeEventListener("dragleave", onDragLeave);
+      root.removeEventListener("drop", onDrop);
+    };
+  }, [editor, addFiles, features.attachments, setIsDraggingFiles]);
+  return null;
+}
+
+// src/plugins/markdown-tokenizer.ts
+var PAIRED_PATTERNS = [
+  { open: "**", close: "**", format: "bold" },
+  { open: "__", close: "__", format: "bold" },
+  { open: "~~", close: "~~", format: "strike" },
+  { open: "`", close: "`", format: "code" },
+  { open: "*", close: "*", format: "italic" },
+  { open: "_", close: "_", format: "italic" },
+  { open: "~", close: "~", format: "strike" }
+  // Slack-style strike
+];
+var LINK_RE = /^(!?)\[([^\]\n]+)\]\(([^)\n\s]+)\)/;
+function isInvalidInner(inner) {
+  if (inner.length === 0) return true;
+  if (/\n/.test(inner)) return true;
+  if (/^\s|\s$/.test(inner)) return true;
+  return false;
+}
+function tokenize(text) {
+  const tokens = [];
+  let i = 0;
+  let buf = "";
+  const flushBuf = () => {
+    if (buf.length > 0) {
+      tokens.push({ type: "text", text: buf });
+      buf = "";
+    }
+  };
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "[" || ch === "!" && text[i + 1] === "[") {
+      const m = text.slice(i).match(LINK_RE);
+      if (m) {
+        const [whole, bang, label, url] = m;
+        flushBuf();
+        if (bang) {
+          tokens.push({ type: "marker", text: "!", format: "link" });
+        }
+        tokens.push({ type: "marker", text: "[", format: "link" });
+        tokens.push({ type: "formatted", text: label, format: "link" });
+        tokens.push({ type: "marker", text: "](", format: "link" });
+        tokens.push({ type: "formatted", text: url, format: "code" });
+        tokens.push({ type: "marker", text: ")", format: "link" });
+        i += whole.length;
+        continue;
+      }
+    }
+    let matched = false;
+    for (const pat of PAIRED_PATTERNS) {
+      if (!text.startsWith(pat.open, i)) continue;
+      const searchStart = i + pat.open.length;
+      let endIdx = -1;
+      let probe = searchStart;
+      while (probe < text.length) {
+        const candidate = text.indexOf(pat.close, probe);
+        if (candidate === -1) break;
+        if (pat.open.length === 1) {
+          const prev = text[candidate - 1];
+          const next = text[candidate + 1];
+          if (prev === pat.close || next === pat.close) {
+            probe = candidate + 1;
+            continue;
+          }
+        }
+        endIdx = candidate;
+        break;
+      }
+      if (endIdx === -1) continue;
+      const inner = text.slice(searchStart, endIdx);
+      if (isInvalidInner(inner)) continue;
+      if (pat.open.length === 1) {
+        if (text[i + 1] === pat.open[0]) continue;
+        if (text[i - 1] === pat.open[0]) continue;
+      }
+      flushBuf();
+      tokens.push({ type: "marker", text: pat.open, format: pat.format });
+      tokens.push({ type: "formatted", text: inner, format: pat.format });
+      tokens.push({ type: "marker", text: pat.close, format: pat.format });
+      i = endIdx + pat.close.length;
+      matched = true;
+      break;
+    }
+    if (matched) continue;
+    buf += text[i];
+    i += 1;
+  }
+  flushBuf();
+  return tokens;
+}
+
+// src/plugins/MarkdownPlugin.tsx
+var FORMAT_FLAGS = {
+  bold: 1,
+  italic: 2,
+  strike: 4,
+  underline: 8,
+  code: 16,
+  link: 0
+};
+function readCurrentChildren(paragraph) {
+  const out = [];
+  for (const child of paragraph.getChildren()) {
+    if ($isLinkTextNode(child)) {
+      out.push({
+        kind: "link",
+        text: child.getTextContent(),
+        format: child.getFormat(),
+        url: child.getUrl()
+      });
+    } else if ($isMarkdownTokenNode(child)) {
+      out.push({ kind: "token", text: child.getTextContent(), format: 0 });
+    } else if (lexical.$isTextNode(child)) {
+      out.push({
+        kind: "text",
+        text: child.getTextContent(),
+        format: child.getFormat()
+      });
+    } else {
+      return null;
+    }
+  }
+  return out;
+}
+function nodesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const ai = a[i];
+    const bi = b[i];
+    const aKind = ai.kind === "link" ? "text" : ai.kind;
+    const bKind = bi.kind === "link" ? "text" : bi.kind;
+    if (aKind !== bKind) return false;
+    if (ai.text !== bi.text) return false;
+    if (ai.format !== bi.format) return false;
+  }
+  return true;
+}
+function getSelectionOffsetWithin(paragraph) {
+  const selection = lexical.$getSelection();
+  if (!lexical.$isRangeSelection(selection)) return null;
+  const measure = (key, offset) => {
+    let acc = 0;
+    for (const child of paragraph.getChildren()) {
+      if (child.getKey() === key) return acc + offset;
+      acc += child.getTextContentSize();
+    }
+    return null;
+  };
+  const measureNodeOffset = (key, offset) => {
+    if (paragraph.getKey() === key) {
+      let acc = 0;
+      const children = paragraph.getChildren();
+      for (let i = 0; i < Math.min(offset, children.length); i++) {
+        acc += children[i].getTextContentSize();
+      }
+      return acc;
+    }
+    return measure(key, offset);
+  };
+  const a = measureNodeOffset(selection.anchor.key, selection.anchor.offset);
+  const f = measureNodeOffset(selection.focus.key, selection.focus.offset);
+  if (a === null || f === null) return null;
+  return { anchor: a, focus: f };
+}
+function setSelectionFromOffsets(paragraph, offsets) {
+  const locate = (target) => {
+    const children = paragraph.getChildren();
+    if (children.length === 0) {
+      return { key: paragraph.getKey(), offset: 0, type: "element" };
+    }
+    let acc = 0;
+    for (const child of children) {
+      const size = child.getTextContentSize();
+      if (target <= acc + size) {
+        return {
+          key: child.getKey(),
+          offset: Math.max(0, target - acc),
+          type: "text"
+        };
+      }
+      acc += size;
+    }
+    const last = children[children.length - 1];
+    return {
+      key: last.getKey(),
+      offset: last.getTextContentSize(),
+      type: "text"
+    };
+  };
+  const a = locate(offsets.anchor);
+  const f = locate(offsets.focus);
+  if (!a || !f) return;
+  const selection = lexical.$getSelection();
+  if (!lexical.$isRangeSelection(selection)) return;
+  selection.anchor.set(a.key, a.offset, a.type);
+  selection.focus.set(f.key, f.offset, f.type);
+}
+function isCodeKind(kind) {
+  return kind === "code-line" || kind === "code-fence-open" || kind === "code-fence-close";
+}
+function buildCurrentFormatMap(paragraph) {
+  const out = [];
+  for (const child of paragraph.getChildren()) {
+    if (!lexical.$isTextNode(child)) continue;
+    const text = child.getTextContent();
+    const fmt = $isMarkdownTokenNode(child) ? 0 : child.getFormat();
+    for (let i = 0; i < text.length; i++) out.push(fmt);
+  }
+  return out;
+}
+function buildKeptMask(tokens) {
+  const mask = new Array(tokens.length);
+  for (let i = 0; i < tokens.length; i++) {
+    mask[i] = tokens[i].type !== "marker";
+  }
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t.type !== "marker") continue;
+    if (t.text !== "[" && t.text !== "!") continue;
+    const offset = t.text === "!" ? 1 : 0;
+    const open = tokens[i + offset];
+    const label = tokens[i + offset + 1];
+    const mid = tokens[i + offset + 2];
+    const url = tokens[i + offset + 3];
+    const close = tokens[i + offset + 4];
+    if (open?.type === "marker" && open.text === "[" && label?.type === "formatted" && label.format === "link" && mid?.type === "marker" && mid.text === "](" && url?.type === "formatted" && close?.type === "marker" && close.text === ")") {
+      mask[i + offset + 3] = false;
+    }
+  }
+  return mask;
+}
+function buildLiveOffsetMap(text, leadingDrop, tokens, trailingDrop = 0) {
+  const kept = new Array(text.length + 1);
+  kept[0] = 0;
+  let cursor = 0;
+  for (let i = 0; i < leadingDrop && cursor < text.length; i++) {
+    kept[cursor + 1] = kept[cursor];
+    cursor++;
+  }
+  if (tokens) {
+    const mask = buildKeptMask(tokens);
+    for (let ti = 0; ti < tokens.length; ti++) {
+      const t = tokens[ti];
+      const isKept = mask[ti];
+      for (let i = 0; i < t.text.length && cursor < text.length; i++) {
+        kept[cursor + 1] = kept[cursor] + (isKept ? 1 : 0);
+        cursor++;
+      }
+    }
+  }
+  const trailDropStart = text.length - trailingDrop;
+  for (; cursor < text.length; cursor++) {
+    const dropped = cursor >= trailDropStart;
+    kept[cursor + 1] = kept[cursor] + (dropped ? 0 : 1);
+  }
+  return (srcOffset) => kept[Math.max(0, Math.min(srcOffset, text.length))];
+}
+function $applyStyling(paragraph, block, mode) {
+  const text = paragraph.getTextContent();
+  const current = readCurrentChildren(paragraph);
+  if (current === null) return false;
+  const desired = [];
+  const isLive = mode === "live";
+  const currentFmt = isLive ? buildCurrentFormatMap(paragraph) : null;
+  const stashedNow = $isBlockParagraphNode(paragraph) ? paragraph.getBlockMarker() : "";
+  let body = text;
+  let stashedMarkerForOffsetMap = "";
+  let hybridPromoteShift = 0;
+  if (block.markerLen > 0 && text.length >= block.markerLen) {
+    const marker = text.slice(0, block.markerLen);
+    if (isLive) {
+      if (stashedNow !== marker && $isBlockParagraphNode(paragraph)) {
+        paragraph.setBlockMarker(marker);
+      }
+      stashedMarkerForOffsetMap = marker;
+      body = text.slice(marker.length);
+    } else {
+      desired.push({ kind: "token", text: marker, format: 0 });
+      body = text.slice(marker.length);
+      if (stashedNow.length > 0 && $isBlockParagraphNode(paragraph)) {
+        paragraph.setBlockMarker("");
+      }
+    }
+  } else if (!isLive && stashedNow.length > 0) {
+    desired.push({ kind: "token", text: stashedNow, format: 0 });
+    hybridPromoteShift = stashedNow.length;
+    if ($isBlockParagraphNode(paragraph)) {
+      paragraph.setBlockMarker("");
+    }
+  }
+  let srcPos = block.markerLen;
+  let inlineTokens = null;
+  let trailingDropForOffsetMap = 0;
+  if (isCodeKind(block.kind)) {
+    if (isLive && (block.kind === "code-fence-open" || block.kind === "code-fence-close") && body.length > 0 && $isBlockParagraphNode(paragraph)) {
+      if (paragraph.getBlockMarker() !== body) {
+        paragraph.setBlockMarker(body);
+      }
+      trailingDropForOffsetMap = body.length;
+      body = "";
+    } else if (body.length > 0) {
+      desired.push({ kind: "text", text: body, format: 0 });
+    }
+  } else if (block.kind === "hr") {
+    if (body.length > 0) {
+      desired.push({ kind: "token", text: body, format: 0 });
+    }
+  } else {
+    inlineTokens = tokenize(body);
+    for (let ti = 0; ti < inlineTokens.length; ti++) {
+      const t = inlineTokens[ti];
+      const tokenLen = t.text.length;
+      if (isLive && t.type === "marker" && (t.text === "[" || t.text === "!") && ti + 4 < inlineTokens.length) {
+        const offset = t.text === "!" ? 1 : 0;
+        const open = inlineTokens[ti + offset];
+        const label = inlineTokens[ti + offset + 1];
+        const mid = inlineTokens[ti + offset + 2];
+        const url = inlineTokens[ti + offset + 3];
+        const close = inlineTokens[ti + offset + 4];
+        if (open?.type === "marker" && open.text === "[" && label?.type === "formatted" && label.format === "link" && mid?.type === "marker" && mid.text === "](" && url?.type === "formatted" && close?.type === "marker" && close.text === ")") {
+          desired.push({
+            kind: "link",
+            text: label.text,
+            format: 0,
+            url: url.text
+          });
+          srcPos += t.text.length;
+          if (offset === 1) {
+            srcPos += open.text.length + label.text.length + mid.text.length + url.text.length + close.text.length;
+            ti += 5;
+          } else {
+            srcPos += label.text.length + mid.text.length + url.text.length + close.text.length;
+            ti += 4;
+          }
+          continue;
+        }
+      }
+      if (t.type === "marker") {
+        if (!isLive) {
+          desired.push({ kind: "token", text: t.text, format: 0 });
+        }
+      } else if (t.type === "formatted") {
+        desired.push({
+          kind: "text",
+          text: t.text,
+          format: FORMAT_FLAGS[t.format]
+        });
+      } else if (isLive && currentFmt) {
+        let runStart = 0;
+        let runFmt = currentFmt[srcPos] ?? 0;
+        for (let i = 1; i < tokenLen; i++) {
+          const f = currentFmt[srcPos + i] ?? 0;
+          if (f !== runFmt) {
+            desired.push({
+              kind: "text",
+              text: t.text.slice(runStart, i),
+              format: runFmt
+            });
+            runStart = i;
+            runFmt = f;
+          }
+        }
+        desired.push({
+          kind: "text",
+          text: t.text.slice(runStart),
+          format: runFmt
+        });
+      } else {
+        desired.push({ kind: "text", text: t.text, format: 0 });
+      }
+      srcPos += tokenLen;
+    }
+  }
+  if (nodesEqual(current, desired)) return false;
+  const preservedLinkUrls = /* @__PURE__ */ new Map();
+  for (const child of paragraph.getChildren()) {
+    if ($isLinkTextNode(child)) {
+      const label = child.getTextContent();
+      const url = child.getUrl();
+      if (label && url && !preservedLinkUrls.has(label)) {
+        preservedLinkUrls.set(label, url);
+      }
+    }
+  }
+  const srcOffsets = getSelectionOffsetWithin(paragraph);
+  for (const child of paragraph.getChildren()) child.remove();
+  for (const node of desired) {
+    if (node.kind === "token") {
+      paragraph.append($createMarkdownTokenNode(node.text));
+    } else if (node.kind === "link") {
+      const t = $createLinkTextNode(node.text, node.url ?? "");
+      if (node.format !== 0) t.setFormat(node.format);
+      paragraph.append(t);
+    } else {
+      const preservedUrl = preservedLinkUrls.get(node.text);
+      const t = preservedUrl ? $createLinkTextNode(node.text, preservedUrl) : lexical.$createTextNode(node.text);
+      if (node.format !== 0) t.setFormat(node.format);
+      paragraph.append(t);
+    }
+  }
+  if (srcOffsets) {
+    if (isLive) {
+      const map = buildLiveOffsetMap(
+        text,
+        stashedMarkerForOffsetMap.length,
+        inlineTokens,
+        trailingDropForOffsetMap
+      );
+      setSelectionFromOffsets(paragraph, {
+        anchor: map(srcOffsets.anchor),
+        focus: map(srcOffsets.focus)
+      });
+    } else {
+      setSelectionFromOffsets(paragraph, {
+        anchor: srcOffsets.anchor + hybridPromoteShift,
+        focus: srcOffsets.focus + hybridPromoteShift
+      });
+    }
+  }
+  return true;
+}
+function $restyleAllParagraphs(mode) {
+  const root = lexical.$getRoot();
+  const map = $computeBlockMap();
+  for (const child of root.getChildren()) {
+    if (!lexical.$isParagraphNode(child)) continue;
+    const info = map.get(child.getKey()) ?? $detectBlockFor(child);
+    $applyStyling(child, info, mode);
+  }
+}
+function $autoEscapeClosedFence(prevKinds) {
+  const map = $computeBlockMap();
+  const root = lexical.$getRoot();
+  for (const child of root.getChildren()) {
+    if (!lexical.$isParagraphNode(child)) continue;
+    const key = child.getKey();
+    const info = map.get(key);
+    if (!info) continue;
+    const oldKind = prevKinds.get(key);
+    if (info.kind === "code-fence-close" && oldKind !== "code-fence-close" && child.getNextSibling() === null) {
+      const next = lexical.$createParagraphNode();
+      child.insertAfter(next);
+      next.select();
+    }
+  }
+  prevKinds.clear();
+  for (const [k, v] of map) prevKinds.set(k, v.kind);
+}
+var BLOCK_ATTR = "data-md-block";
+var LANG_ATTR = "data-md-lang";
+function syncBlockAttributes(editor) {
+  editor.getEditorState().read(() => {
+    const root = editor.getRootElement();
+    if (!root) return;
+    const seen = /* @__PURE__ */ new Set();
+    const map = $computeBlockMap();
+    for (const [key, info] of map) {
+      const el = editor.getElementByKey(key);
+      if (!(el instanceof HTMLElement)) continue;
+      seen.add(el);
+      if (info.kind === "paragraph") {
+        if (el.hasAttribute(BLOCK_ATTR)) el.removeAttribute(BLOCK_ATTR);
+      } else {
+        if (el.getAttribute(BLOCK_ATTR) !== info.kind) {
+          el.setAttribute(BLOCK_ATTR, info.kind);
+        }
+      }
+      if (info.kind === "code-fence-open" && info.lang) {
+        if (el.getAttribute(LANG_ATTR) !== info.lang) {
+          el.setAttribute(LANG_ATTR, info.lang);
+        }
+      } else if (el.hasAttribute(LANG_ATTR)) {
+        el.removeAttribute(LANG_ATTR);
+      }
+    }
+    const stale = root.querySelectorAll(`[${BLOCK_ATTR}]`);
+    stale.forEach((el) => {
+      if (!seen.has(el)) {
+        el.removeAttribute(BLOCK_ATTR);
+        el.removeAttribute(LANG_ATTR);
+      }
+    });
+  });
+}
+var RESTYLE_TAG = "md-restyle";
+function MarkdownPlugin() {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const { markdownMode } = useComposerContext();
+  const prevKindsRef = react.useRef(/* @__PURE__ */ new Map());
+  const modeRef = react.useRef(markdownMode);
+  modeRef.current = markdownMode;
+  react.useEffect(() => {
+    const prevKinds = prevKindsRef.current;
+    editor.update(
+      () => {
+        $restyleAllParagraphs(modeRef.current);
+        const map = $computeBlockMap();
+        prevKinds.clear();
+        for (const [k, v] of map) prevKinds.set(k, v.kind);
+      },
+      { tag: RESTYLE_TAG }
+    );
+    syncBlockAttributes(editor);
+    let scheduled = false;
+    const unregisterUpdate = editor.registerUpdateListener(
+      ({ tags, dirtyElements, dirtyLeaves }) => {
+        syncBlockAttributes(editor);
+        if (tags.has(RESTYLE_TAG)) return;
+        if (dirtyElements.size === 0 && dirtyLeaves.size === 0) return;
+        if (scheduled) return;
+        scheduled = true;
+        queueMicrotask(() => {
+          scheduled = false;
+          editor.update(
+            () => {
+              $restyleAllParagraphs(modeRef.current);
+              $autoEscapeClosedFence(prevKinds);
+            },
+            { tag: RESTYLE_TAG }
+          );
+        });
+      }
+    );
+    const unregisterBackspace = editor.registerCommand(
+      lexical.KEY_BACKSPACE_COMMAND,
+      () => {
+        if (modeRef.current !== "live") return false;
+        const selection = lexical.$getSelection();
+        if (!lexical.$isRangeSelection(selection) || !selection.isCollapsed()) {
+          return false;
+        }
+        if (selection.anchor.offset !== 0) return false;
+        const anchor = selection.anchor.getNode();
+        const top = anchor.getTopLevelElement();
+        if (!top || !lexical.$isParagraphNode(top)) return false;
+        if (!$isBlockParagraphNode(top)) return false;
+        if (!top.hasBlockMarker()) return false;
+        if (selection.anchor.type === "element") {
+          if (selection.anchor.getNode().getKey() !== top.getKey()) {
+            return false;
+          }
+        } else {
+          const first = top.getFirstChild();
+          if (!first || first.getKey() !== anchor.getKey()) return false;
+        }
+        editor.update(() => {
+          const latest = top.getLatest();
+          if ($isBlockParagraphNode(latest)) {
+            latest.setBlockMarker("");
+          }
+        });
+        return true;
+      },
+      lexical.COMMAND_PRIORITY_LOW
+    );
+    return () => {
+      unregisterUpdate();
+      unregisterBackspace();
+    };
+  }, [editor, markdownMode]);
+  return null;
+}
+function Portal({ children }) {
+  const [mounted, setMounted] = react.useState(false);
+  react.useEffect(() => {
+    setMounted(true);
+  }, []);
+  if (!mounted) return null;
+  return reactDom.createPortal(children, document.body);
+}
+function ImageLightbox({ src, alt, onClose }) {
+  const { icons, tokenStyle } = useComposerContext();
+  const { close: CloseIcon } = icons;
+  react.useEffect(() => {
+    const onKey = (e) => {
+      if (e.key === "Escape") onClose();
+    };
+    document.addEventListener("keydown", onKey);
+    const prev = document.body.style.overflow;
+    document.body.style.overflow = "hidden";
+    return () => {
+      document.removeEventListener("keydown", onKey);
+      document.body.style.overflow = prev;
+    };
+  }, [onClose]);
+  return /* @__PURE__ */ jsxRuntime.jsx(Portal, { children: /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      role: "dialog",
+      "aria-modal": "true",
+      className: "fixed inset-0 z-50 flex items-center justify-center p-6",
+      style: tokenStyle,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            "aria-hidden": true,
+            className: "absolute inset-0 bg-foreground/70 backdrop-blur-sm",
+            onClick: onClose
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            onClick: onClose,
+            "aria-label": "Close",
+            className: "absolute end-5 top-5 flex h-9 w-9 items-center justify-center rounded-full bg-card text-foreground shadow-soft transition-colors hover:bg-accent",
+            children: /* @__PURE__ */ jsxRuntime.jsx(CloseIcon, { className: "h-4 w-4" })
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "img",
+          {
+            src,
+            alt,
+            className: "relative max-h-[85vh] max-w-[85vw] rounded-lg object-contain shadow-xl"
+          }
+        )
+      ]
+    }
+  ) });
+}
+var FENCE_OPEN_MERMAID = /^```mermaid(?:\s.*)?$/;
+var FENCE_CLOSE = /^```\s*$/;
+var mermaidPromise = null;
+var mermaidInitialized = false;
+var mermaidMissingWarned = false;
+async function loadMermaid() {
+  if (!mermaidPromise) {
+    mermaidPromise = import('mermaid').then((m) => m.default).catch((err) => {
+      if (!mermaidMissingWarned) {
+        mermaidMissingWarned = true;
+        console.warn(
+          "[composeai] Failed to load the `mermaid` package. Either `npm install mermaid` or pass a `renderDiagram` prop to <Composer /> to render diagrams yourself.",
+          err
+        );
+      }
+      return null;
+    });
+  }
+  const mermaid = await mermaidPromise;
+  if (mermaid && !mermaidInitialized) {
+    mermaid.initialize({
+      startOnLoad: false,
+      theme: "default",
+      securityLevel: "strict",
+      fontFamily: "inherit"
+    });
+    mermaidInitialized = true;
+  }
+  return mermaid;
+}
+function svgToDataUri(svg) {
+  return `data:image/svg+xml;utf8,${encodeURIComponent(svg)}`;
+}
+function MermaidPlugin() {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const { features, icons, renderDiagram, classNames, sx } = useComposerContext();
+  const { sparkle: SparkleIcon } = icons;
+  const [diagrams, setDiagrams] = react.useState([]);
+  const keepSource = typeof features.mermaid === "object" ? features.mermaid.keepSource !== false : true;
+  react.useEffect(() => {
+    const sync = () => {
+      editor.getEditorState().read(() => {
+        const found = [];
+        const root = lexical.$getRoot();
+        const children = root.getChildren();
+        let i = 0;
+        while (i < children.length) {
+          const opener = children[i];
+          if (!lexical.$isParagraphNode(opener) || !FENCE_OPEN_MERMAID.test(opener.getTextContent())) {
+            i++;
+            continue;
+          }
+          const paragraphKeys = [opener.getKey()];
+          const codeLines = [];
+          let j = i + 1;
+          while (j < children.length) {
+            const next = children[j];
+            if (!lexical.$isParagraphNode(next)) break;
+            const text = next.getTextContent();
+            paragraphKeys.push(next.getKey());
+            if (FENCE_CLOSE.test(text)) {
+              j++;
+              break;
+            }
+            codeLines.push(text);
+            j++;
+          }
+          found.push({
+            id: opener.getKey(),
+            code: codeLines.join("\n").trim(),
+            paragraphKeys
+          });
+          i = j;
+        }
+        setDiagrams((prev) => {
+          if (prev.length === found.length && prev.every(
+            (d, idx) => d.id === found[idx].id && d.code === found[idx].code && d.paragraphKeys.length === found[idx].paragraphKeys.length && d.paragraphKeys.every((k, kk) => k === found[idx].paragraphKeys[kk])
+          )) {
+            return prev;
+          }
+          return found;
+        });
+      });
+    };
+    sync();
+    return editor.registerUpdateListener(sync);
+  }, [editor]);
+  const hiddenKeysRef = react.useRef(/* @__PURE__ */ new Set());
+  react.useEffect(() => {
+    const currentKeys = /* @__PURE__ */ new Set();
+    for (const d of diagrams) for (const k of d.paragraphKeys) currentKeys.add(k);
+    if (keepSource) {
+      for (const key of hiddenKeysRef.current) {
+        const el = editor.getElementByKey(key);
+        if (el) el.style.removeProperty("display");
+      }
+      hiddenKeysRef.current.clear();
+      return;
+    }
+    for (const key of hiddenKeysRef.current) {
+      if (!currentKeys.has(key)) {
+        const el = editor.getElementByKey(key);
+        if (el) el.style.removeProperty("display");
+      }
+    }
+    for (const key of currentKeys) {
+      const el = editor.getElementByKey(key);
+      if (el) el.style.display = "none";
+    }
+    hiddenKeysRef.current = currentKeys;
+  }, [diagrams, keepSource, editor]);
+  react.useEffect(() => {
+    return () => {
+      for (const key of hiddenKeysRef.current) {
+        const el = editor.getElementByKey(key);
+        if (el) el.style.removeProperty("display");
+      }
+      hiddenKeysRef.current.clear();
+    };
+  }, [editor]);
+  if (diagrams.length === 0) return null;
+  const preview = slotProps(
+    "mermaidPreview",
+    "border-t border-border/60 bg-muted/30 px-4 py-3",
+    classNames,
+    sx
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { ...preview, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "mb-1.5 flex items-center gap-1.5 text-[10px] font-medium uppercase tracking-wide text-muted-foreground", children: [
+      /* @__PURE__ */ jsxRuntime.jsx(SparkleIcon, { className: "h-3 w-3" }),
+      "Diagram preview"
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex gap-2 overflow-x-auto scrollbar-thin", children: diagrams.map((d) => /* @__PURE__ */ jsxRuntime.jsx(
+      DiagramTile,
+      {
+        diagram: d,
+        renderDiagram
+      },
+      d.id
+    )) })
+  ] });
+}
+function DiagramTile({ diagram, renderDiagram }) {
+  if (renderDiagram) {
+    return /* @__PURE__ */ jsxRuntime.jsx(ConsumerTile, { diagram, renderDiagram });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(MermaidTile, { diagram });
+}
+function ConsumerTile({
+  diagram,
+  renderDiagram
+}) {
+  let content = null;
+  try {
+    content = renderDiagram({ code: diagram.code, language: "mermaid" });
+  } catch (err) {
+    console.error("[composeai] renderDiagram threw", err);
+    content = /* @__PURE__ */ jsxRuntime.jsx("div", { className: "flex h-24 w-40 items-center justify-center px-2 text-center text-[10px] text-destructive", children: err instanceof Error ? err.message.slice(0, 80) : "Render failed" });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: "shrink-0 overflow-hidden rounded-lg border border-border bg-card", children: content });
+}
+function MermaidTile({ diagram }) {
+  const { icons } = useComposerContext();
+  const { zoom: ZoomIcon } = icons;
+  const [svg, setSvg] = react.useState(null);
+  const [error, setError] = react.useState(null);
+  const [zoom, setZoom] = react.useState(false);
+  const [mermaidMissing, setMermaidMissing] = react.useState(false);
+  const renderId = react.useMemo(
+    () => `mermaid-${diagram.id}-${Math.random().toString(36).slice(2, 8)}`,
+    [diagram.id]
+  );
+  react.useEffect(() => {
+    let cancelled = false;
+    if (!diagram.code) {
+      setSvg(null);
+      return;
+    }
+    loadMermaid().then((mermaid) => {
+      if (cancelled) return null;
+      if (!mermaid) {
+        setMermaidMissing(true);
+        return null;
+      }
+      return mermaid.render(renderId, diagram.code);
+    }).then((result) => {
+      if (cancelled || !result) return;
+      setSvg(result.svg);
+      setError(null);
+    }).catch((err) => {
+      if (cancelled) return;
+      const msg = err instanceof Error ? err.message : "Render failed";
+      setError(msg);
+      setSvg(null);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [diagram.code, renderId]);
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        type: "button",
+        onClick: () => svg && setZoom(true),
+        "aria-label": "Zoom diagram",
+        className: "group/dia relative shrink-0 overflow-hidden rounded-lg border border-border bg-card transition-colors hover:border-primary/40",
+        children: svg ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "div",
+            {
+              className: "h-24 w-40 [&_svg]:h-full [&_svg]:w-full",
+              dangerouslySetInnerHTML: { __html: svg }
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "absolute end-1 top-1 flex h-5 w-5 items-center justify-center rounded-full bg-foreground/70 text-background opacity-0 transition-opacity group-hover/dia:opacity-100", children: /* @__PURE__ */ jsxRuntime.jsx(ZoomIcon, { className: "h-3 w-3" }) })
+        ] }) : mermaidMissing ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "grid h-24 w-40 place-items-center px-3 text-center text-[11px] leading-snug text-muted-foreground", children: /* @__PURE__ */ jsxRuntime.jsxs("span", { children: [
+          "Install ",
+          /* @__PURE__ */ jsxRuntime.jsx("code", { className: "rounded bg-muted px-1 font-mono", children: "mermaid" }),
+          " ",
+          "or pass",
+          " ",
+          /* @__PURE__ */ jsxRuntime.jsx("code", { className: "rounded bg-muted px-1 font-mono", children: "renderDiagram" })
+        ] }) }) : error ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "grid h-24 w-40 place-items-center px-2 text-center text-[10px] leading-snug text-destructive", children: /* @__PURE__ */ jsxRuntime.jsx("span", { children: error.slice(0, 80) }) }) : /* @__PURE__ */ jsxRuntime.jsx("div", { className: "grid h-24 w-40 place-items-center text-[10px] text-muted-foreground", children: /* @__PURE__ */ jsxRuntime.jsx("span", { children: "Rendering\u2026" }) })
+      }
+    ),
+    zoom && svg && /* @__PURE__ */ jsxRuntime.jsx(
+      ImageLightbox,
+      {
+        src: svgToDataUri(svg),
+        alt: "Mermaid diagram",
+        onClose: () => setZoom(false)
+      }
+    )
+  ] });
+}
+function SlashMenu({
+  options,
+  selectedIndex,
+  isLoading = false,
+  onSelect,
+  onHover
+}) {
+  const listRef = react.useRef(null);
+  const { classNames, sx } = useComposerContext();
+  react.useEffect(() => {
+    const el = listRef.current?.querySelector(
+      `[data-index="${selectedIndex}"]`
+    );
+    if (el) el.scrollIntoView({ block: "nearest" });
+  }, [selectedIndex]);
+  const grouped = options.reduce(
+    (acc, item, index) => {
+      const g = item.group ?? "Commands";
+      if (!acc[g]) acc[g] = [];
+      acc[g].push({ item, index });
+      return acc;
+    },
+    {}
+  );
+  const menu = slotProps(
+    "slashMenu",
+    "z-50 w-72 origin-top animate-slide-up overflow-hidden rounded-xl border border-border bg-popover text-popover-foreground shadow-soft",
+    classNames,
+    sx
+  );
+  const itemStyle = react.useMemo(() => resolveSx(sx?.slashItem), [sx]);
+  const showSkeleton = isLoading && options.length === 0;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      "data-composer-popover": "open",
+      role: "listbox",
+      "aria-label": "Slash commands",
+      "aria-busy": isLoading || void 0,
+      ...menu,
+      children: /* @__PURE__ */ jsxRuntime.jsxs("ul", { ref: listRef, className: "max-h-72 overflow-y-auto scrollbar-thin py-1", children: [
+        showSkeleton && /* @__PURE__ */ jsxRuntime.jsx(SlashSkeleton, { rows: 4 }),
+        Object.entries(grouped).map(([group, entries]) => /* @__PURE__ */ jsxRuntime.jsxs("li", { children: [
+          /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-3 pb-1 pt-2 text-[10px] font-medium uppercase tracking-wide text-muted-foreground", children: group }),
+          /* @__PURE__ */ jsxRuntime.jsx("ul", { children: entries.map(({ item, index }) => /* @__PURE__ */ jsxRuntime.jsxs(
+            "li",
+            {
+              "data-index": index,
+              role: "option",
+              "aria-selected": selectedIndex === index,
+              onMouseDown: (e) => {
+                e.preventDefault();
+                onSelect(index);
+              },
+              onMouseEnter: () => onHover(index),
+              className: cn(
+                "flex cursor-pointer items-center gap-2.5 px-2.5 py-1.5 text-sm",
+                selectedIndex === index ? "bg-accent text-accent-foreground" : "text-foreground",
+                classNames?.slashItem
+              ),
+              style: itemStyle,
+              children: [
+                item.icon && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "flex h-7 w-7 shrink-0 items-center justify-center rounded-md bg-muted text-muted-foreground", children: item.icon }),
+                /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "flex min-w-0 flex-col leading-tight", children: [
+                  /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate font-medium", children: item.label }),
+                  item.description && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate text-[11px] text-muted-foreground", children: item.description })
+                ] }),
+                item.shortcut && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ms-auto rounded border border-border bg-muted px-1.5 py-0.5 font-mono text-[10px] text-muted-foreground", children: item.shortcut })
+              ]
+            },
+            item.id
+          )) })
+        ] }, group))
+      ] })
+    }
+  );
+}
+function SlashSkeleton({ rows = 4 }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("li", { "aria-hidden": "true", className: "px-2.5 py-1.5", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-0.5 pb-1.5 pt-0.5", children: /* @__PURE__ */ jsxRuntime.jsx("span", { className: "block h-2 w-16 animate-pulse rounded bg-muted/70" }) }),
+    /* @__PURE__ */ jsxRuntime.jsx("ul", { className: "flex flex-col gap-1", children: Array.from({ length: rows }).map((_, i) => /* @__PURE__ */ jsxRuntime.jsxs(
+      "li",
+      {
+        className: "flex items-center gap-2.5 rounded-md px-0 py-1.5",
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "h-7 w-7 shrink-0 animate-pulse rounded-md bg-muted" }),
+          /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "flex min-w-0 flex-1 flex-col gap-1.5", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "span",
+              {
+                className: "h-2.5 animate-pulse rounded bg-muted",
+                style: { width: `${50 + i * 19 % 35}%` }
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "span",
+              {
+                className: "h-2 animate-pulse rounded bg-muted/70",
+                style: { width: `${30 + i * 13 % 30}%` }
+              }
+            )
+          ] })
+        ]
+      },
+      i
+    )) }),
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sr-only", children: "Loading commands\u2026" })
+  ] });
+}
+var MARGIN = 8;
+function findComposerRoot(anchor) {
+  const active = document.activeElement;
+  if (active instanceof HTMLElement) {
+    const root = active.closest("[data-composer-root]");
+    if (root) return root;
+  }
+  if (anchor) {
+    const anchorRect = anchor.getBoundingClientRect();
+    const x = anchorRect.left + 1;
+    const y = anchorRect.top + 1;
+    const el = document.elementFromPoint(x, y);
+    if (el instanceof HTMLElement) {
+      const root = el.closest("[data-composer-root]");
+      if (root) return root;
+    }
+  }
+  return document.querySelector("[data-composer-root]");
+}
+function rectFromDom(rect) {
+  return {
+    left: rect.left,
+    right: rect.right,
+    top: rect.top,
+    bottom: rect.bottom,
+    width: rect.width,
+    height: rect.height
+  };
+}
+var WORD_OR_SPACE = /[A-Za-z0-9_\s\u0590-\u05FF\u0600-\u06FF\u4E00-\u9FFF]/;
+function isBlockRtl(node) {
+  let el = node.nodeType === Node.ELEMENT_NODE ? node : node.parentElement;
+  while (el) {
+    const display = getComputedStyle(el).display;
+    if (display && display !== "inline" && display !== "contents") {
+      return getComputedStyle(el).direction === "rtl";
+    }
+    el = el.parentElement;
+  }
+  return null;
+}
+function readTriggerInfo() {
+  if (typeof window === "undefined") return null;
+  const sel = window.getSelection?.();
+  if (!sel || sel.rangeCount === 0) return null;
+  const range = sel.getRangeAt(0);
+  const node = range.startContainer;
+  if (node.nodeType !== Node.TEXT_NODE) return null;
+  const text = node.data;
+  const cursorOffset = range.startOffset;
+  let triggerOffset = -1;
+  const lookbackStart = Math.max(0, cursorOffset - 64);
+  for (let i = cursorOffset - 1; i >= lookbackStart; i--) {
+    const c = text[i];
+    if (WORD_OR_SPACE.test(c)) continue;
+    triggerOffset = i;
+    break;
+  }
+  if (triggerOffset < 0) return null;
+  const triggerRange = document.createRange();
+  try {
+    triggerRange.setStart(node, triggerOffset);
+    triggerRange.setEnd(node, triggerOffset + 1);
+  } catch {
+    return null;
+  }
+  const rect = triggerRange.getBoundingClientRect();
+  if (rect.height === 0 && rect.width === 0) return null;
+  return {
+    rect: rectFromDom(rect),
+    rtl: isBlockRtl(node) ?? false
+  };
+}
+function readFallbackInfo(fallback, dirHint) {
+  const sel = typeof window !== "undefined" ? window.getSelection?.() : null;
+  let rect;
+  if (sel && sel.rangeCount > 0) {
+    const r = sel.getRangeAt(0).getBoundingClientRect();
+    rect = r.height > 0 || r.width > 0 ? rectFromDom(r) : rectFromDom(fallback.getBoundingClientRect());
+    const blockRtl = sel.rangeCount > 0 ? isBlockRtl(sel.getRangeAt(0).startContainer) : null;
+    if (blockRtl !== null) return { rect, rtl: blockRtl };
+  } else {
+    rect = rectFromDom(fallback.getBoundingClientRect());
+  }
+  if (dirHint === "rtl") return { rect, rtl: true };
+  if (dirHint === "ltr") return { rect, rtl: false };
+  const root = fallback.closest("[data-composer-root]") ?? document.querySelector("[data-composer-root]");
+  const editor = root?.querySelector(".composer-editor");
+  const probe = editor ?? root ?? fallback;
+  return { rect, rtl: getComputedStyle(probe).direction === "rtl" };
+}
+function SmartPopover({ children, gap = 6 }) {
+  const ref = react.useRef(null);
+  const [placement, setPlacement] = react.useState(null);
+  const { tokenStyle, dir } = useComposerContext();
+  react.useLayoutEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const anchor = el.parentElement;
+    if (!anchor) return;
+    const update = () => {
+      const info = readTriggerInfo() ?? readFallbackInfo(anchor, dir);
+      const triggerRect = info.rect;
+      const menuHeight = el.offsetHeight;
+      const menuWidth = el.offsetWidth;
+      const viewportH = window.innerHeight;
+      const viewportW = window.innerWidth;
+      const baseLeft = info.rtl ? triggerRect.right - menuWidth : triggerRect.left;
+      let left = baseLeft;
+      if (left + menuWidth + MARGIN > viewportW) {
+        left = viewportW - menuWidth - MARGIN;
+      }
+      if (left < MARGIN) left = MARGIN;
+      const spaceBelow = viewportH - triggerRect.bottom;
+      const spaceAbove = triggerRect.top;
+      const wantsAbove = spaceBelow < menuHeight + MARGIN && spaceAbove > spaceBelow;
+      let next;
+      if (wantsAbove) {
+        const composerRoot = findComposerRoot(anchor);
+        const topEdge = composerRoot ? composerRoot.getBoundingClientRect().top : triggerRect.top;
+        next = {
+          left,
+          bottom: Math.max(MARGIN, viewportH - topEdge + gap),
+          rtl: info.rtl
+        };
+      } else {
+        next = { left, top: triggerRect.bottom + gap, rtl: info.rtl };
+      }
+      setPlacement(
+        (prev) => prev && prev.left === next.left && prev.top === next.top && prev.bottom === next.bottom && prev.rtl === next.rtl ? prev : next
+      );
+    };
+    update();
+    const ro = new ResizeObserver(update);
+    ro.observe(el);
+    ro.observe(anchor);
+    document.addEventListener("selectionchange", update);
+    window.addEventListener("resize", update);
+    window.addEventListener("scroll", update, true);
+    return () => {
+      ro.disconnect();
+      document.removeEventListener("selectionchange", update);
+      window.removeEventListener("resize", update);
+      window.removeEventListener("scroll", update, true);
+    };
+  }, [children, gap, dir]);
+  const style = placement === null ? {
+    position: "fixed",
+    left: 0,
+    top: 0,
+    visibility: "hidden",
+    zIndex: 60
+  } : {
+    position: "fixed",
+    left: placement.left,
+    top: placement.top,
+    bottom: placement.bottom,
+    zIndex: 60
+  };
+  const mergedStyle = tokenStyle ? { ...tokenStyle, ...style } : style;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref,
+      "data-composer-popover-placement": placement?.bottom !== void 0 ? "above-composer" : "below",
+      dir: placement?.rtl ? "rtl" : "ltr",
+      style: mergedStyle,
+      children
+    }
+  );
+}
+function useOutsideClickDismiss(editor, enabled) {
+  react.useEffect(() => {
+    if (!enabled) return;
+    const dismiss = () => {
+      const event = new KeyboardEvent("keydown", { key: "Escape" });
+      editor.dispatchCommand(lexical.KEY_ESCAPE_COMMAND, event);
+    };
+    const isOutside = (target) => {
+      if (!(target instanceof Node)) return false;
+      const popover = document.querySelector(
+        "[data-composer-popover-placement]"
+      );
+      if (!popover) return false;
+      if (popover.contains(target)) return false;
+      const el = target instanceof Element ? target : target.parentElement;
+      if (!el) return true;
+      if (el.closest("[data-composer-root]")) return false;
+      return true;
+    };
+    const onPointer = (e) => {
+      const target = e instanceof TouchEvent ? e.touches[0]?.target ?? null : e.target;
+      if (isOutside(target)) dismiss();
+    };
+    document.addEventListener("mousedown", onPointer, true);
+    document.addEventListener("touchstart", onPointer, true);
+    return () => {
+      document.removeEventListener("mousedown", onPointer, true);
+      document.removeEventListener("touchstart", onPointer, true);
+    };
+  }, [editor, enabled]);
+}
+var SlashOption = class extends LexicalTypeaheadMenuPlugin.MenuOption {
+  command;
+  constructor(command) {
+    super(command.id);
+    this.command = command;
+  }
+};
+function isSyncItems(items) {
+  return Array.isArray(items);
+}
+function SlashCommandPlugin({ config, onSubmit }) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const { closeMenusOnOutsideClick } = useComposerContext();
+  const [query, setQuery] = react.useState("");
+  const [asyncItems, setAsyncItems] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(
+    !isSyncItems(config.items)
+  );
+  useOutsideClickDismiss(editor, closeMenusOnOutsideClick);
+  const triggerFn = LexicalTypeaheadMenuPlugin.useBasicTypeaheadTriggerMatch(
+    config.trigger ?? "/",
+    { minLength: 0, maxLength: 32, allowWhitespace: false }
+  );
+  react.useEffect(() => {
+    if (isSyncItems(config.items)) {
+      setIsLoading(false);
+      return;
+    }
+    let cancelled = false;
+    setIsLoading(true);
+    Promise.resolve(config.items(query)).then((res) => {
+      if (cancelled) return;
+      setAsyncItems(res);
+      setIsLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [query, config.items]);
+  const allItems = react.useMemo(() => {
+    return isSyncItems(config.items) ? config.items : asyncItems ?? [];
+  }, [config.items, asyncItems]);
+  const options = react.useMemo(() => {
+    const q = query.trim().toLowerCase();
+    const max = config.maxItems ?? 8;
+    const filtered = q ? allItems.filter((it) => {
+      const hay = `${it.label} ${it.description ?? ""} ${it.group ?? ""}`.toLowerCase();
+      return hay.includes(q);
+    }) : allItems;
+    return filtered.slice(0, max).map((c) => new SlashOption(c));
+  }, [allItems, query, config.maxItems]);
+  const onSelectOption = react.useCallback(
+    (selectedOption, nodeToReplace, closeMenu, matchingString) => {
+      editor.update(() => {
+        if (nodeToReplace) nodeToReplace.remove();
+      });
+      const ctx = {
+        insertText: (text) => {
+          editor.update(() => {
+            const sel = lexical.$getSelection();
+            if (lexical.$isRangeSelection(sel)) sel.insertText(text);
+          });
+        },
+        insertMarkdown: (md) => {
+          editor.update(() => {
+            const sel = lexical.$getSelection();
+            if (lexical.$isRangeSelection(sel)) sel.insertText(md);
+          });
+        },
+        cancel: () => closeMenu(),
+        submit: () => onSubmit()
+      };
+      selectedOption.command.onSelect?.(ctx);
+      closeMenu();
+    },
+    [editor, onSubmit]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    LexicalTypeaheadMenuPlugin.LexicalTypeaheadMenuPlugin,
+    {
+      onQueryChange: (s) => setQuery(s ?? ""),
+      onSelectOption,
+      triggerFn,
+      options,
+      menuRenderFn: (anchorElementRef, { selectedIndex, selectOptionAndCleanUp, setHighlightedIndex }) => {
+        if (!anchorElementRef.current) return null;
+        if (options.length === 0 && !isLoading) return null;
+        return reactDom.createPortal(
+          /* @__PURE__ */ jsxRuntime.jsx(SmartPopover, { children: /* @__PURE__ */ jsxRuntime.jsx(
+            SlashMenu,
+            {
+              options: options.map((o) => o.command),
+              selectedIndex: selectedIndex ?? 0,
+              isLoading,
+              onSelect: (index) => selectOptionAndCleanUp(options[index]),
+              onHover: (index) => setHighlightedIndex(index)
+            }
+          ) }),
+          anchorElementRef.current
+        );
+      }
+    }
+  );
+}
+function Avatar({ src, alt, size = 28, className }) {
+  const [errored, setErrored] = react.useState(false);
+  const showImage = src && !errored;
+  const initial = (alt || "?").slice(0, 1).toUpperCase();
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "span",
+    {
+      className: "inline-flex shrink-0 select-none items-center justify-center overflow-hidden rounded-full bg-primary/10 text-xs font-semibold text-primary" + (className ? ` ${className}` : ""),
+      style: { width: size, height: size },
+      children: showImage ? /* @__PURE__ */ jsxRuntime.jsx(
+        "img",
+        {
+          src,
+          alt,
+          className: "h-full w-full object-cover",
+          onError: () => setErrored(true)
+        }
+      ) : initial
+    }
+  );
+}
+function MentionMenu({
+  options,
+  selectedIndex,
+  isLoading = false,
+  onSelect,
+  onHover
+}) {
+  const listRef = react.useRef(null);
+  const { classNames, sx } = useComposerContext();
+  react.useEffect(() => {
+    const el = listRef.current?.querySelector(
+      `[data-index="${selectedIndex}"]`
+    );
+    if (el) el.scrollIntoView({ block: "nearest" });
+  }, [selectedIndex]);
+  const menu = slotProps(
+    "mentionMenu",
+    "z-50 w-64 origin-top animate-slide-up overflow-hidden rounded-xl border border-border bg-popover text-popover-foreground shadow-soft",
+    classNames,
+    sx
+  );
+  const itemStyle = react.useMemo(() => resolveSx(sx?.mentionItem), [sx]);
+  const showSkeleton = isLoading && options.length === 0;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      "data-composer-popover": "open",
+      role: "listbox",
+      "aria-label": "Mentions",
+      "aria-busy": isLoading || void 0,
+      ...menu,
+      children: /* @__PURE__ */ jsxRuntime.jsxs("ul", { ref: listRef, className: "max-h-72 overflow-y-auto scrollbar-thin py-1", children: [
+        showSkeleton ? /* @__PURE__ */ jsxRuntime.jsx(MentionSkeleton, { rows: 3 }) : null,
+        options.map((item, index) => /* @__PURE__ */ jsxRuntime.jsxs(
+          "li",
+          {
+            "data-index": index,
+            role: "option",
+            "aria-selected": selectedIndex === index,
+            onMouseDown: (e) => {
+              e.preventDefault();
+              onSelect(index);
+            },
+            onMouseEnter: () => onHover(index),
+            className: cn(
+              "flex cursor-pointer items-center gap-2.5 px-2.5 py-1.5 text-sm",
+              selectedIndex === index ? "bg-accent text-accent-foreground" : "text-foreground",
+              classNames?.mentionItem
+            ),
+            style: itemStyle,
+            children: [
+              item.avatarUrl ? /* @__PURE__ */ jsxRuntime.jsx(Avatar, { src: item.avatarUrl, alt: item.label }) : item.icon ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: "flex h-7 w-7 shrink-0 items-center justify-center rounded-full bg-primary/10 text-primary", children: item.icon }) : /* @__PURE__ */ jsxRuntime.jsx("span", { className: "flex h-7 w-7 shrink-0 items-center justify-center rounded-full bg-primary/10 text-xs font-semibold text-primary", children: item.label.slice(0, 1).toUpperCase() }),
+              /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "flex min-w-0 flex-col leading-tight", children: [
+                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate font-medium", children: item.label }),
+                item.description && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate text-[11px] text-muted-foreground", children: item.description })
+              ] })
+            ]
+          },
+          item.id
+        ))
+      ] })
+    }
+  );
+}
+function MentionSkeleton({ rows = 3 }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("li", { "aria-hidden": "true", className: "px-2.5 py-1.5", children: [
+    /* @__PURE__ */ jsxRuntime.jsx("ul", { className: "flex flex-col gap-1", children: Array.from({ length: rows }).map((_, i) => /* @__PURE__ */ jsxRuntime.jsxs(
+      "li",
+      {
+        className: "flex items-center gap-2.5 rounded-md px-0 py-1.5",
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "h-7 w-7 shrink-0 animate-pulse rounded-full bg-muted" }),
+          /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "flex min-w-0 flex-1 flex-col gap-1.5", children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "span",
+              {
+                className: "h-2.5 animate-pulse rounded bg-muted",
+                style: { width: `${60 + i * 17 % 30}%` }
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "span",
+              {
+                className: "h-2 animate-pulse rounded bg-muted/70",
+                style: { width: `${35 + i * 23 % 25}%` }
+              }
+            )
+          ] })
+        ]
+      },
+      i
+    )) }),
+    /* @__PURE__ */ jsxRuntime.jsx("span", { className: "sr-only", children: "Loading suggestions\u2026" })
+  ] });
+}
+var MentionOption = class extends LexicalTypeaheadMenuPlugin.MenuOption {
+  item;
+  constructor(item) {
+    super(item.id);
+    this.item = item;
+  }
+};
+function isSyncItems2(items) {
+  return Array.isArray(items);
+}
+function MentionPlugin({ config }) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const { closeMenusOnOutsideClick } = useComposerContext();
+  const [query, setQuery] = react.useState("");
+  const [asyncItems, setAsyncItems] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(
+    !isSyncItems2(config.items)
+  );
+  useOutsideClickDismiss(editor, closeMenusOnOutsideClick);
+  const trigger = config.trigger ?? "@";
+  const triggerFn = LexicalTypeaheadMenuPlugin.useBasicTypeaheadTriggerMatch(trigger, {
+    minLength: 0,
+    maxLength: 32,
+    allowWhitespace: false
+  });
+  react.useEffect(() => {
+    if (isSyncItems2(config.items)) {
+      setIsLoading(false);
+      return;
+    }
+    let cancelled = false;
+    setIsLoading(true);
+    Promise.resolve(config.items(query)).then((res) => {
+      if (cancelled) return;
+      setAsyncItems(res);
+      setIsLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [query, config.items]);
+  const allItems = react.useMemo(() => {
+    return isSyncItems2(config.items) ? config.items : asyncItems ?? [];
+  }, [config.items, asyncItems]);
+  const options = react.useMemo(() => {
+    const q = query.trim().toLowerCase();
+    const max = config.maxItems ?? 8;
+    const filtered = q ? allItems.filter(
+      (it) => `${it.label} ${it.description ?? ""}`.toLowerCase().includes(q)
+    ) : allItems;
+    return filtered.slice(0, max).map((c) => new MentionOption(c));
+  }, [allItems, query, config.maxItems]);
+  const onSelectOption = react.useCallback(
+    (selectedOption, nodeToReplace, closeMenu) => {
+      editor.update(() => {
+        const chip = $createMentionNode(selectedOption.item.id, trigger);
+        chip.append(lexical.$createTextNode(selectedOption.item.label));
+        if (nodeToReplace) {
+          nodeToReplace.replace(chip);
+        } else {
+          const sel = lexical.$getSelection();
+          if (lexical.$isRangeSelection(sel)) sel.insertNodes([chip]);
+        }
+        const space = lexical.$createTextNode(" ");
+        chip.insertAfter(space);
+        space.select();
+      });
+      closeMenu();
+    },
+    [editor, trigger]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    LexicalTypeaheadMenuPlugin.LexicalTypeaheadMenuPlugin,
+    {
+      onQueryChange: (s) => setQuery(s ?? ""),
+      onSelectOption,
+      triggerFn,
+      options,
+      menuRenderFn: (anchorElementRef, { selectedIndex, selectOptionAndCleanUp, setHighlightedIndex }) => {
+        if (!anchorElementRef.current) return null;
+        if (options.length === 0 && !isLoading) return null;
+        return reactDom.createPortal(
+          /* @__PURE__ */ jsxRuntime.jsx(SmartPopover, { children: /* @__PURE__ */ jsxRuntime.jsx(
+            MentionMenu,
+            {
+              options: options.map((o) => o.item),
+              selectedIndex: selectedIndex ?? 0,
+              isLoading,
+              onSelect: (index) => selectOptionAndCleanUp(options[index]),
+              onHover: (index) => setHighlightedIndex(index)
+            }
+          ) }),
+          anchorElementRef.current
+        );
+      }
+    }
+  );
+}
+function resolveConfig(config) {
+  if (Array.isArray(config)) {
+    return { suggestions: config, caseSensitive: false, minLength: 1 };
+  }
+  return {
+    suggestions: config.suggestions,
+    caseSensitive: !!config.caseSensitive,
+    // `1` (not `0`) so the ghost never appears on an empty editor — the
+    // placeholder handles that, and showing a ghost there would feel like
+    // the composer is auto-typing on its own.
+    minLength: Math.max(1, config.minLength ?? 1)
+  };
+}
+function findGhost(typed, suggestions, caseSensitive) {
+  if (typed.length === 0) return null;
+  const needle = caseSensitive ? typed : typed.toLowerCase();
+  for (const candidate of suggestions) {
+    if (candidate.length <= typed.length) continue;
+    const hay = caseSensitive ? candidate : candidate.toLowerCase();
+    if (hay.startsWith(needle)) {
+      return candidate.slice(typed.length);
+    }
+  }
+  return null;
+}
+function $isCaretAtDocumentEnd() {
+  const sel = lexical.$getSelection();
+  if (!lexical.$isRangeSelection(sel) || !sel.isCollapsed()) return false;
+  const root = lexical.$getRoot();
+  const last = root.getLastDescendant();
+  if (last === null) {
+    return sel.focus.key === root.getKey();
+  }
+  if (sel.focus.key !== last.getKey()) return false;
+  const size = "getTextContentSize" in last && typeof last.getTextContentSize === "function" ? last.getTextContentSize() : last.getTextContent().length;
+  return sel.focus.offset === size;
+}
+function GhostedAutoCompletePlugin({ config }) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const { multiline } = useComposerContext();
+  const resolved = react.useMemo(() => resolveConfig(config), [config]);
+  const [ghost, setGhost] = react.useState(null);
+  const ghostRef = react.useRef(null);
+  ghostRef.current = ghost;
+  react.useEffect(() => {
+    const compute = () => {
+      editor.getEditorState().read(() => {
+        if (!$isCaretAtDocumentEnd()) {
+          setGhost(null);
+          return;
+        }
+        const typed = lexical.$getRoot().getTextContent();
+        if (typed.length < resolved.minLength) {
+          setGhost(null);
+          return;
+        }
+        const remainder = findGhost(
+          typed,
+          resolved.suggestions,
+          resolved.caseSensitive
+        );
+        if (!remainder) {
+          setGhost(null);
+          return;
+        }
+        setGhost(
+          (prev) => prev && prev.typed === typed && prev.remainder === remainder ? prev : { typed, remainder }
+        );
+      });
+    };
+    compute();
+    return editor.registerUpdateListener(compute);
+  }, [editor, resolved]);
+  const acceptGhost = react.useCallback(() => {
+    const current = ghostRef.current;
+    if (!current) return false;
+    editor.update(() => {
+      const sel = lexical.$getSelection();
+      if (lexical.$isRangeSelection(sel)) {
+        sel.insertText(current.remainder);
+      }
+    });
+    setGhost(null);
+    return true;
+  }, [editor]);
+  react.useEffect(() => {
+    return editor.registerCommand(
+      lexical.KEY_TAB_COMMAND,
+      (event) => {
+        if (!ghostRef.current) return false;
+        event?.preventDefault();
+        return acceptGhost();
+      },
+      lexical.COMMAND_PRIORITY_HIGH
+    );
+  }, [editor, acceptGhost]);
+  react.useEffect(() => {
+    return editor.registerCommand(
+      lexical.KEY_ESCAPE_COMMAND,
+      () => {
+        if (!ghostRef.current) return false;
+        setGhost(null);
+        return true;
+      },
+      lexical.COMMAND_PRIORITY_LOW
+    );
+  }, [editor]);
+  if (!ghost) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    GhostOverlay,
+    {
+      typed: ghost.typed,
+      remainder: ghost.remainder,
+      multiline
+    }
+  );
+}
+function GhostOverlay({ typed, remainder, multiline }) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const [container, setContainer] = react.useState(null);
+  react.useEffect(() => {
+    const root = editor.getRootElement();
+    const block = root?.closest(".composer-editor-block") ?? null;
+    setContainer(block);
+  }, [editor]);
+  if (!container) return null;
+  const paddingClass = multiline ? "composer-ghost-overlay--multiline px-5 py-3.5" : "composer-ghost-overlay--inline px-2 leading-9";
+  return reactDom.createPortal(
+    /* @__PURE__ */ jsxRuntime.jsxs(
+      "div",
+      {
+        "aria-hidden": true,
+        "data-composer-ghost": "",
+        className: `composer-ghost-overlay pointer-events-none absolute inset-0 select-none ${paddingClass}`,
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "composer-ghost-overlay-typed", "aria-hidden": true, children: typed }),
+          /* @__PURE__ */ jsxRuntime.jsx("span", { className: "composer-ghost-suggestion", children: remainder })
+        ]
+      }
+    ),
+    container
+  );
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(0)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function AttachmentChip({ attachment, onRemove, onZoom }) {
+  const { icons, classNames, sx } = useComposerContext();
+  const {
+    file: FileIcon,
+    audio: AudioIcon,
+    close: CloseIcon,
+    zoom: ZoomIcon,
+    spinner: SpinnerIcon,
+    warning: WarningIcon
+  } = icons;
+  const isImage = attachment.kind === "image" && !!attachment.previewUrl;
+  const isUploading = attachment.status === "uploading";
+  const isFailed = attachment.status === "failed";
+  const titleText = isFailed && attachment.error ? `${attachment.name} \u2014 ${attachment.error}` : attachment.name;
+  if (isImage) {
+    const chip2 = slotProps(
+      "attachmentChip",
+      "group/chip relative h-16 w-16 overflow-hidden rounded-xl border border-border bg-muted",
+      classNames,
+      sx
+    );
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { ...chip2, title: titleText, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "img",
+        {
+          src: attachment.previewUrl,
+          alt: attachment.name,
+          className: "h-full w-full object-cover"
+        }
+      ),
+      isUploading && /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          "aria-label": "Uploading",
+          className: "absolute inset-0 grid place-items-center bg-foreground/50",
+          children: /* @__PURE__ */ jsxRuntime.jsx(SpinnerIcon, { className: "h-5 w-5 animate-spin text-background" })
+        }
+      ),
+      isFailed && /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          "aria-label": "Upload failed",
+          className: "absolute inset-0 grid place-items-center bg-destructive/55",
+          children: /* @__PURE__ */ jsxRuntime.jsx(WarningIcon, { className: "h-5 w-5 text-destructive-foreground" })
+        }
+      ),
+      !isUploading && !isFailed && /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          onClick: onZoom,
+          "aria-label": `Zoom ${attachment.name}`,
+          className: "absolute inset-0 flex items-center justify-center bg-foreground/40 opacity-0 transition-opacity group-hover/chip:opacity-100",
+          children: /* @__PURE__ */ jsxRuntime.jsx(ZoomIcon, { className: "h-4 w-4 text-background" })
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          onClick: onRemove,
+          "aria-label": `Remove ${attachment.name}`,
+          className: "absolute end-1 top-1 z-10 flex h-5 w-5 items-center justify-center rounded-full bg-foreground text-background transition-opacity " + (isUploading || isFailed ? "opacity-100" : "opacity-0 group-hover/chip:opacity-100"),
+          children: /* @__PURE__ */ jsxRuntime.jsx(CloseIcon, { className: "h-3 w-3", strokeWidth: 2.5 })
+        }
+      )
+    ] });
+  }
+  const KindIcon = attachment.kind === "audio" ? AudioIcon : FileIcon;
+  const chip = slotProps(
+    "attachmentChip",
+    "group/chip flex items-center gap-2 rounded-xl border bg-card ps-2 pe-1 py-1.5 " + (isFailed ? "border-destructive/60" : "border-border"),
+    classNames,
+    sx
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { ...chip, title: titleText, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "span",
+      {
+        className: "flex h-8 w-8 items-center justify-center rounded-md " + (isFailed ? "bg-destructive/15 text-destructive" : "bg-muted text-muted-foreground"),
+        children: isUploading ? /* @__PURE__ */ jsxRuntime.jsx(SpinnerIcon, { className: "h-4 w-4 animate-spin" }) : isFailed ? /* @__PURE__ */ jsxRuntime.jsx(WarningIcon, { className: "h-4 w-4" }) : /* @__PURE__ */ jsxRuntime.jsx(KindIcon, { className: "h-4 w-4" })
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "flex flex-col", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "max-w-[160px] truncate text-xs font-medium leading-tight", children: attachment.name }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "span",
+        {
+          className: "text-[10px] " + (isFailed ? "text-destructive" : "text-muted-foreground"),
+          children: isUploading ? "Uploading\u2026" : isFailed ? attachment.error || "Upload failed" : formatBytes(attachment.size)
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        type: "button",
+        onClick: onRemove,
+        "aria-label": `Remove ${attachment.name}`,
+        className: "flex h-6 w-6 items-center justify-center rounded-full text-muted-foreground transition-colors hover:bg-accent hover:text-foreground",
+        children: /* @__PURE__ */ jsxRuntime.jsx(CloseIcon, { className: "h-3.5 w-3.5" })
+      }
+    )
+  ] });
+}
+function AttachmentTray() {
+  const { attachments, removeAttachment, classNames, sx } = useComposerContext();
+  const [zoom, setZoom] = react.useState(null);
+  if (attachments.length === 0) return null;
+  const tray = slotProps(
+    "attachmentTray",
+    "flex flex-wrap gap-2 px-4 pt-3",
+    classNames,
+    sx
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx("div", { ...tray, children: attachments.map((att) => /* @__PURE__ */ jsxRuntime.jsx(
+      AttachmentChip,
+      {
+        attachment: att,
+        onRemove: () => removeAttachment(att.id),
+        onZoom: att.kind === "image" ? () => setZoom(att) : void 0
+      },
+      att.id
+    )) }),
+    zoom && zoom.previewUrl && /* @__PURE__ */ jsxRuntime.jsx(
+      ImageLightbox,
+      {
+        src: zoom.previewUrl,
+        alt: zoom.name,
+        onClose: () => setZoom(null)
+      }
+    )
+  ] });
+}
+var sideClasses = {
+  top: "bottom-full left-1/2 mb-2 -translate-x-1/2",
+  bottom: "top-full left-1/2 mt-2 -translate-x-1/2",
+  left: "end-full top-1/2 me-2 -translate-y-1/2",
+  right: "start-full top-1/2 ms-2 -translate-y-1/2"
+};
+function Tooltip({
+  children,
+  content,
+  side = "top",
+  delay = 150,
+  className
+}) {
+  const [open, setOpen] = react.useState(false);
+  const id = react.useId();
+  const timerRef = react.useRef(null);
+  const show = () => {
+    if (timerRef.current) clearTimeout(timerRef.current);
+    timerRef.current = setTimeout(() => setOpen(true), delay);
+  };
+  const hide = () => {
+    if (timerRef.current) clearTimeout(timerRef.current);
+    setOpen(false);
+  };
+  const trigger = react.isValidElement(children) ? react.cloneElement(children, {
+    "aria-describedby": id,
+    onMouseEnter: show,
+    onMouseLeave: hide,
+    onFocus: show,
+    onBlur: hide
+  }) : /* @__PURE__ */ jsxRuntime.jsx(
+    "span",
+    {
+      tabIndex: 0,
+      "aria-describedby": id,
+      onMouseEnter: show,
+      onMouseLeave: hide,
+      onFocus: show,
+      onBlur: hide,
+      children
+    }
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "relative inline-flex", children: [
+    trigger,
+    open && /* @__PURE__ */ jsxRuntime.jsx(
+      "span",
+      {
+        id,
+        role: "tooltip",
+        className: cn(
+          "absolute z-50 whitespace-nowrap rounded-md bg-foreground px-2 py-1 text-xs text-background shadow-md",
+          sideClasses[side],
+          className
+        ),
+        children: content
+      }
+    )
+  ] });
+}
+function getSpeechRecognition() {
+  const w = window;
+  return w.SpeechRecognition ?? w.webkitSpeechRecognition ?? null;
+}
+function formatSeconds(s) {
+  const mm = Math.floor(s / 60);
+  const ss = s % 60;
+  return `${mm}:${ss.toString().padStart(2, "0")}`;
+}
+function VoiceButton() {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const { addFiles, icons, classNames } = useComposerContext();
+  const { voice: VoiceIcon, voiceRecording: VoiceRecordingIcon } = icons;
+  const [state, setState] = react.useState("idle");
+  const [elapsed, setElapsed] = react.useState(0);
+  const recognitionRef = react.useRef(null);
+  const mediaRef = react.useRef(null);
+  const chunksRef = react.useRef([]);
+  const startedAtRef = react.useRef(0);
+  const tickerRef = react.useRef(null);
+  react.useEffect(() => {
+    return () => {
+      try {
+        recognitionRef.current?.stop();
+      } catch {
+      }
+      try {
+        mediaRef.current?.stop();
+      } catch {
+      }
+      if (tickerRef.current) window.clearInterval(tickerRef.current);
+    };
+  }, []);
+  const startTicker = () => {
+    startedAtRef.current = Date.now();
+    setElapsed(0);
+    if (tickerRef.current) window.clearInterval(tickerRef.current);
+    tickerRef.current = window.setInterval(() => {
+      setElapsed(Math.floor((Date.now() - startedAtRef.current) / 1e3));
+    }, 500);
+  };
+  const stopTicker = () => {
+    if (tickerRef.current) {
+      window.clearInterval(tickerRef.current);
+      tickerRef.current = null;
+    }
+  };
+  const insertText = react.useCallback(
+    (text) => {
+      editor.update(() => {
+        const sel = lexical.$getSelection();
+        if (lexical.$isRangeSelection(sel)) {
+          sel.insertText(text);
+        }
+      });
+    },
+    [editor]
+  );
+  const startSpeech = (Recognition) => {
+    const rec = new Recognition();
+    rec.continuous = false;
+    rec.interimResults = true;
+    rec.lang = navigator.language || "en-US";
+    let finalBuffer = "";
+    rec.onresult = (event) => {
+      let interim = "";
+      for (let i = event.resultIndex; i < event.results.length; i++) {
+        const result = event.results[i];
+        const transcript = result[0].transcript;
+        if (result.isFinal) {
+          finalBuffer += transcript;
+        } else {
+          interim += transcript;
+        }
+      }
+      if (finalBuffer.trim().length > 0) {
+        insertText(finalBuffer + (interim ? "" : " "));
+        finalBuffer = "";
+      }
+    };
+    rec.onerror = () => {
+      stopTicker();
+      setState("idle");
+    };
+    rec.onend = () => {
+      stopTicker();
+      setState("idle");
+    };
+    recognitionRef.current = rec;
+    setState("recording");
+    startTicker();
+    rec.start();
+  };
+  const startMediaRecorder = async () => {
+    try {
+      const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      const rec = new MediaRecorder(stream);
+      chunksRef.current = [];
+      rec.ondataavailable = (e) => {
+        if (e.data.size > 0) chunksRef.current.push(e.data);
+      };
+      rec.onstop = () => {
+        const blob = new Blob(chunksRef.current, { type: "audio/webm" });
+        const file = new File([blob], `voice-${Date.now()}.webm`, {
+          type: "audio/webm"
+        });
+        addFiles([file]);
+        stream.getTracks().forEach((t) => t.stop());
+        stopTicker();
+        setState("idle");
+      };
+      mediaRef.current = rec;
+      rec.start();
+      setState("recording");
+      startTicker();
+    } catch {
+      stopTicker();
+      setState("idle");
+    }
+  };
+  const start = async () => {
+    setState("starting");
+    const Recognition = getSpeechRecognition();
+    if (Recognition) {
+      try {
+        startSpeech(Recognition);
+        return;
+      } catch {
+      }
+    }
+    await startMediaRecorder();
+  };
+  const stop = () => {
+    setState("transcribing");
+    try {
+      recognitionRef.current?.stop();
+    } catch {
+    }
+    try {
+      mediaRef.current?.stop();
+    } catch {
+    }
+  };
+  const isRecording = state === "recording" || state === "starting";
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-1.5", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Tooltip,
+      {
+        content: isRecording ? "Stop recording" : "Voice input",
+        side: "top",
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          "button",
+          {
+            type: "button",
+            "aria-label": isRecording ? "Stop voice recording" : "Start voice input",
+            "aria-pressed": isRecording,
+            onClick: () => isRecording ? stop() : void start(),
+            className: cn(
+              "flex h-8 w-8 items-center justify-center rounded-full transition-colors",
+              isRecording ? "bg-destructive/10 text-destructive ring-1 ring-destructive/40" : "text-muted-foreground hover:bg-accent hover:text-foreground",
+              classNames?.toolbarButton
+            ),
+            children: state === "transcribing" ? /* @__PURE__ */ jsxRuntime.jsx(VoiceRecordingIcon, { className: "h-4 w-4 animate-spin" }) : /* @__PURE__ */ jsxRuntime.jsx(VoiceIcon, { className: cn("h-4 w-4", isRecording && "animate-pulse") })
+          }
+        )
+      }
+    ),
+    isRecording && /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "flex items-center gap-1 rounded-full bg-destructive/10 px-2 py-0.5 text-[11px] font-mono font-medium tabular-nums text-destructive", children: [
+      /* @__PURE__ */ jsxRuntime.jsx("span", { className: "h-1.5 w-1.5 animate-pulse rounded-full bg-destructive" }),
+      formatSeconds(elapsed)
+    ] })
+  ] });
+}
+function AttachmentTypePicker({
+  types,
+  addFiles,
+  triggerClassName,
+  triggerStyle,
+  TriggerIcon
+}) {
+  const { closeMenusOnOutsideClick } = useComposerContext();
+  const [open, setOpen] = react.useState(false);
+  const [activeIndex, setActiveIndex] = react.useState(0);
+  const triggerRef = react.useRef(null);
+  const popoverRef = react.useRef(null);
+  const fileInputRef = react.useRef(null);
+  const itemRefs = react.useRef([]);
+  const menuId = react.useId();
+  const close = react.useCallback(() => setOpen(false), []);
+  const triggerPicker = react.useCallback(
+    (type) => {
+      const input = fileInputRef.current;
+      if (!input) return;
+      input.accept = type.accept;
+      input.click();
+    },
+    []
+  );
+  const pick = react.useCallback(
+    (index) => {
+      const type = types[index];
+      if (!type) return;
+      close();
+      triggerRef.current?.focus();
+      triggerPicker(type);
+    },
+    [types, close, triggerPicker]
+  );
+  react.useEffect(() => {
+    if (!open || !closeMenusOnOutsideClick) return;
+    const onPointerDown = (event) => {
+      const target = event.target;
+      if (!target) return;
+      if (popoverRef.current?.contains(target)) return;
+      if (triggerRef.current?.contains(target)) return;
+      close();
+    };
+    document.addEventListener("pointerdown", onPointerDown, true);
+    return () => document.removeEventListener("pointerdown", onPointerDown, true);
+  }, [open, closeMenusOnOutsideClick, close]);
+  react.useEffect(() => {
+    if (!open) return;
+    const onKeyDown = (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        close();
+        triggerRef.current?.focus();
+        return;
+      }
+      if (event.key === "ArrowDown") {
+        event.preventDefault();
+        setActiveIndex((i) => (i + 1) % types.length);
+        return;
+      }
+      if (event.key === "ArrowUp") {
+        event.preventDefault();
+        setActiveIndex((i) => (i - 1 + types.length) % types.length);
+        return;
+      }
+      if (event.key === "Home") {
+        event.preventDefault();
+        setActiveIndex(0);
+        return;
+      }
+      if (event.key === "End") {
+        event.preventDefault();
+        setActiveIndex(types.length - 1);
+        return;
+      }
+      if (event.key === "Enter" || event.key === " ") {
+        if (popoverRef.current?.contains(document.activeElement)) {
+          event.preventDefault();
+          pick(activeIndex);
+        }
+      }
+    };
+    document.addEventListener("keydown", onKeyDown);
+    return () => document.removeEventListener("keydown", onKeyDown);
+  }, [open, types.length, activeIndex, pick, close]);
+  react.useEffect(() => {
+    if (!open) return;
+    itemRefs.current[activeIndex]?.focus();
+  }, [open, activeIndex]);
+  react.useEffect(() => {
+    if (open) setActiveIndex(0);
+  }, [open]);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "relative", children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        ref: fileInputRef,
+        type: "file",
+        multiple: true,
+        hidden: true,
+        onChange: (e) => {
+          const files = e.target.files;
+          if (files && files.length > 0) addFiles(Array.from(files));
+          if (fileInputRef.current) fileInputRef.current.value = "";
+        }
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        ref: triggerRef,
+        type: "button",
+        "aria-label": "Attach file",
+        "aria-haspopup": "menu",
+        "aria-expanded": open,
+        "aria-controls": open ? menuId : void 0,
+        onClick: () => setOpen((o) => !o),
+        className: triggerClassName,
+        style: triggerStyle,
+        children: /* @__PURE__ */ jsxRuntime.jsx(TriggerIcon, { className: "h-4 w-4" })
+      }
+    ),
+    open && /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        ref: popoverRef,
+        id: menuId,
+        role: "menu",
+        "aria-label": "Attachment types",
+        "data-composer-popover": "open",
+        className: cn(
+          "composer-popover-in absolute bottom-full start-0 z-30 mb-2 min-w-[200px] overflow-hidden",
+          "rounded-xl border border-border bg-popover p-1 text-popover-foreground",
+          "shadow-soft"
+        ),
+        children: types.map((type, index) => {
+          const active = index === activeIndex;
+          return /* @__PURE__ */ jsxRuntime.jsxs(
+            "button",
+            {
+              ref: (el) => {
+                itemRefs.current[index] = el;
+              },
+              role: "menuitem",
+              type: "button",
+              tabIndex: active ? 0 : -1,
+              onMouseEnter: () => setActiveIndex(index),
+              onClick: () => pick(index),
+              className: cn(
+                "flex w-full items-center gap-2.5 rounded-lg px-2.5 py-1.5 text-start text-sm transition-colors",
+                active ? "bg-accent text-accent-foreground" : "text-foreground hover:bg-accent/60"
+              ),
+              children: [
+                type.icon ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: "flex h-5 w-5 shrink-0 items-center justify-center text-muted-foreground", children: type.icon }) : null,
+                /* @__PURE__ */ jsxRuntime.jsx("span", { className: "min-w-0 flex-1 truncate font-medium", children: type.label }),
+                type.description ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: "shrink-0 font-mono text-[11px] text-muted-foreground", children: type.description }) : null
+              ]
+            },
+            type.id
+          );
+        })
+      }
+    )
+  ] });
+}
+var TOOLBAR_BTN_BASE = "flex h-8 w-8 items-center justify-center rounded-full text-muted-foreground transition-colors hover:bg-accent hover:text-foreground";
+function Toolbar({ extras }) {
+  const {
+    features,
+    attachmentsConfig,
+    addFiles,
+    webEnabled,
+    toggleWeb,
+    icons,
+    classNames,
+    sx
+  } = useComposerContext();
+  const { attach: AttachIcon, image: ImageIcon, web: WebIcon } = icons;
+  const fileInputRef = react.useRef(null);
+  const imageInputRef = react.useRef(null);
+  const attachmentsEnabled = !!features.attachments;
+  const showFileBtn = attachmentsEnabled && attachmentsConfig.file !== false;
+  const showImageBtn = attachmentsEnabled && attachmentsConfig.image !== false;
+  const hasTypePicker = showFileBtn && Array.isArray(attachmentsConfig.types) && attachmentsConfig.types.length > 0;
+  const toolbar = slotProps("toolbar", "flex items-center gap-1", classNames, sx);
+  const toolbarBtn = slotProps("toolbarButton", TOOLBAR_BTN_BASE, classNames, sx);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { ...toolbar, children: [
+    showFileBtn && !hasTypePicker && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          ref: fileInputRef,
+          type: "file",
+          multiple: true,
+          accept: attachmentsConfig.accept,
+          hidden: true,
+          onChange: (e) => {
+            const files = e.target.files;
+            if (files) addFiles(Array.from(files));
+            if (fileInputRef.current) fileInputRef.current.value = "";
+          }
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(Tooltip, { content: "Attach file", side: "top", children: /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          "aria-label": "Attach file",
+          onClick: () => fileInputRef.current?.click(),
+          ...toolbarBtn,
+          children: /* @__PURE__ */ jsxRuntime.jsx(AttachIcon, { className: "h-4 w-4" })
+        }
+      ) })
+    ] }),
+    hasTypePicker && attachmentsConfig.types && /* @__PURE__ */ jsxRuntime.jsx(
+      AttachmentTypePicker,
+      {
+        types: attachmentsConfig.types,
+        addFiles,
+        triggerClassName: toolbarBtn.className ?? "",
+        triggerStyle: toolbarBtn.style,
+        TriggerIcon: AttachIcon
+      }
+    ),
+    showImageBtn && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          ref: imageInputRef,
+          type: "file",
+          multiple: true,
+          accept: "image/*",
+          hidden: true,
+          onChange: (e) => {
+            const files = e.target.files;
+            if (files) addFiles(Array.from(files));
+            if (imageInputRef.current) imageInputRef.current.value = "";
+          }
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(Tooltip, { content: "Add image", side: "top", children: /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          type: "button",
+          "aria-label": "Add image",
+          onClick: () => imageInputRef.current?.click(),
+          ...toolbarBtn,
+          children: /* @__PURE__ */ jsxRuntime.jsx(ImageIcon, { className: "h-4 w-4" })
+        }
+      ) })
+    ] }),
+    features.voice && /* @__PURE__ */ jsxRuntime.jsx(VoiceButton, {}),
+    features.web && /* @__PURE__ */ jsxRuntime.jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: toggleWeb,
+        "aria-pressed": webEnabled,
+        className: cn(
+          "ms-0.5 inline-flex h-8 items-center gap-1.5 rounded-full px-2.5 text-xs font-medium transition-colors",
+          webEnabled ? "bg-primary/10 text-primary" : "text-muted-foreground hover:bg-accent hover:text-foreground",
+          classNames?.toolbarButton
+        ),
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx(WebIcon, { className: "h-3.5 w-3.5" }),
+          "Web"
+        ]
+      }
+    ),
+    extras
+  ] });
+}
+function SendButton({ canSend, isStreaming, onSend, onStop }) {
+  const { icons, classNames, sx, slots } = useComposerContext();
+  const { send: SendIcon, stop: StopIcon } = icons;
+  if (isStreaming) {
+    const stop = slotProps(
+      "stopButton",
+      "inline-flex h-9 w-9 items-center justify-center rounded-full bg-foreground text-background transition-transform hover:scale-105",
+      classNames,
+      sx
+    );
+    if (slots.stopButton) {
+      const Slot = slots.stopButton;
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        Slot,
+        {
+          onStop: onStop ?? noop,
+          className: stop.className,
+          style: stop.style
+        }
+      );
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", onClick: onStop, "aria-label": "Stop generating", ...stop, children: /* @__PURE__ */ jsxRuntime.jsx(StopIcon, { className: "h-3.5 w-3.5 fill-current" }) });
+  }
+  const send = slotProps(
+    "sendButton",
+    [
+      "inline-flex h-9 w-9 items-center justify-center rounded-full transition-all",
+      canSend ? "bg-foreground text-background shadow-sm hover:scale-105" : "bg-muted text-muted-foreground/60"
+    ],
+    classNames,
+    sx
+  );
+  if (slots.sendButton) {
+    const Slot = slots.sendButton;
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      Slot,
+      {
+        canSend,
+        onSend,
+        className: send.className,
+        style: send.style
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      type: "button",
+      onClick: onSend,
+      disabled: !canSend,
+      "aria-label": "Send message",
+      ...send,
+      children: /* @__PURE__ */ jsxRuntime.jsx(SendIcon, { className: "h-4 w-4", strokeWidth: 2.5 })
+    }
+  );
+}
+function noop() {
+}
+function Key({ children }) {
+  return /* @__PURE__ */ jsxRuntime.jsx("kbd", { className: "rounded border border-border bg-card px-1 py-0.5 font-mono text-[10px]", children });
+}
+function formatShortcut(spec) {
+  const parts = spec.split("+").map((s) => s.trim().toLowerCase()).filter(Boolean);
+  if (parts.length === 0) return null;
+  const labels = [];
+  for (const p of parts) {
+    switch (p) {
+      case "mod":
+        labels.push("\u2318/Ctrl");
+        break;
+      case "cmd":
+      case "command":
+      case "meta":
+      case "win":
+      case "super":
+        labels.push("\u2318");
+        break;
+      case "ctrl":
+      case "control":
+        labels.push("Ctrl");
+        break;
+      case "alt":
+      case "option":
+        labels.push("Alt");
+        break;
+      case "shift":
+        labels.push("Shift");
+        break;
+      default:
+        labels.push(p.length === 1 ? p.toUpperCase() : p);
+    }
+  }
+  return labels.join(" + ");
+}
+function HintBar({ hint }) {
+  const {
+    multiline,
+    submitOnEnter,
+    smartNewline,
+    focusShortcut,
+    classNames,
+    sx
+  } = useComposerContext();
+  const defaultShortcuts = react.useMemo(() => {
+    if (!multiline) {
+      if (!submitOnEnter) return null;
+      return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        "Press ",
+        /* @__PURE__ */ jsxRuntime.jsx(Key, { children: "Enter" }),
+        " to send."
+      ] });
+    }
+    if (smartNewline && submitOnEnter) {
+      return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        "Press ",
+        /* @__PURE__ */ jsxRuntime.jsx(Key, { children: "Enter" }),
+        " to send a single line,",
+        " ",
+        /* @__PURE__ */ jsxRuntime.jsx(Key, { children: "\u2318/Ctrl + Enter" }),
+        " to send once you've started a new line."
+      ] });
+    }
+    if (!submitOnEnter) {
+      return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        "Press ",
+        /* @__PURE__ */ jsxRuntime.jsx(Key, { children: "\u2318/Ctrl + Enter" }),
+        " to send, ",
+        /* @__PURE__ */ jsxRuntime.jsx(Key, { children: "Enter" }),
+        " for newline."
+      ] });
+    }
+    return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      "Press ",
+      /* @__PURE__ */ jsxRuntime.jsx(Key, { children: "Enter" }),
+      " to send, ",
+      /* @__PURE__ */ jsxRuntime.jsx(Key, { children: "Shift + Enter" }),
+      " for newline."
+    ] });
+  }, [multiline, submitOnEnter, smartNewline]);
+  const focusHint = react.useMemo(() => {
+    if (!focusShortcut) return null;
+    const label = formatShortcut(focusShortcut);
+    if (!label) return null;
+    return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      " ",
+      /* @__PURE__ */ jsxRuntime.jsx(Key, { children: label }),
+      " to jump back here."
+    ] });
+  }, [focusShortcut]);
+  if (!hint) return null;
+  const hintProps = slotProps(
+    "hint",
+    "text-center text-[11px] text-muted-foreground",
+    classNames,
+    sx
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx("p", { ...hintProps, children: hint === true ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    "AI can make mistakes \u2014 verify important info.",
+    defaultShortcuts ? /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "hidden sm:inline", children: [
+      " ",
+      defaultShortcuts
+    ] }) : null,
+    focusHint ? /* @__PURE__ */ jsxRuntime.jsx("span", { className: "hidden md:inline", children: focusHint }) : null
+  ] }) : hint });
+}
+var DEFAULT_MAX = 3;
+var HARD_CAP = 5;
+function pickDisplay(items, maxToShow, randomize) {
+  const cleaned = items.filter((s) => typeof s === "string" && s.length > 0);
+  if (cleaned.length === 0) return [];
+  const max = Math.min(Math.max(1, maxToShow ?? DEFAULT_MAX), HARD_CAP);
+  if (cleaned.length <= max) return cleaned;
+  if (randomize === false) return cleaned.slice(0, max);
+  const arr = [...cleaned];
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+  return arr.slice(0, max);
+}
+function QuickPrompts({ prompts }) {
+  const { runPrompt, icons } = useComposerContext();
+  const { sparkle: SparkleIcon } = icons;
+  const display = react.useMemo(
+    () => pickDisplay(prompts.items, prompts.maxToShow, prompts.randomize),
+    [prompts.items, prompts.maxToShow, prompts.randomize]
+  );
+  if (display.length === 0) return null;
+  const behavior = prompts.behavior ?? "sendValue";
+  const handleClick = (prompt) => {
+    prompts.onSelect?.(prompt);
+    runPrompt(prompt, behavior);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      role: "group",
+      "aria-label": "Quick prompts",
+      className: "flex flex-wrap items-center gap-2 px-1 pb-1",
+      children: display.map((p) => /* @__PURE__ */ jsxRuntime.jsxs(
+        "button",
+        {
+          type: "button",
+          onClick: () => handleClick(p),
+          title: p,
+          className: cn(
+            "group inline-flex max-w-full items-center gap-1.5 rounded-full",
+            "border border-border bg-card/60 px-3 py-1.5 text-xs",
+            "text-muted-foreground backdrop-blur transition-all",
+            "hover:-translate-y-px hover:border-primary/40 hover:bg-card",
+            "hover:text-foreground hover:shadow-sm",
+            "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary/40"
+          ),
+          children: [
+            /* @__PURE__ */ jsxRuntime.jsx(SparkleIcon, { className: "h-3 w-3 shrink-0 text-primary opacity-70 group-hover:opacity-100" }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { className: "truncate", style: { maxWidth: "32ch" }, children: p })
+          ]
+        },
+        p
+      ))
+    }
+  );
+}
+function useComposerHandle(ref, onSubmit) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const { addFiles } = useComposerContext();
+  react.useEffect(() => {
+    if (!ref) return;
+    const handle = {
+      focus: () => editor.focus(),
+      clear: () => {
+        editor.update(() => {
+          const root = lexical.$getRoot();
+          root.clear();
+          root.append(lexical.$createParagraphNode());
+        });
+      },
+      insert: (text) => {
+        editor.update(() => {
+          const root = lexical.$getRoot();
+          const isEmpty = root.getChildrenSize() === 0 || root.getChildrenSize() === 1 && root.getFirstChild()?.getTextContent() === "";
+          if (isEmpty) {
+            $seedInitialValue(text);
+          } else {
+            $insertTextWithParagraphBreaks(text);
+          }
+        });
+      },
+      submit: () => onSubmit(),
+      addAttachments: (files) => addFiles(files)
+    };
+    if (typeof ref === "function") {
+      ref(handle);
+      return () => ref(null);
+    }
+    ref.current = handle;
+    return () => {
+      ref.current = null;
+    };
+  }, [editor, ref, onSubmit, addFiles]);
+}
+
+// src/internal/shortcut.ts
+var MODIFIERS = /* @__PURE__ */ new Set([
+  "mod",
+  "cmd",
+  "command",
+  "meta",
+  "win",
+  "super",
+  "ctrl",
+  "control",
+  "alt",
+  "option",
+  "shift"
+]);
+function isMac() {
+  if (typeof navigator === "undefined") return false;
+  const platform = navigator.userAgentData?.platform ?? navigator.platform ?? navigator.userAgent;
+  return /mac|iphone|ipad|ipod/i.test(platform);
+}
+function parseShortcut(spec) {
+  const segments = spec.split("+").map((s) => s.trim().toLowerCase()).filter(Boolean);
+  if (segments.length === 0) return null;
+  const mac = isMac();
+  let mod = false;
+  let altMod = false;
+  let shift = false;
+  let alt = false;
+  let key = null;
+  for (const seg of segments) {
+    if (MODIFIERS.has(seg)) {
+      switch (seg) {
+        case "mod":
+          mod = true;
+          break;
+        case "cmd":
+        case "command":
+        case "meta":
+        case "win":
+        case "super":
+          if (mac) mod = true;
+          else altMod = true;
+          break;
+        case "ctrl":
+        case "control":
+          if (mac) altMod = true;
+          else mod = true;
+          break;
+        case "alt":
+        case "option":
+          alt = true;
+          break;
+        case "shift":
+          shift = true;
+          break;
+      }
+    } else {
+      key = seg;
+    }
+  }
+  if (!key) return null;
+  return { mod, altMod, shift, alt, key };
+}
+function matchesShortcut(parsed, event) {
+  const mac = isMac();
+  const platformMod = mac ? event.metaKey : event.ctrlKey;
+  const otherMod = mac ? event.ctrlKey : event.metaKey;
+  if (parsed.mod !== platformMod) return false;
+  if (parsed.altMod !== otherMod) return false;
+  if (parsed.shift !== event.shiftKey) return false;
+  if (parsed.alt !== event.altKey) return false;
+  const eventKey = event.key.length === 1 ? event.key.toLowerCase() : event.key.toLowerCase();
+  return eventKey === parsed.key;
+}
+var Composer = react.forwardRef(function Composer2(props, ref) {
+  const {
+    placeholder = "Send a message\u2026",
+    onSend,
+    onStop,
+    isStreaming,
+    autoFocus,
+    refocusOnSubmit = true,
+    focusShortcut = "mod+/",
+    initialValue,
+    className,
+    classNames,
+    sx,
+    style,
+    tokens,
+    color,
+    hint = true,
+    features,
+    toolbarExtras,
+    closeMenusOnOutsideClick = true,
+    mode = "markdown",
+    multiline = true,
+    submitOnEnter = true,
+    smartNewline = true,
+    icons,
+    slots,
+    renderDiagram,
+    prompts,
+    attachmentOptions,
+    dir
+  } = props;
+  const tokenStyle = react.useMemo(() => {
+    const derived = color ? deriveColorTokens(color) : null;
+    if (!derived && !tokens) return void 0;
+    return tokensToStyle({ ...derived, ...tokens });
+  }, [color, tokens]);
+  const root = slotProps("root", "space-y-2", classNames, sx);
+  const rootStyle = react.useMemo(
+    () => ({ ...tokenStyle, ...root.style, ...style }),
+    [tokenStyle, root.style, style]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    ComposerProvider,
+    {
+      features,
+      isStreaming,
+      closeMenusOnOutsideClick,
+      attachmentOptions,
+      mode,
+      multiline,
+      submitOnEnter,
+      smartNewline,
+      focusShortcut,
+      icons,
+      slots,
+      renderDiagram,
+      dir,
+      classNames,
+      sx,
+      tokenStyle,
+      children: /* @__PURE__ */ jsxRuntime.jsxs(
+        "div",
+        {
+          dir,
+          className: cn(root.className, className),
+          style: Object.keys(rootStyle).length ? rootStyle : void 0,
+          children: [
+            prompts && prompts.items.length > 0 ? /* @__PURE__ */ jsxRuntime.jsx(QuickPrompts, { prompts }) : null,
+            /* @__PURE__ */ jsxRuntime.jsx(
+              ComposerCard,
+              {
+                placeholder,
+                initialValue,
+                handleRef: ref,
+                onSend,
+                onStop,
+                autoFocus,
+                refocusOnSubmit,
+                focusShortcut,
+                isStreaming: !!isStreaming,
+                toolbarExtras,
+                mode,
+                multiline
+              }
+            ),
+            /* @__PURE__ */ jsxRuntime.jsx(HintBar, { hint })
+          ]
+        }
+      )
+    }
+  );
+});
+var BLOCK_PARAGRAPH_REPLACEMENT = {
+  replace: lexical.ParagraphNode,
+  with: () => new BlockParagraphNode(),
+  withKlass: BlockParagraphNode
+};
+var RICH_NODES = [
+  MentionNode,
+  MarkdownTokenNode,
+  BlockParagraphNode,
+  LinkTextNode,
+  BLOCK_PARAGRAPH_REPLACEMENT
+];
+var PLAIN_NODES = [MentionNode];
+function ComposerCard({
+  placeholder,
+  initialValue,
+  handleRef,
+  onSend,
+  onStop,
+  autoFocus,
+  refocusOnSubmit,
+  focusShortcut,
+  isStreaming,
+  toolbarExtras,
+  mode,
+  multiline
+}) {
+  const { webEnabled, isDraggingFiles, classNames, sx } = useComposerContext();
+  const card = slotProps(
+    "card",
+    [
+      "group relative border border-border bg-card shadow-soft transition-all focus-within:border-primary/40 focus-within:shadow-glow",
+      webEnabled && "ring-1 ring-primary/20",
+      isDraggingFiles && "ring-2 ring-primary/60"
+    ],
+    classNames,
+    sx
+  );
+  const initialConfig = react.useMemo(
+    () => ({
+      namespace: "composeai",
+      theme: composerTheme,
+      onError: (error) => {
+        console.error("[Composer]", error);
+      },
+      nodes: mode === "markdown" ? RICH_NODES : PLAIN_NODES,
+      editorState: initialValue ? void 0 : null
+    }),
+    [mode, initialValue]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs(
+    "div",
+    {
+      "data-composer-root": "",
+      "data-composer-inline": multiline ? void 0 : "",
+      ...card,
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            "aria-hidden": true,
+            "data-composer-overlay": "",
+            className: "pointer-events-none absolute inset-0 opacity-0 transition-opacity group-focus-within:opacity-100",
+            style: {
+              background: "linear-gradient(135deg, hsl(var(--primary)/0.08) 0%, transparent 40%, hsl(var(--primary)/0.06) 100%)"
+            }
+          }
+        ),
+        isDraggingFiles && /* @__PURE__ */ jsxRuntime.jsx(
+          "div",
+          {
+            "aria-hidden": true,
+            "data-composer-overlay": "",
+            className: "pointer-events-none absolute inset-0 z-10 flex items-center justify-center bg-primary/5 text-sm font-medium text-primary backdrop-blur-[1px]",
+            children: "Drop to attach"
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(LexicalComposer.LexicalComposer, { initialConfig, children: /* @__PURE__ */ jsxRuntime.jsx(
+          ComposerInner,
+          {
+            placeholder,
+            mode,
+            multiline,
+            handleRef,
+            onSend,
+            onStop,
+            autoFocus,
+            refocusOnSubmit,
+            focusShortcut,
+            isStreaming,
+            toolbarExtras,
+            initialValue
+          }
+        ) })
+      ]
+    }
+  );
+}
+function ComposerInner({
+  placeholder,
+  mode,
+  multiline,
+  handleRef,
+  onSend,
+  onStop,
+  autoFocus,
+  refocusOnSubmit,
+  focusShortcut,
+  isStreaming,
+  toolbarExtras,
+  initialValue
+}) {
+  const [editor] = LexicalComposerContext.useLexicalComposerContext();
+  const {
+    features,
+    attachments,
+    clearAttachments,
+    registerRunPrompt,
+    attachmentOptions
+  } = useComposerContext();
+  const canSendOnlyAttachment = attachmentOptions.canSendOnlyAttachment !== false;
+  const hasUploadingAttachment = attachments.some((a) => a.status === "uploading");
+  const hasFailedAttachment = attachments.some((a) => a.status === "failed");
+  const uploadsBlocking = hasUploadingAttachment || hasFailedAttachment;
+  const markdownEnabled = mode === "markdown" && features.markdown;
+  const [hasText, setHasText] = react.useState(
+    !!initialValue && initialValue.trim().length > 0
+  );
+  const onSendRef = react.useRef(onSend);
+  onSendRef.current = onSend;
+  const refocusOnSubmitRef = react.useRef(refocusOnSubmit);
+  refocusOnSubmitRef.current = refocusOnSubmit;
+  const submit = react.useCallback(() => {
+    if (isStreaming) return;
+    if (uploadsBlocking) return;
+    let payload = null;
+    editor.getEditorState().read(() => {
+      const { text, mentions } = collectPlainAndMentions(editor);
+      const markdown = toMarkdown(editor);
+      const trimmed = text.trim();
+      if (!trimmed) {
+        if (attachments.length === 0) return;
+        if (!canSendOnlyAttachment) return;
+      }
+      payload = {
+        text: trimmed,
+        markdown,
+        attachments: [...attachments],
+        mentions
+      };
+    });
+    if (!payload) return;
+    onSendRef.current?.(payload);
+    editor.update(
+      () => {
+        const root = lexical.$getRoot();
+        root.clear();
+        root.append(lexical.$createParagraphNode());
+      },
+      {
+        onUpdate: () => {
+          if (refocusOnSubmitRef.current) {
+            focusEditor(editor);
+          } else {
+            const root = editor.getRootElement();
+            if (root) root.blur();
+          }
+        }
+      }
+    );
+    clearAttachments();
+  }, [
+    editor,
+    attachments,
+    clearAttachments,
+    isStreaming,
+    canSendOnlyAttachment,
+    uploadsBlocking
+  ]);
+  useComposerHandle(handleRef, submit);
+  react.useEffect(() => {
+    if (!focusShortcut) return;
+    const parsed = parseShortcut(focusShortcut);
+    if (!parsed) return;
+    const onKey = (e) => {
+      if (!matchesShortcut(parsed, e)) return;
+      if (e.defaultPrevented) return;
+      e.preventDefault();
+      focusEditor(editor);
+    };
+    window.addEventListener("keydown", onKey);
+    return () => window.removeEventListener("keydown", onKey);
+  }, [editor, focusShortcut]);
+  const seededRef = react.useRef(false);
+  react.useEffect(() => {
+    if (seededRef.current) return;
+    seededRef.current = true;
+    if (!initialValue) return;
+    editor.update(() => {
+      $seedInitialValue(initialValue);
+    });
+  }, [editor, initialValue]);
+  react.useEffect(() => {
+    return editor.registerUpdateListener(() => {
+      editor.getEditorState().read(() => {
+        const text = lexical.$getRoot().getTextContent().trim();
+        setHasText(text.length > 0);
+      });
+    });
+  }, [editor]);
+  react.useEffect(() => {
+    return registerRunPrompt((prompt, behavior) => {
+      editor.update(() => {
+        $seedInitialValue(prompt);
+      });
+      if (behavior === "sendValue") {
+        queueMicrotask(() => submit());
+      } else {
+        focusEditor(editor);
+      }
+    });
+  }, [editor, registerRunPrompt, submit]);
+  const toolbarSlot = /* @__PURE__ */ jsxRuntime.jsx(Toolbar, { extras: toolbarExtras });
+  const sendButtonSlot = /* @__PURE__ */ jsxRuntime.jsx(
+    SendButton,
+    {
+      canSend: (
+        // Same gate as `submit`, kept in sync so the disabled state is
+        // never out of step with what would actually happen on click.
+        !uploadsBlocking && (hasText || attachments.length > 0 && canSendOnlyAttachment)
+      ),
+      isStreaming,
+      onSend: submit,
+      onStop
+    }
+  );
+  return /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      EditorShell,
+      {
+        placeholder,
+        mode,
+        multiline,
+        header: /* @__PURE__ */ jsxRuntime.jsx(AttachmentTray, {}),
+        toolbar: toolbarSlot,
+        sendButton: sendButtonSlot,
+        footer: multiline ? /* @__PURE__ */ jsxRuntime.jsx(MermaidSlot, {}) : null
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(KeyboardPlugin, { onSubmit: submit }),
+    /* @__PURE__ */ jsxRuntime.jsx(AutoFocusPlugin, { enabled: !!autoFocus }),
+    /* @__PURE__ */ jsxRuntime.jsx(PasteDropPlugin, {}),
+    markdownEnabled && /* @__PURE__ */ jsxRuntime.jsx(MarkdownPlugin, {}),
+    features.slashCommands && /* @__PURE__ */ jsxRuntime.jsx(
+      SlashCommandPlugin,
+      {
+        config: features.slashCommands,
+        onSubmit: submit
+      }
+    ),
+    features.mentions && /* @__PURE__ */ jsxRuntime.jsx(MentionPlugin, { config: features.mentions }),
+    features.ghostedAutoComplete && /* @__PURE__ */ jsxRuntime.jsx(GhostedAutoCompletePlugin, { config: features.ghostedAutoComplete })
+  ] });
+}
+function MermaidSlot() {
+  const { features, mode } = useComposerContext();
+  if (mode !== "markdown" || !features.mermaid) return null;
+  return /* @__PURE__ */ jsxRuntime.jsx(MermaidPlugin, {});
+}
+function SuggestionRow({ items, onSelect, className }) {
+  const { icons } = useComposerContext();
+  const { sparkle: SparkleIcon } = icons;
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn("flex flex-wrap justify-center gap-2", className), children: items.map((s) => /* @__PURE__ */ jsxRuntime.jsxs(
+    "button",
+    {
+      type: "button",
+      onClick: () => onSelect(s),
+      className: "group inline-flex items-center gap-1.5 rounded-full border border-border bg-card/60 px-3.5 py-1.5 text-xs text-muted-foreground backdrop-blur transition-all hover:-translate-y-px hover:border-primary/40 hover:bg-card hover:text-foreground hover:shadow-sm",
+      children: [
+        /* @__PURE__ */ jsxRuntime.jsx(SparkleIcon, { className: "h-3 w-3 text-primary opacity-70 group-hover:opacity-100" }),
+        s
+      ]
+    },
+    s
+  )) });
+}
+
+exports.Composer = Composer;
+exports.SuggestionRow = SuggestionRow;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map