prompt-area 0.1.0 → 0.3.0

package/dist/chunk-E7HUXORB.js

@@ -1,2692 +0,0 @@
-'use client';
-import { cn } from './chunk-NF2LHZIE.js';
-import { useRef, useState, useCallback, useEffect, useMemo, useImperativeHandle } from 'react';
-import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
-
-// src/prompt-area/prompt-area-engine.ts
-function segmentsToPlainText(segments) {
-  return segments.map((seg) => {
-    if (seg.type === "text") return seg.text;
-    return `${seg.trigger}${seg.displayText}`;
-  }).join("");
-}
-function plainTextToSegments(text) {
-  if (!text) return [];
-  return [{ type: "text", text }];
-}
-function isValidTriggerPosition(text, charIndex, position) {
-  if (charIndex === 0) return true;
-  const prevChar = text[charIndex - 1];
-  if (position === "start") {
-    return prevChar === "\n";
-  }
-  return prevChar === " " || prevChar === "\n" || prevChar === "	";
-}
-function detectActiveTrigger(text, cursorPos, triggers) {
-  if (!text || cursorPos === 0 || triggers.length === 0) return null;
-  for (let i = cursorPos - 1; i >= 0; i--) {
-    const char = text[i];
-    if (char === " " || char === "\n" || char === "	") {
-      if (i + 1 < cursorPos) {
-        const nextChar = text[i + 1];
-        const matchingTrigger2 = triggers.find((t) => t.char === nextChar);
-        if (matchingTrigger2 && isValidTriggerPosition(text, i + 1, matchingTrigger2.position)) {
-          return {
-            config: matchingTrigger2,
-            startOffset: i + 1,
-            query: text.slice(i + 2, cursorPos)
-          };
-        }
-      }
-      return null;
-    }
-    const matchingTrigger = triggers.find((t) => t.char === char);
-    if (matchingTrigger && isValidTriggerPosition(text, i, matchingTrigger.position)) {
-      return {
-        config: matchingTrigger,
-        startOffset: i,
-        query: text.slice(i + 1, cursorPos)
-      };
-    }
-  }
-  return null;
-}
-function resolveChip(segments, activeTrigger, chip) {
-  const triggerStart = activeTrigger.startOffset;
-  const triggerEnd = triggerStart + 1 + activeTrigger.query.length;
-  const newSegments = [];
-  let offset = 0;
-  for (const seg of segments) {
-    if (seg.type === "chip") {
-      const chipText = `${seg.trigger}${seg.displayText}`;
-      const chipStart = offset;
-      const chipEnd = offset + chipText.length;
-      if (chipEnd <= triggerStart || chipStart >= triggerEnd) {
-        newSegments.push(seg);
-      }
-      offset = chipEnd;
-    } else {
-      const textStart = offset;
-      const textEnd = offset + seg.text.length;
-      if (textEnd <= triggerStart) {
-        newSegments.push(seg);
-      } else if (textStart >= triggerEnd) {
-        newSegments.push(seg);
-      } else {
-        const beforeText = seg.text.slice(0, Math.max(0, triggerStart - textStart));
-        const afterText = seg.text.slice(Math.min(seg.text.length, triggerEnd - textStart));
-        if (beforeText) {
-          newSegments.push({ type: "text", text: beforeText });
-        }
-        const newChip = {
-          type: "chip",
-          trigger: activeTrigger.config.char,
-          value: chip.value,
-          displayText: chip.displayText,
-          ...chip.data !== void 0 ? { data: chip.data } : {},
-          ...chip.autoResolved ? { autoResolved: true } : {}
-        };
-        newSegments.push(newChip);
-        if (afterText) {
-          newSegments.push({ type: "text", text: " " + afterText.replace(/^\s/, "") });
-        } else {
-          newSegments.push({ type: "text", text: " " });
-        }
-      }
-      offset = textEnd;
-    }
-  }
-  const merged = mergeAdjacentTextSegments(newSegments);
-  let lastChipEndOffset = -1;
-  let runningOffset = 0;
-  for (const seg of merged) {
-    if (seg.type === "text") {
-      runningOffset += seg.text.length;
-    } else {
-      runningOffset += seg.trigger.length + seg.displayText.length;
-      if (seg.value === chip.value && seg.displayText === chip.displayText && seg.trigger === activeTrigger.config.char) {
-        lastChipEndOffset = runningOffset;
-      }
-    }
-  }
-  const cursorOffset = lastChipEndOffset === -1 ? runningOffset : lastChipEndOffset + 1;
-  return { segments: merged, cursorOffset };
-}
-function removeChipAtIndex(segments, index) {
-  if (index < 0 || index >= segments.length) return segments;
-  if (segments[index].type !== "chip") return segments;
-  const result = [...segments.slice(0, index), ...segments.slice(index + 1)];
-  return mergeAdjacentTextSegments(result);
-}
-function revertChipAtIndex(segments, index) {
-  if (index < 0 || index >= segments.length) return null;
-  const seg = segments[index];
-  if (seg.type !== "chip" || !seg.autoResolved) return null;
-  const revertedText = `${seg.trigger}${seg.displayText}`;
-  const result = [
-    ...segments.slice(0, index),
-    { type: "text", text: revertedText },
-    ...segments.slice(index + 1)
-  ];
-  return { segments: mergeAdjacentTextSegments(result), revertedText };
-}
-function resolveTriggersInSegments(segments, triggers) {
-  const autoResolveTriggers = triggers.filter((t) => t.resolveOnSpace);
-  if (autoResolveTriggers.length === 0) return segments;
-  const triggerChars = new Set(autoResolveTriggers.map((t) => t.char));
-  const result = [];
-  for (const seg of segments) {
-    if (seg.type === "chip") {
-      result.push(seg);
-      continue;
-    }
-    const parts = splitTextByTriggerPatterns(seg.text, autoResolveTriggers, triggerChars);
-    result.push(...parts);
-  }
-  return mergeAdjacentTextSegments(result);
-}
-function splitTextByTriggerPatterns(text, triggers, triggerChars) {
-  if (!text) return [];
-  const segments = [];
-  let i = 0;
-  while (i < text.length) {
-    const char = text[i];
-    if (triggerChars.has(char)) {
-      const isAtBoundary = i === 0 || text[i - 1] === " " || text[i - 1] === "\n" || text[i - 1] === "	";
-      if (isAtBoundary) {
-        const trigger = triggers.find((t) => t.char === char);
-        if (trigger && isValidTriggerPosition(text, i, trigger.position)) {
-          let end = i + 1;
-          while (end < text.length && text[end] !== " " && text[end] !== "\n" && text[end] !== "	") {
-            end++;
-          }
-          const query = text.slice(i + 1, end);
-          if (query.length > 0) {
-            const displayText = trigger.onSelect?.({ value: query, label: query }) || query;
-            segments.push({
-              type: "chip",
-              trigger: char,
-              value: query,
-              displayText,
-              autoResolved: true
-            });
-            i = end;
-            continue;
-          }
-        }
-      }
-    }
-    const start = i;
-    i++;
-    while (i < text.length && !(triggerChars.has(text[i]) && (text[i - 1] === " " || text[i - 1] === "\n" || text[i - 1] === "	"))) {
-      i++;
-    }
-    segments.push({ type: "text", text: text.slice(start, i) });
-  }
-  return segments;
-}
-function replaceTextRange(segments, start, end, replacement) {
-  const newSegments = [];
-  let offset = 0;
-  let inserted = false;
-  for (const seg of segments) {
-    if (seg.type === "chip") {
-      const chipText = `${seg.trigger}${seg.displayText}`;
-      const chipStart = offset;
-      const chipEnd = offset + chipText.length;
-      if (!inserted && start === end && chipStart === start) {
-        newSegments.push({ type: "text", text: replacement });
-        inserted = true;
-      }
-      if (chipEnd <= start || chipStart >= end) {
-        newSegments.push(seg);
-      }
-      offset = chipEnd;
-    } else {
-      const textStart = offset;
-      const textEnd = offset + seg.text.length;
-      const isBefore = start === end ? textEnd < start : textEnd <= start;
-      const isAfter = start === end ? textStart > end : textStart >= end;
-      if (isBefore) {
-        newSegments.push(seg);
-      } else if (isAfter) {
-        newSegments.push(seg);
-      } else {
-        const beforeText = seg.text.slice(0, Math.max(0, start - textStart));
-        const afterText = seg.text.slice(Math.min(seg.text.length, end - textStart));
-        if (beforeText) {
-          newSegments.push({ type: "text", text: beforeText });
-        }
-        if (!inserted && textStart <= start) {
-          newSegments.push({ type: "text", text: replacement });
-          inserted = true;
-        }
-        if (afterText) {
-          newSegments.push({ type: "text", text: afterText });
-        }
-      }
-      offset = textEnd;
-    }
-  }
-  if (!inserted && replacement) {
-    newSegments.push({ type: "text", text: replacement });
-  }
-  return mergeAdjacentTextSegments(newSegments);
-}
-function toggleMarkdownWrap(segments, selectionStart, selectionEnd, marker) {
-  if (selectionStart === selectionEnd) return null;
-  const plainText = segmentsToPlainText(segments);
-  const markerLen = marker.length;
-  const hasOpeningMarker = selectionStart >= markerLen && plainText.slice(selectionStart - markerLen, selectionStart) === marker;
-  const hasClosingMarker = selectionEnd + markerLen <= plainText.length && plainText.slice(selectionEnd, selectionEnd + markerLen) === marker;
-  let isWrapped = hasOpeningMarker && hasClosingMarker;
-  if (isWrapped && markerLen === 1) {
-    const charBeforeOpening = selectionStart > markerLen ? plainText[selectionStart - markerLen - 1] : "";
-    const charAfterClosing = selectionEnd + markerLen < plainText.length ? plainText[selectionEnd + markerLen] : "";
-    if (charBeforeOpening === marker || charAfterClosing === marker) {
-      isWrapped = false;
-    }
-  }
-  if (isWrapped) {
-    const afterClosing2 = replaceTextRange(segments, selectionEnd, selectionEnd + markerLen, "");
-    const afterOpening2 = replaceTextRange(
-      afterClosing2,
-      selectionStart - markerLen,
-      selectionStart,
-      ""
-    );
-    return {
-      segments: afterOpening2,
-      selectionStart: selectionStart - markerLen,
-      selectionEnd: selectionEnd - markerLen
-    };
-  }
-  const afterClosing = replaceTextRange(segments, selectionEnd, selectionEnd, marker);
-  const afterOpening = replaceTextRange(afterClosing, selectionStart, selectionStart, marker);
-  return {
-    segments: afterOpening,
-    selectionStart: selectionStart + markerLen,
-    selectionEnd: selectionEnd + markerLen
-  };
-}
-function parseInlineMarkdown(text) {
-  if (!text) return [];
-  const tokens = [];
-  const pattern = /(\*{3}(.+?)\*{3})|(\*{2}(.+?)\*{2})|(\*(.+?)\*)|(https?:\/\/[^\s),]+)/g;
-  let lastIndex = 0;
-  let match;
-  while ((match = pattern.exec(text)) !== null) {
-    if (match.index > lastIndex) {
-      tokens.push({ type: "plain", text: text.slice(lastIndex, match.index) });
-    }
-    if (match[1] && match[2]) {
-      tokens.push({ type: "bold-italic", text: match[2] });
-    } else if (match[3] && match[4]) {
-      tokens.push({ type: "bold", text: match[4] });
-    } else if (match[5] && match[6]) {
-      tokens.push({ type: "italic", text: match[6] });
-    } else if (match[7]) {
-      tokens.push({ type: "url", text: match[7] });
-    }
-    lastIndex = match.index + match[0].length;
-  }
-  if (lastIndex < text.length) {
-    tokens.push({ type: "plain", text: text.slice(lastIndex) });
-  }
-  return tokens;
-}
-function segmentsEqual(a, b) {
-  if (a === b) return true;
-  if (a.length !== b.length) return false;
-  for (let i = 0; i < a.length; i++) {
-    const sa = a[i];
-    const sb = b[i];
-    if (sa.type !== sb.type) return false;
-    if (sa.type === "text") {
-      if (sb.type !== "text" || sa.text !== sb.text) return false;
-    } else {
-      if (sb.type !== "chip" || sa.trigger !== sb.trigger || sa.value !== sb.value || sa.displayText !== sb.displayText || sa.autoResolved !== sb.autoResolved)
-        return false;
-    }
-  }
-  return true;
-}
-function mergeAdjacentTextSegments(segments) {
-  const result = [];
-  for (const seg of segments) {
-    if (seg.type === "text" && seg.text === "") continue;
-    const last = result[result.length - 1];
-    if (seg.type === "text" && last?.type === "text") {
-      result[result.length - 1] = { type: "text", text: last.text + seg.text };
-    } else {
-      result.push(seg);
-    }
-  }
-  return result;
-}
-
-// src/prompt-area/prompt-area-list-ops.ts
-function getListContext(text, cursorPos) {
-  const lineStart = text.lastIndexOf("\n", cursorPos - 1) + 1;
-  const lineEnd = text.indexOf("\n", cursorPos);
-  const line = text.slice(lineStart, lineEnd === -1 ? text.length : lineEnd);
-  const bulletMatch = line.match(/^(\s*)([•\-*]) /);
-  if (bulletMatch) {
-    const indentStr = bulletMatch[1];
-    return {
-      lineStart,
-      prefix: bulletMatch[0],
-      indent: Math.floor(indentStr.length / 2),
-      listType: "bullet",
-      contentStart: lineStart + bulletMatch[0].length
-    };
-  }
-  const numberMatch = line.match(/^(\s*)(\d+)\. /);
-  if (numberMatch) {
-    const indentStr = numberMatch[1];
-    return {
-      lineStart,
-      prefix: numberMatch[0],
-      indent: Math.floor(indentStr.length / 2),
-      listType: "numbered",
-      number: parseInt(numberMatch[2], 10),
-      contentStart: lineStart + numberMatch[0].length
-    };
-  }
-  return null;
-}
-function autoFormatListPrefix(segments, cursorPos) {
-  const plainText = segmentsToPlainText(segments);
-  const lineStart = plainText.lastIndexOf("\n", cursorPos - 1) + 1;
-  const lineText = plainText.slice(lineStart, cursorPos);
-  const match = lineText.match(/^(\s*)[-*] $/);
-  if (!match) return null;
-  const indent = match[1];
-  const replacement = `${indent}\u2022 `;
-  const rangeStart = lineStart;
-  const rangeEnd = lineStart + lineText.length;
-  const newSegments = replaceTextRange(segments, rangeStart, rangeEnd, replacement);
-  return {
-    segments: newSegments,
-    cursorOffset: lineStart + replacement.length
-  };
-}
-function insertListContinuation(segments, cursorPos) {
-  const plainText = segmentsToPlainText(segments);
-  const ctx = getListContext(plainText, cursorPos);
-  if (!ctx) return null;
-  const lineEnd = plainText.indexOf("\n", cursorPos);
-  const lineContent = plainText.slice(ctx.contentStart, lineEnd === -1 ? plainText.length : lineEnd);
-  if (lineContent.trim() === "") {
-    const newSegments2 = replaceTextRange(
-      segments,
-      ctx.lineStart,
-      ctx.lineStart + ctx.prefix.length,
-      ""
-    );
-    return {
-      segments: newSegments2,
-      cursorOffset: ctx.lineStart
-    };
-  }
-  const indent = "  ".repeat(ctx.indent);
-  let nextPrefix;
-  if (ctx.listType === "bullet") {
-    nextPrefix = `${indent}\u2022 `;
-  } else {
-    const nextNum = (ctx.number ?? 1) + 1;
-    nextPrefix = `${indent}${nextNum}. `;
-  }
-  const insertion = `
-${nextPrefix}`;
-  const newSegments = replaceTextRange(segments, cursorPos, cursorPos, insertion);
-  return {
-    segments: newSegments,
-    cursorOffset: cursorPos + insertion.length
-  };
-}
-function indentListItem(segments, cursorPos) {
-  const plainText = segmentsToPlainText(segments);
-  const ctx = getListContext(plainText, cursorPos);
-  if (!ctx) return null;
-  const newSegments = replaceTextRange(segments, ctx.lineStart, ctx.lineStart, "  ");
-  return {
-    segments: newSegments,
-    cursorOffset: cursorPos + 2
-  };
-}
-function outdentListItem(segments, cursorPos) {
-  const plainText = segmentsToPlainText(segments);
-  const ctx = getListContext(plainText, cursorPos);
-  if (!ctx || ctx.indent === 0) return null;
-  const newSegments = replaceTextRange(segments, ctx.lineStart, ctx.lineStart + 2, "");
-  return {
-    segments: newSegments,
-    cursorOffset: Math.max(ctx.lineStart, cursorPos - 2)
-  };
-}
-function removeListPrefix(segments, cursorPos) {
-  const plainText = segmentsToPlainText(segments);
-  const ctx = getListContext(plainText, cursorPos);
-  if (!ctx) return null;
-  if (cursorPos > ctx.contentStart) return null;
-  const newSegments = replaceTextRange(
-    segments,
-    ctx.lineStart,
-    ctx.contentStart,
-    "  ".repeat(ctx.indent)
-  );
-  return {
-    segments: newSegments,
-    cursorOffset: ctx.lineStart + ctx.indent * 2
-  };
-}
-function normalizeListPrefixes(segments, markdownEnabled) {
-  let changed = false;
-  const result = segments.map((seg) => {
-    if (seg.type !== "text") return seg;
-    const newText = markdownEnabled ? seg.text.replace(/(^|\n)(\s*)- /g, "$1$2\u2022 ") : seg.text.replace(/(^|\n)(\s*)• /g, "$1$2- ");
-    if (newText === seg.text) return seg;
-    changed = true;
-    return { ...seg, text: newText };
-  });
-  return changed ? result : segments;
-}
-
-// src/prompt-area/dom-helpers.ts
-function isHTMLElement(node) {
-  return node instanceof HTMLElement;
-}
-function isChipElement(node) {
-  return node instanceof HTMLElement && node.dataset.chipTrigger !== void 0;
-}
-function isBRElement(node) {
-  return node instanceof HTMLBRElement;
-}
-function isTextNode(node) {
-  return node instanceof Text;
-}
-function getChipAutoResolved(node) {
-  return isChipElement(node) && node.dataset.chipAutoResolved === "true";
-}
-function isLinkElement(node) {
-  return node instanceof HTMLAnchorElement && node.dataset.url === "true";
-}
-function safeJsonParse(json) {
-  try {
-    const parsed = JSON.parse(json);
-    return parsed;
-  } catch {
-    return void 0;
-  }
-}
-function safeJsonStringify(value) {
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return void 0;
-  }
-}
-function getChipTrigger(node) {
-  if (!isChipElement(node)) return void 0;
-  return node.dataset.chipTrigger;
-}
-function getChipValue(node) {
-  if (!isChipElement(node)) return void 0;
-  return node.dataset.chipValue;
-}
-function getChipDisplay(node) {
-  if (!isChipElement(node)) return void 0;
-  return node.dataset.chipDisplay ?? node.textContent ?? void 0;
-}
-function getChipData(node) {
-  if (!isChipElement(node)) return void 0;
-  const raw = node.dataset.chipData;
-  if (!raw) return void 0;
-  return safeJsonParse(raw);
-}
-function indexOfChildNode(parent, child) {
-  const children = parent.childNodes;
-  for (let i = 0; i < children.length; i++) {
-    if (children[i] === child) return i;
-  }
-  return -1;
-}
-function getDirectChildContaining(ancestor, descendant) {
-  let node = descendant;
-  while (node !== null) {
-    if (node.parentNode === ancestor) return node;
-    node = node.parentNode;
-  }
-  return null;
-}
-function unwrapBlockElement(parent, block) {
-  const fragment = document.createDocumentFragment();
-  while (block.firstChild) {
-    fragment.appendChild(block.firstChild);
-  }
-  fragment.appendChild(document.createElement("br"));
-  parent.replaceChild(fragment, block);
-}
-function normalizeEditorDOM(editor) {
-  let changed = false;
-  const blockTags = /* @__PURE__ */ new Set(["DIV", "P", "SECTION", "ARTICLE", "BLOCKQUOTE"]);
-  for (let i = editor.childNodes.length - 1; i >= 0; i--) {
-    const child = editor.childNodes[i];
-    if (!(child instanceof HTMLElement)) continue;
-    if (child.dataset.chipTrigger !== void 0) continue;
-    if (child instanceof HTMLBRElement) continue;
-    const tag = child.tagName;
-    if (blockTags.has(tag)) {
-      unwrapBlockElement(editor, child);
-      changed = true;
-    } else if (tag === "FONT" || tag === "B" || tag === "I" || tag === "U" || tag === "STRONG" || tag === "EM" || tag === "A" || tag === "SPAN") {
-      const text = child.textContent ?? "";
-      if (text) {
-        editor.replaceChild(document.createTextNode(text), child);
-      } else {
-        editor.removeChild(child);
-      }
-      changed = true;
-    }
-  }
-  editor.normalize();
-  return changed;
-}
-var URL_PATTERN = /https?:\/\/[^\s),]+/g;
-function decorateURLsInEditor(editor) {
-  let decorated = false;
-  const textNodes = [];
-  for (let i = 0; i < editor.childNodes.length; i++) {
-    const node = editor.childNodes[i];
-    if (isTextNode(node) && node.textContent) {
-      textNodes.push(node);
-    }
-  }
-  for (const textNode of textNodes) {
-    const text = textNode.textContent ?? "";
-    URL_PATTERN.lastIndex = 0;
-    const matches = [];
-    let match;
-    while ((match = URL_PATTERN.exec(text)) !== null) {
-      let url = match[0];
-      while (url.length > 0 && /[.;:!?]$/.test(url)) {
-        url = url.slice(0, -1);
-      }
-      if (url.length > 0) {
-        matches.push({ url, index: match.index });
-      }
-    }
-    if (matches.length === 0) continue;
-    const parent = textNode.parentNode;
-    if (!parent) continue;
-    const safeMatches = [];
-    for (const { url, index } of matches) {
-      try {
-        const parsed = new URL(url);
-        if (parsed.protocol === "http:" || parsed.protocol === "https:") {
-          safeMatches.push({ url, href: parsed.href, index });
-        }
-      } catch {
-      }
-    }
-    if (safeMatches.length === 0) continue;
-    decorated = true;
-    const fragment = document.createDocumentFragment();
-    let lastIndex = 0;
-    for (const { url, href, index } of safeMatches) {
-      if (index > lastIndex) {
-        fragment.appendChild(document.createTextNode(text.slice(lastIndex, index)));
-      }
-      const anchor = document.createElement("a");
-      anchor.href = href;
-      anchor.target = "_blank";
-      anchor.rel = "noopener noreferrer";
-      anchor.dataset.url = "true";
-      anchor.className = "text-primary hover:text-primary/80 underline cursor-pointer";
-      anchor.textContent = url;
-      fragment.appendChild(anchor);
-      lastIndex = index + url.length;
-    }
-    if (lastIndex < text.length) {
-      fragment.appendChild(document.createTextNode(text.slice(lastIndex)));
-    }
-    parent.replaceChild(fragment, textNode);
-  }
-  return decorated;
-}
-var MARKDOWN_INLINE_PATTERN = /(\*{3})(.+?)\*{3}|(\*{2})(.+?)\*{2}|(\*)(.+?)\*/g;
-function decorateMarkdownInEditor(editor) {
-  let decorated = false;
-  const textNodes = [];
-  for (let i = 0; i < editor.childNodes.length; i++) {
-    const node = editor.childNodes[i];
-    if (isTextNode(node) && node.textContent) {
-      textNodes.push(node);
-    }
-  }
-  for (const textNode of textNodes) {
-    const text = textNode.textContent ?? "";
-    MARKDOWN_INLINE_PATTERN.lastIndex = 0;
-    const matches = [];
-    let match;
-    while ((match = MARKDOWN_INLINE_PATTERN.exec(text)) !== null) {
-      if (match[1] && match[2]) {
-        matches.push({
-          fullMatch: match[0],
-          marker: match[1],
-          content: match[2],
-          index: match.index,
-          className: "font-bold italic"
-        });
-      } else if (match[3] && match[4]) {
-        matches.push({
-          fullMatch: match[0],
-          marker: match[3],
-          content: match[4],
-          index: match.index,
-          className: "font-bold"
-        });
-      } else if (match[5] && match[6]) {
-        matches.push({
-          fullMatch: match[0],
-          marker: match[5],
-          content: match[6],
-          index: match.index,
-          className: "italic"
-        });
-      }
-    }
-    if (matches.length === 0) continue;
-    decorated = true;
-    const parent = textNode.parentNode;
-    if (!parent) continue;
-    const fragment = document.createDocumentFragment();
-    let lastIndex = 0;
-    for (const { fullMatch, marker, content, index, className } of matches) {
-      if (index > lastIndex) {
-        fragment.appendChild(document.createTextNode(text.slice(lastIndex, index)));
-      }
-      const span = document.createElement("span");
-      span.dataset.md = "true";
-      const openMarker = document.createElement("span");
-      openMarker.className = "prompt-area-md-marker";
-      openMarker.textContent = marker;
-      const styledContent = document.createElement("span");
-      styledContent.className = className;
-      styledContent.textContent = content;
-      const closeMarker = document.createElement("span");
-      closeMarker.className = "prompt-area-md-marker";
-      closeMarker.textContent = marker;
-      span.appendChild(openMarker);
-      span.appendChild(styledContent);
-      span.appendChild(closeMarker);
-      fragment.appendChild(span);
-      lastIndex = index + fullMatch.length;
-    }
-    if (lastIndex < text.length) {
-      fragment.appendChild(document.createTextNode(text.slice(lastIndex)));
-    }
-    parent.replaceChild(fragment, textNode);
-  }
-  return decorated;
-}
-function getSelectionRange() {
-  const sel = window.getSelection();
-  if (!sel || sel.rangeCount === 0) return null;
-  return sel.getRangeAt(0);
-}
-
-// src/prompt-area/cursor-helpers.ts
-function saveCursorPosition(editor) {
-  const range = getSelectionRange();
-  if (!range) return null;
-  if (!editor.contains(range.startContainer)) return null;
-  const node = range.startContainer;
-  if (node === editor) {
-    return { nodeIndex: range.startOffset, offset: 0 };
-  }
-  const directChild = getDirectChildContaining(editor, node);
-  if (!directChild) return null;
-  const nodeIndex = indexOfChildNode(editor, directChild);
-  return { nodeIndex, offset: range.startOffset };
-}
-function restoreCursorPosition(editor, saved) {
-  const sel = window.getSelection();
-  if (!sel) return;
-  const childNodes = editor.childNodes;
-  if (childNodes.length === 0) return;
-  const range = document.createRange();
-  if (saved.nodeIndex >= childNodes.length) {
-    const lastChild = childNodes[childNodes.length - 1];
-    if (lastChild.nodeType === Node.TEXT_NODE) {
-      range.setStart(lastChild, (lastChild.textContent ?? "").length);
-    } else {
-      range.setStartAfter(lastChild);
-    }
-  } else {
-    const targetNode = childNodes[saved.nodeIndex];
-    if (targetNode.nodeType === Node.TEXT_NODE) {
-      const maxOffset = (targetNode.textContent ?? "").length;
-      range.setStart(targetNode, Math.min(saved.offset, maxOffset));
-    } else {
-      range.setStartAfter(targetNode);
-    }
-  }
-  range.collapse(true);
-  sel.removeAllRanges();
-  sel.addRange(range);
-}
-function getCursorOffset(editor) {
-  const range = getSelectionRange();
-  if (!range) return null;
-  if (!editor.contains(range.startContainer)) return null;
-  const preRange = document.createRange();
-  preRange.selectNodeContents(editor);
-  preRange.setEnd(range.startContainer, range.startOffset);
-  return getTextLengthInRange(preRange);
-}
-function createRangeAtOffset(editor, targetOffset) {
-  const pos = findDOMPosition(editor, targetOffset);
-  if (!pos) return null;
-  const range = document.createRange();
-  range.setStart(pos.node, pos.offset);
-  range.collapse(true);
-  return range;
-}
-function setCursorAtOffset(editor, targetOffset) {
-  const sel = window.getSelection();
-  if (!sel) return;
-  const pos = findDOMPosition(editor, targetOffset);
-  if (pos) {
-    const range2 = document.createRange();
-    range2.setStart(pos.node, pos.offset);
-    range2.collapse(true);
-    sel.removeAllRanges();
-    sel.addRange(range2);
-    return;
-  }
-  const range = document.createRange();
-  range.selectNodeContents(editor);
-  range.collapse(false);
-  sel.removeAllRanges();
-  sel.addRange(range);
-}
-function getTextLengthInRange(range) {
-  const fragment = range.cloneContents();
-  let length = 0;
-  const walk = (node) => {
-    if (node.nodeType === Node.TEXT_NODE) {
-      length += (node.textContent ?? "").length;
-    } else if (isChipElement(node)) {
-      const trigger = node.dataset.chipTrigger ?? "";
-      const display = node.dataset.chipDisplay ?? node.textContent ?? "";
-      length += trigger.length + display.length;
-    } else if (isHTMLElement(node) && node.tagName === "BR") {
-      if (node.dataset.sentinel) return;
-      length += 1;
-    } else if (isHTMLElement(node)) {
-      node.childNodes.forEach(walk);
-    }
-  };
-  fragment.childNodes.forEach(walk);
-  return length;
-}
-function getSelectionOffsets(editor) {
-  const range = getSelectionRange();
-  if (!range) return null;
-  if (!editor.contains(range.startContainer)) return null;
-  const startRange = document.createRange();
-  startRange.selectNodeContents(editor);
-  startRange.setEnd(range.startContainer, range.startOffset);
-  const start = getTextLengthInRange(startRange);
-  if (range.collapsed) return { start, end: start };
-  const endRange = document.createRange();
-  endRange.selectNodeContents(editor);
-  endRange.setEnd(range.endContainer, range.endOffset);
-  const end = getTextLengthInRange(endRange);
-  return { start, end };
-}
-function setSelectionAtOffsets(editor, startOffset, endOffset) {
-  const sel = window.getSelection();
-  if (!sel) return;
-  if (startOffset === endOffset) {
-    setCursorAtOffset(editor, startOffset);
-    return;
-  }
-  const startPos = findDOMPosition(editor, startOffset);
-  const endPos = findDOMPosition(editor, endOffset);
-  if (!startPos || !endPos) return;
-  const range = document.createRange();
-  range.setStart(startPos.node, startPos.offset);
-  range.setEnd(endPos.node, endPos.offset);
-  sel.removeAllRanges();
-  sel.addRange(range);
-}
-function findDOMPosition(container, targetOffset) {
-  let remaining = targetOffset;
-  for (let i = 0; i < container.childNodes.length; i++) {
-    const child = container.childNodes[i];
-    if (child.nodeType === Node.TEXT_NODE) {
-      const len = (child.textContent ?? "").length;
-      if (remaining <= len) {
-        return { node: child, offset: remaining };
-      }
-      remaining -= len;
-    } else if (isChipElement(child)) {
-      const trigger = child.dataset.chipTrigger ?? "";
-      const display = child.dataset.chipDisplay ?? child.textContent ?? "";
-      const chipLen = trigger.length + display.length;
-      if (remaining <= chipLen) {
-        return { node: container, offset: i + 1 };
-      }
-      remaining -= chipLen;
-    } else if (isBRElement(child)) {
-      if (child.dataset.sentinel) continue;
-      if (remaining <= 1) {
-        return { node: container, offset: i + 1 };
-      }
-      remaining -= 1;
-    } else if (isHTMLElement(child)) {
-      const textLen = (child.textContent ?? "").length;
-      if (remaining <= textLen) {
-        const result = findDOMPosition(child, remaining);
-        if (result) return result;
-      }
-      remaining -= textLen;
-    }
-  }
-  return { node: container, offset: container.childNodes.length };
-}
-
-// src/prompt-area/clipboard-helpers.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function serializeFragmentToPlainText(fragment) {
-  let text = "";
-  const walk = (node) => {
-    if (node.nodeType === Node.TEXT_NODE) {
-      text += node.textContent ?? "";
-    } else if (isChipElement(node)) {
-      const trigger = getChipTrigger(node) ?? "";
-      const display = getChipDisplay(node) ?? "";
-      text += trigger + display;
-    } else if (isHTMLElement(node) && node.tagName === "BR") {
-      text += "\n";
-    } else {
-      node.childNodes.forEach(walk);
-    }
-  };
-  fragment.childNodes.forEach(walk);
-  return text;
-}
-function serializeFragmentToSegments(fragment) {
-  const segments = [];
-  const walk = (node) => {
-    if (node.nodeType === Node.TEXT_NODE) {
-      const text = node.textContent ?? "";
-      if (text) {
-        segments.push({ type: "text", text });
-      }
-    } else if (isChipElement(node)) {
-      const trigger = getChipTrigger(node);
-      const chipValue = getChipValue(node);
-      const display = getChipDisplay(node);
-      const data = getChipData(node);
-      const autoResolved = getChipAutoResolved(node);
-      if (trigger && chipValue !== void 0 && display) {
-        const chip = {
-          type: "chip",
-          trigger,
-          value: chipValue,
-          displayText: display,
-          ...data !== void 0 ? { data } : {},
-          ...autoResolved ? { autoResolved: true } : {}
-        };
-        segments.push(chip);
-      }
-    } else if (isHTMLElement(node) && node.tagName === "BR") {
-      segments.push({ type: "text", text: "\n" });
-    } else {
-      node.childNodes.forEach(walk);
-    }
-  };
-  fragment.childNodes.forEach(walk);
-  return segments;
-}
-function parseSegmentsFromClipboard(json) {
-  try {
-    const parsed = JSON.parse(json);
-    if (!Array.isArray(parsed)) return null;
-    const segments = [];
-    for (const item of parsed) {
-      if (!isRecord(item)) return null;
-      if (item.type === "text" && typeof item.text === "string") {
-        segments.push({ type: "text", text: item.text });
-      } else if (item.type === "chip" && typeof item.trigger === "string" && typeof item.value === "string" && typeof item.displayText === "string") {
-        const chip = {
-          type: "chip",
-          trigger: item.trigger,
-          value: item.value,
-          displayText: item.displayText,
-          ...item.data !== void 0 ? { data: item.data } : {},
-          ...item.autoResolved ? { autoResolved: true } : {}
-        };
-        segments.push(chip);
-      } else {
-        return null;
-      }
-    }
-    return segments;
-  } catch {
-    return null;
-  }
-}
-function insertSegmentsAtCursor(currentSegments, pastedSegments, editor) {
-  const range = getSelectionRange();
-  if (!range) return [...currentSegments, ...pastedSegments];
-  const preRange = document.createRange();
-  preRange.selectNodeContents(editor);
-  preRange.setEnd(range.startContainer, range.startOffset);
-  const cursorOffset = getTextLengthInRange(preRange);
-  const result = [];
-  let offset = 0;
-  let inserted = false;
-  const insertOnce = () => {
-    if (!inserted) {
-      result.push(...pastedSegments);
-      inserted = true;
-    }
-  };
-  for (const seg of currentSegments) {
-    if (seg.type === "chip") {
-      const chipLen = seg.trigger.length + seg.displayText.length;
-      if (offset >= cursorOffset) insertOnce();
-      result.push(seg);
-      offset += chipLen;
-      continue;
-    }
-    const segEnd = offset + seg.text.length;
-    if (segEnd <= cursorOffset) {
-      result.push(seg);
-    } else if (offset >= cursorOffset) {
-      insertOnce();
-      result.push(seg);
-    } else {
-      const splitAt = cursorOffset - offset;
-      const before = seg.text.slice(0, splitAt);
-      const after = seg.text.slice(splitAt);
-      if (before) result.push({ type: "text", text: before });
-      insertOnce();
-      if (after) result.push({ type: "text", text: after });
-    }
-    offset = segEnd;
-  }
-  insertOnce();
-  return mergeAdjacentTextSegments(result);
-}
-
-// src/prompt-area/use-prompt-area-events.ts
-var MAX_UNDO_HISTORY = 100;
-var BLUR_DELAY_MS = 150;
-function usePromptAreaEvents(deps) {
-  const {
-    editorRef,
-    readSegmentsFromDOM,
-    onChange,
-    renderSegmentsToDOM,
-    runTriggerDetection,
-    dismissTrigger,
-    triggers,
-    onPaste: onPasteCallback,
-    onUndo,
-    onRedo,
-    onChipAdd,
-    onImagePaste
-  } = deps;
-  const isComposing = useRef(false);
-  const undoState = useRef({ undoStack: [], redoStack: [] });
-  const pushUndo = useCallback((segments) => {
-    const state = undoState.current;
-    state.undoStack.push(segments);
-    if (state.undoStack.length > MAX_UNDO_HISTORY) {
-      state.undoStack.shift();
-    }
-    state.redoStack = [];
-  }, []);
-  const resetUndoHistory = useCallback(() => {
-    undoState.current = { undoStack: [], redoStack: [] };
-  }, []);
-  const handlePaste = useCallback(
-    (e) => {
-      e.preventDefault();
-      const editor = editorRef.current;
-      if (!editor) return;
-      const imageFile = Array.from(e.clipboardData.files).find((f) => f.type.startsWith("image/")) ?? (() => {
-        const item = Array.from(e.clipboardData.items).find((i) => i.type.startsWith("image/"));
-        return item?.getAsFile() ?? null;
-      })();
-      if (imageFile) {
-        onImagePaste?.(imageFile);
-        return;
-      }
-      const currentSegments = readSegmentsFromDOM();
-      pushUndo(currentSegments);
-      const segmentJson = e.clipboardData.getData("text/prompt-area-segments");
-      if (segmentJson) {
-        const parsed = parseSegmentsFromClipboard(segmentJson);
-        if (parsed && parsed.length > 0) {
-          const range2 = getSelectionRange();
-          if (!range2) return;
-          range2.deleteContents();
-          const beforePaste = readSegmentsFromDOM();
-          const merged = insertSegmentsAtCursor(beforePaste, parsed, editor);
-          onChange(merged);
-          renderSegmentsToDOM(merged);
-          onPasteCallback?.({ segments: merged, source: "internal" });
-          for (const seg of parsed) {
-            if (seg.type === "chip") {
-              onChipAdd?.(seg);
-            }
-          }
-          runTriggerDetection();
-          return;
-        }
-      }
-      const text = e.clipboardData.getData("text/plain");
-      if (!text) return;
-      const range = getSelectionRange();
-      if (!range) return;
-      range.deleteContents();
-      const lines = text.split("\n");
-      const fragment = document.createDocumentFragment();
-      for (let i = 0; i < lines.length; i++) {
-        if (lines[i]) {
-          fragment.appendChild(document.createTextNode(lines[i]));
-        }
-        if (i < lines.length - 1) {
-          fragment.appendChild(document.createElement("br"));
-        }
-      }
-      range.insertNode(fragment);
-      range.collapse(false);
-      const sel = window.getSelection();
-      sel?.removeAllRanges();
-      sel?.addRange(range);
-      normalizeEditorDOM(editor);
-      const newSegments = readSegmentsFromDOM();
-      const resolvedSegments = resolveTriggersInSegments(newSegments, triggers);
-      if (resolvedSegments !== newSegments) {
-        onChange(resolvedSegments);
-        renderSegmentsToDOM(resolvedSegments);
-        for (const seg of resolvedSegments) {
-          if (seg.type === "chip" && !newSegments.some(
-            (s) => s.type === "chip" && s.trigger === seg.trigger && s.value === seg.value && s.displayText === seg.displayText
-          )) {
-            onChipAdd?.(seg);
-          }
-        }
-      } else {
-        onChange(newSegments);
-      }
-      onPasteCallback?.({ segments: resolvedSegments, source: "external" });
-      runTriggerDetection();
-    },
-    [
-      editorRef,
-      readSegmentsFromDOM,
-      onChange,
-      pushUndo,
-      runTriggerDetection,
-      renderSegmentsToDOM,
-      triggers,
-      onPasteCallback,
-      onChipAdd,
-      onImagePaste
-    ]
-  );
-  const handleCopy = useCallback((e) => {
-    e.preventDefault();
-    const range = getSelectionRange();
-    if (!range) return;
-    const fragment = range.cloneContents();
-    const plainText = serializeFragmentToPlainText(fragment);
-    e.clipboardData.setData("text/plain", plainText);
-    const fragmentSegments = serializeFragmentToSegments(fragment);
-    const hasChips = fragmentSegments.some((s) => s.type === "chip");
-    if (hasChips) {
-      const json = safeJsonStringify(fragmentSegments);
-      if (json) {
-        e.clipboardData.setData("text/prompt-area-segments", json);
-      }
-    }
-  }, []);
-  const handleCut = useCallback(
-    (e) => {
-      handleCopy(e);
-      const range = getSelectionRange();
-      if (!range) return;
-      const currentSegments = readSegmentsFromDOM();
-      pushUndo(currentSegments);
-      range.deleteContents();
-      const editor = editorRef.current;
-      if (editor) {
-        normalizeEditorDOM(editor);
-      }
-      const newSegments = readSegmentsFromDOM();
-      onChange(newSegments);
-      runTriggerDetection();
-    },
-    [handleCopy, editorRef, readSegmentsFromDOM, onChange, pushUndo, runTriggerDetection]
-  );
-  const handleDrop = useCallback((e) => {
-    e.preventDefault();
-  }, []);
-  const handleDragOver = useCallback((e) => {
-    e.preventDefault();
-  }, []);
-  const handleCompositionStart = useCallback(() => {
-    isComposing.current = true;
-  }, []);
-  const handleCompositionEnd = useCallback(() => {
-    isComposing.current = false;
-    runTriggerDetection();
-  }, [runTriggerDetection]);
-  const handleBlur = useCallback(() => {
-    setTimeout(() => {
-      const editor = editorRef.current;
-      if (!editor) return;
-      const activeEl = document.activeElement;
-      if (activeEl && editor.parentElement?.contains(activeEl)) return;
-      dismissTrigger();
-    }, BLUR_DELAY_MS);
-  }, [editorRef, dismissTrigger]);
-  const handleKeyDownForUndoRedo = useCallback(
-    (e) => {
-      const isMeta = e.metaKey || e.ctrlKey;
-      if (!isMeta || e.key !== "z") return false;
-      e.preventDefault();
-      const state = undoState.current;
-      if (e.shiftKey) {
-        if (state.redoStack.length === 0) return true;
-        const segments = state.redoStack.pop();
-        if (!segments) return true;
-        const current = readSegmentsFromDOM();
-        state.undoStack.push(current);
-        onChange(segments);
-        renderSegmentsToDOM(segments);
-        onRedo?.(segments);
-      } else {
-        if (state.undoStack.length === 0) return true;
-        const segments = state.undoStack.pop();
-        if (!segments) return true;
-        const current = readSegmentsFromDOM();
-        state.redoStack.push(current);
-        onChange(segments);
-        renderSegmentsToDOM(segments);
-        onUndo?.(segments);
-      }
-      return true;
-    },
-    [readSegmentsFromDOM, onChange, renderSegmentsToDOM, onUndo, onRedo]
-  );
-  return {
-    handlePaste,
-    handleCopy,
-    handleCut,
-    handleDrop,
-    handleDragOver,
-    handleCompositionStart,
-    handleCompositionEnd,
-    handleBlur,
-    handleKeyDownForUndoRedo,
-    pushUndo,
-    resetUndoHistory,
-    isComposing
-  };
-}
-function useTriggerSearch() {
-  const [suggestions, setSuggestions] = useState([]);
-  const [suggestionsLoading, setSuggestionsLoading] = useState(false);
-  const [suggestionsError, setSuggestionsError] = useState(null);
-  const searchVersion = useRef(0);
-  const abortController = useRef(null);
-  const debounceTimer = useRef(null);
-  const reset = useCallback(() => {
-    abortController.current?.abort();
-    if (debounceTimer.current) clearTimeout(debounceTimer.current);
-    setSuggestions([]);
-    setSuggestionsLoading(false);
-    setSuggestionsError(null);
-  }, []);
-  const search = useCallback((query, config) => {
-    if (!config.onSearch) return;
-    abortController.current?.abort();
-    if (debounceTimer.current) clearTimeout(debounceTimer.current);
-    setSuggestionsLoading(true);
-    setSuggestionsError(null);
-    searchVersion.current++;
-    const version = searchVersion.current;
-    const controller = new AbortController();
-    abortController.current = controller;
-    const { onSearch, onSearchError, searchDebounceMs } = config;
-    const executeSearch = () => {
-      const result = onSearch(query, { signal: controller.signal });
-      if (result instanceof Promise) {
-        void result.then(
-          (items) => {
-            if (controller.signal.aborted || searchVersion.current !== version) return;
-            setSuggestions(items);
-            setSuggestionsLoading(false);
-          },
-          (error) => {
-            if (controller.signal.aborted || searchVersion.current !== version) return;
-            if (error instanceof DOMException && error.name === "AbortError") return;
-            setSuggestionsError(error instanceof Error ? error.message : "Search failed");
-            setSuggestionsLoading(false);
-            onSearchError?.(error);
-          }
-        );
-      } else {
-        setSuggestions(result);
-        setSuggestionsLoading(false);
-      }
-    };
-    if (searchDebounceMs && searchDebounceMs > 0 && query.length > 0) {
-      debounceTimer.current = setTimeout(executeSearch, searchDebounceMs);
-    } else {
-      executeSearch();
-    }
-  }, []);
-  useEffect(() => {
-    return () => {
-      abortController.current?.abort();
-      if (debounceTimer.current) clearTimeout(debounceTimer.current);
-    };
-  }, []);
-  return {
-    suggestions,
-    suggestionsLoading,
-    suggestionsError,
-    search,
-    reset
-  };
-}
-
-// src/prompt-area/use-prompt-area.ts
-var UNDO_DEBOUNCE_MS = 300;
-function usePromptArea({
-  value,
-  onChange,
-  triggers = [],
-  onSubmit,
-  onEscape,
-  onChipClick,
-  onChipAdd,
-  onChipDelete,
-  onLinkClick,
-  onPaste,
-  onUndo,
-  onRedo,
-  onImagePaste,
-  markdown: markdownEnabled = true
-}) {
-  const editorRef = useRef(null);
-  const [activeTrigger, setActiveTrigger] = useState(null);
-  const [selectedSuggestionIndex, setSelectedSuggestionIndex] = useState(0);
-  const [triggerRect, setTriggerRect] = useState(null);
-  const {
-    suggestions,
-    suggestionsLoading,
-    suggestionsError,
-    search: runSearch,
-    reset: resetSearch
-  } = useTriggerSearch();
-  const isSyncing = useRef(false);
-  const lastRenderedValue = useRef([]);
-  const undoTimer = useRef(null);
-  const undoBaseState = useRef(null);
-  const readSegmentsFromDOM = useCallback(() => {
-    const editor = editorRef.current;
-    if (!editor) return [];
-    const segments = [];
-    for (let i = 0; i < editor.childNodes.length; i++) {
-      const node = editor.childNodes[i];
-      if (node.nodeType === Node.TEXT_NODE) {
-        const text = node.textContent ?? "";
-        if (text) {
-          segments.push({ type: "text", text });
-        }
-      } else if (isChipElement(node)) {
-        const trigger = getChipTrigger(node);
-        const chipValue = getChipValue(node);
-        const display = getChipDisplay(node);
-        const data = getChipData(node);
-        if (trigger && chipValue !== void 0 && display) {
-          const autoResolved = getChipAutoResolved(node);
-          segments.push({
-            type: "chip",
-            trigger,
-            value: chipValue,
-            displayText: display,
-            ...data !== void 0 ? { data } : {},
-            ...autoResolved ? { autoResolved: true } : {}
-          });
-        }
-      } else if (isBRElement(node)) {
-        if (node.dataset.sentinel) continue;
-        segments.push({ type: "text", text: "\n" });
-      } else if (isHTMLElement(node)) {
-        const text = node.textContent ?? "";
-        if (text) {
-          segments.push({ type: "text", text });
-        }
-      }
-    }
-    return segments;
-  }, []);
-  const renderSegmentsToDOM = useCallback(
-    (segments) => {
-      const editor = editorRef.current;
-      if (!editor) return;
-      isSyncing.current = true;
-      const savedCursor = saveCursorPosition(editor);
-      while (editor.firstChild) {
-        editor.removeChild(editor.firstChild);
-      }
-      for (const seg of segments) {
-        if (seg.type === "text") {
-          const lines = seg.text.split("\n");
-          for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
-            if (lines[lineIdx]) {
-              editor.appendChild(document.createTextNode(lines[lineIdx]));
-            }
-            if (lineIdx < lines.length - 1) {
-              editor.appendChild(document.createElement("br"));
-            }
-          }
-        } else {
-          const chip = document.createElement("span");
-          chip.contentEditable = "false";
-          chip.dataset.chipTrigger = seg.trigger;
-          chip.dataset.chipValue = seg.value;
-          chip.dataset.chipDisplay = seg.displayText;
-          if (seg.data !== void 0) {
-            const json = safeJsonStringify(seg.data);
-            if (json) {
-              chip.dataset.chipData = json;
-            }
-          }
-          if (seg.autoResolved) {
-            chip.dataset.chipAutoResolved = "true";
-          }
-          const triggerConfig = triggers.find((t) => t.char === seg.trigger);
-          const chipStyle = triggerConfig?.chipStyle ?? "pill";
-          chip.dataset.chipStyle = chipStyle;
-          chip.className = cn(
-            "prompt-area-chip",
-            chipStyle === "inline" && "prompt-area-chip--inline",
-            triggerConfig?.chipClassName
-          );
-          chip.textContent = `${seg.trigger}${seg.displayText}`;
-          chip.setAttribute("role", "button");
-          chip.setAttribute("tabindex", "-1");
-          editor.appendChild(chip);
-        }
-      }
-      if (editor.lastChild && isBRElement(editor.lastChild)) {
-        const sentinel = document.createElement("br");
-        sentinel.dataset.sentinel = "true";
-        editor.appendChild(sentinel);
-      }
-      decorateURLsInEditor(editor);
-      if (markdownEnabled) decorateMarkdownInEditor(editor);
-      if (savedCursor) {
-        restoreCursorPosition(editor, savedCursor);
-      }
-      lastRenderedValue.current = segments;
-      isSyncing.current = false;
-    },
-    [triggers, markdownEnabled]
-  );
-  const runTriggerDetection = useCallback(() => {
-    const editor = editorRef.current;
-    if (!editor) return;
-    const segments = readSegmentsFromDOM();
-    const plainText = segmentsToPlainText(segments);
-    const cursorPos = getCursorOffset(editor);
-    if (cursorPos === null) return;
-    const detected = detectActiveTrigger(plainText, cursorPos, triggers);
-    if (detected) {
-      setActiveTrigger(detected);
-      setSelectedSuggestionIndex(0);
-      const triggerRange = createRangeAtOffset(editor, detected.startOffset);
-      if (triggerRange) {
-        const rect = triggerRange.getBoundingClientRect();
-        if (rect.height > 0 || rect.left > 0 || rect.top > 0) {
-          setTriggerRect(rect);
-        }
-      }
-      if (detected.config.mode === "dropdown" && detected.config.onSearch) {
-        runSearch(detected.query, detected.config);
-      }
-      if (detected.config.mode === "callback" && detected.config.onActivate) {
-        detected.config.onActivate({
-          text: plainText,
-          cursorPosition: cursorPos,
-          insertChip: (chip) => {
-            const chipResult = resolveChip(segments, detected, {
-              value: chip.value,
-              displayText: chip.displayText,
-              data: chip.data
-            });
-            onChange(chipResult.segments);
-            renderSegmentsToDOM(chipResult.segments);
-            onChipAdd?.({
-              type: "chip",
-              trigger: detected.config.char,
-              value: chip.value,
-              displayText: chip.displayText,
-              ...chip.data !== void 0 ? { data: chip.data } : {}
-            });
-            const editor2 = editorRef.current;
-            if (editor2) {
-              setCursorAtOffset(editor2, chipResult.cursorOffset);
-            }
-          }
-        });
-      }
-    } else {
-      setActiveTrigger(null);
-      resetSearch();
-    }
-  }, [
-    triggers,
-    readSegmentsFromDOM,
-    onChange,
-    renderSegmentsToDOM,
-    onChipAdd,
-    resetSearch,
-    runSearch
-  ]);
-  const dismissTrigger = useCallback(() => {
-    setActiveTrigger(null);
-    setSelectedSuggestionIndex(0);
-    resetSearch();
-  }, [resetSearch]);
-  const events = usePromptAreaEvents({
-    editorRef,
-    readSegmentsFromDOM,
-    onChange,
-    renderSegmentsToDOM,
-    runTriggerDetection,
-    dismissTrigger,
-    triggers,
-    onPaste,
-    onUndo,
-    onRedo,
-    onChipAdd,
-    onImagePaste
-  });
-  useEffect(() => {
-    if (isSyncing.current) return;
-    if (segmentsEqual(value, lastRenderedValue.current)) return;
-    if (markdownEnabled) {
-      const normalized = normalizeListPrefixes(value, true);
-      if (normalized !== value) {
-        onChange(normalized);
-        return;
-      }
-    }
-    renderSegmentsToDOM(value);
-  }, [value, renderSegmentsToDOM, markdownEnabled, onChange]);
-  const prevMarkdown = useRef(markdownEnabled);
-  useEffect(() => {
-    if (prevMarkdown.current === markdownEnabled) return;
-    prevMarkdown.current = markdownEnabled;
-    const converted = normalizeListPrefixes(value, markdownEnabled);
-    if (converted !== value) {
-      onChange(converted);
-    } else {
-      renderSegmentsToDOM(value);
-    }
-  }, [markdownEnabled, renderSegmentsToDOM, value, onChange]);
-  useEffect(() => {
-    return () => {
-      if (undoTimer.current) clearTimeout(undoTimer.current);
-    };
-  }, []);
-  const handleInput = useCallback(() => {
-    if (isSyncing.current) return;
-    if (events.isComposing.current) {
-      const segments2 = readSegmentsFromDOM();
-      lastRenderedValue.current = segments2;
-      onChange(segments2);
-      return;
-    }
-    const editor = editorRef.current;
-    const savedCursorOffset = editor ? getCursorOffset(editor) : null;
-    if (editor) {
-      normalizeEditorDOM(editor);
-    }
-    const segments = readSegmentsFromDOM();
-    if (markdownEnabled && editor && savedCursorOffset !== null) {
-      const formatted = autoFormatListPrefix(segments, savedCursorOffset);
-      if (formatted) {
-        lastRenderedValue.current = formatted.segments;
-        onChange(formatted.segments);
-        renderSegmentsToDOM(formatted.segments);
-        setCursorAtOffset(editor, formatted.cursorOffset);
-        runTriggerDetection();
-        return;
-      }
-    }
-    if (!undoBaseState.current) {
-      undoBaseState.current = lastRenderedValue.current;
-    }
-    lastRenderedValue.current = segments;
-    onChange(segments);
-    if (undoTimer.current) clearTimeout(undoTimer.current);
-    undoTimer.current = setTimeout(() => {
-      if (undoBaseState.current) {
-        events.pushUndo(undoBaseState.current);
-        undoBaseState.current = null;
-      }
-      undoTimer.current = null;
-    }, UNDO_DEBOUNCE_MS);
-    if (editor) {
-      decorateURLsInEditor(editor);
-      if (markdownEnabled) decorateMarkdownInEditor(editor);
-      if (savedCursorOffset !== null) {
-        setCursorAtOffset(editor, savedCursorOffset);
-      }
-    }
-    runTriggerDetection();
-  }, [
-    onChange,
-    readSegmentsFromDOM,
-    runTriggerDetection,
-    renderSegmentsToDOM,
-    markdownEnabled,
-    events
-  ]);
-  const handleClick = useCallback(
-    (e) => {
-      const target = e.target;
-      if (!(target instanceof Node)) return;
-      const editor = editorRef.current;
-      if (!editor) return;
-      let node = target;
-      while (node && node !== editor) {
-        if (isLinkElement(node)) {
-          if (e.metaKey || e.ctrlKey) {
-            e.preventDefault();
-            onLinkClick?.(node.href);
-            window.open(node.href, "_blank", "noopener,noreferrer");
-            return;
-          }
-          break;
-        }
-        if (isChipElement(node)) {
-          const chipEl = node;
-          const rect = chipEl.getBoundingClientRect();
-          const ripple = document.createElement("span");
-          ripple.className = "prompt-area-chip-ripple";
-          const size = Math.max(rect.width, rect.height);
-          ripple.style.width = `${size}px`;
-          ripple.style.height = `${size}px`;
-          ripple.style.left = `${e.clientX - rect.left - size / 2}px`;
-          ripple.style.top = `${e.clientY - rect.top - size / 2}px`;
-          chipEl.appendChild(ripple);
-          ripple.addEventListener("animationend", () => ripple.remove());
-          if (!onChipClick) return;
-          const trigger = getChipTrigger(node);
-          const chipValue = getChipValue(node);
-          const display = getChipDisplay(node);
-          const data = getChipData(node);
-          if (trigger && chipValue !== void 0 && display) {
-            const autoResolved = getChipAutoResolved(node);
-            const chip = {
-              type: "chip",
-              trigger,
-              value: chipValue,
-              displayText: display,
-              ...data !== void 0 ? { data } : {},
-              ...autoResolved ? { autoResolved: true } : {}
-            };
-            onChipClick(chip);
-          }
-          return;
-        }
-        node = node.parentNode;
-      }
-    },
-    [onChipClick, onLinkClick]
-  );
-  const removeChipNodeFromDOM = useCallback(
-    (editor, chipNode) => {
-      const segments = readSegmentsFromDOM();
-      const chipIdx = indexOfChildNode(editor, chipNode);
-      if (chipIdx === -1) return false;
-      let segIdx = 0;
-      for (let i = 0; i < chipIdx; i++) {
-        const child = editor.childNodes[i];
-        if (child.nodeType === Node.TEXT_NODE && (child.textContent ?? "") !== "") {
-          segIdx++;
-        } else if (isChipElement(child)) {
-          segIdx++;
-        } else if (isBRElement(child)) {
-          segIdx++;
-        }
-      }
-      const deletedChip = segments[segIdx];
-      const newSegments = removeChipAtIndex(segments, segIdx);
-      onChange(newSegments);
-      renderSegmentsToDOM(newSegments);
-      if (deletedChip?.type === "chip") {
-        onChipDelete?.(deletedChip);
-      }
-      return true;
-    },
-    [readSegmentsFromDOM, onChange, renderSegmentsToDOM, onChipDelete]
-  );
-  const revertChipNodeToText = useCallback(
-    (editor, chipNode) => {
-      const segments = readSegmentsFromDOM();
-      const chipIdx = indexOfChildNode(editor, chipNode);
-      if (chipIdx === -1) return false;
-      let segIdx = 0;
-      for (let i = 0; i < chipIdx; i++) {
-        const child = editor.childNodes[i];
-        if (child.nodeType === Node.TEXT_NODE && (child.textContent ?? "") !== "") {
-          segIdx++;
-        } else if (isChipElement(child)) {
-          segIdx++;
-        } else if (isBRElement(child)) {
-          segIdx++;
-        }
-      }
-      const revertedChip = segments[segIdx];
-      const result = revertChipAtIndex(segments, segIdx);
-      if (!result) return false;
-      let targetOffset = 0;
-      for (let i = 0; i < segIdx; i++) {
-        const s = segments[i];
-        if (s.type === "text") {
-          targetOffset += s.text.length;
-        } else {
-          targetOffset += s.trigger.length + s.displayText.length;
-        }
-      }
-      targetOffset += result.revertedText.length;
-      onChange(result.segments);
-      renderSegmentsToDOM(result.segments);
-      setCursorAtOffset(editor, targetOffset);
-      if (revertedChip?.type === "chip") {
-        onChipDelete?.(revertedChip);
-      }
-      return true;
-    },
-    [readSegmentsFromDOM, onChange, renderSegmentsToDOM, onChipDelete]
-  );
-  const handleChipBackspace = useCallback(() => {
-    const editor = editorRef.current;
-    if (!editor) return false;
-    const range = getSelectionRange();
-    if (!range || !range.collapsed) return false;
-    const node = range.startContainer;
-    const offset = range.startOffset;
-    if (node === editor && offset > 0) {
-      const prevChild = editor.childNodes[offset - 1];
-      if (prevChild && isChipElement(prevChild)) {
-        if (getChipAutoResolved(prevChild)) {
-          return revertChipNodeToText(editor, prevChild);
-        }
-        return removeChipNodeFromDOM(editor, prevChild);
-      }
-    }
-    if (node.nodeType === Node.TEXT_NODE && offset === 0) {
-      const directChild = getDirectChildContaining(editor, node);
-      if (!directChild) return false;
-      let prevSibling = directChild.previousSibling;
-      while (prevSibling && prevSibling.nodeType === Node.TEXT_NODE && prevSibling.textContent === "") {
-        prevSibling = prevSibling.previousSibling;
-      }
-      if (prevSibling && isChipElement(prevSibling)) {
-        if (getChipAutoResolved(prevSibling)) {
-          return revertChipNodeToText(editor, prevSibling);
-        }
-        return removeChipNodeFromDOM(editor, prevSibling);
-      }
-    }
-    return false;
-  }, [removeChipNodeFromDOM, revertChipNodeToText]);
-  const handleChipForwardDelete = useCallback(() => {
-    const editor = editorRef.current;
-    if (!editor) return false;
-    const range = getSelectionRange();
-    if (!range || !range.collapsed) return false;
-    const node = range.startContainer;
-    const offset = range.startOffset;
-    if (node === editor && offset < editor.childNodes.length) {
-      const nextChild = editor.childNodes[offset];
-      if (nextChild && isChipElement(nextChild)) {
-        return removeChipNodeFromDOM(editor, nextChild);
-      }
-    }
-    if (node.nodeType === Node.TEXT_NODE && offset === (node.textContent ?? "").length) {
-      const directChild = getDirectChildContaining(editor, node);
-      if (!directChild) return false;
-      let nextSibling = directChild.nextSibling;
-      while (nextSibling && nextSibling.nodeType === Node.TEXT_NODE && nextSibling.textContent === "") {
-        nextSibling = nextSibling.nextSibling;
-      }
-      if (nextSibling && isChipElement(nextSibling)) {
-        return removeChipNodeFromDOM(editor, nextSibling);
-      }
-    }
-    return false;
-  }, [removeChipNodeFromDOM]);
-  const autoResolveActiveTrigger = useCallback(
-    (trigger) => {
-      const segments = readSegmentsFromDOM();
-      const query = trigger.query;
-      const syntheticSuggestion = {
-        value: query,
-        label: query
-      };
-      const displayText = trigger.config.onSelect?.(syntheticSuggestion) ?? query;
-      const chipData = {
-        value: query,
-        displayText: displayText || query,
-        autoResolved: true
-      };
-      const result = resolveChip(segments, trigger, chipData);
-      onChange(result.segments);
-      renderSegmentsToDOM(result.segments);
-      onChipAdd?.({
-        type: "chip",
-        trigger: trigger.config.char,
-        ...chipData
-      });
-      const editor = editorRef.current;
-      if (editor) {
-        setCursorAtOffset(editor, result.cursorOffset);
-      }
-      dismissTrigger();
-    },
-    [readSegmentsFromDOM, onChange, renderSegmentsToDOM, dismissTrigger, onChipAdd]
-  );
-  const selectSuggestionInternal = useCallback(
-    (suggestion) => {
-      if (!activeTrigger) return;
-      const segments = readSegmentsFromDOM();
-      const displayText = activeTrigger.config.onSelect?.(suggestion) ?? suggestion.label;
-      const chipData = {
-        value: suggestion.value,
-        displayText: displayText || suggestion.label,
-        data: suggestion.data
-      };
-      const result = resolveChip(segments, activeTrigger, chipData);
-      onChange(result.segments);
-      renderSegmentsToDOM(result.segments);
-      onChipAdd?.({
-        type: "chip",
-        trigger: activeTrigger.config.char,
-        ...chipData
-      });
-      const editor = editorRef.current;
-      if (editor) {
-        setCursorAtOffset(editor, result.cursorOffset);
-      }
-      dismissTrigger();
-      setTimeout(() => {
-        editorRef.current?.focus();
-      }, 0);
-    },
-    [activeTrigger, readSegmentsFromDOM, onChange, renderSegmentsToDOM, dismissTrigger, onChipAdd]
-  );
-  const selectSuggestion = selectSuggestionInternal;
-  const handleKeyDown = useCallback(
-    (e) => {
-      const applyEditResult = (editor, result) => {
-        lastRenderedValue.current = result.segments;
-        onChange(result.segments);
-        renderSegmentsToDOM(result.segments);
-        setCursorAtOffset(editor, result.cursorOffset);
-      };
-      const tryListContinuation = (editor) => {
-        if (!markdownEnabled) return false;
-        const segments = readSegmentsFromDOM();
-        const cursorPos = getCursorOffset(editor);
-        if (cursorPos === null) return false;
-        const plainText = segmentsToPlainText(segments);
-        if (!getListContext(plainText, cursorPos)) return false;
-        const result = insertListContinuation(segments, cursorPos);
-        if (result) applyEditResult(editor, result);
-        return true;
-      };
-      if ((e.metaKey || e.ctrlKey) && e.key === "z" && undoBaseState.current) {
-        if (undoTimer.current) {
-          clearTimeout(undoTimer.current);
-          undoTimer.current = null;
-        }
-        events.pushUndo(undoBaseState.current);
-        undoBaseState.current = null;
-      }
-      if (events.handleKeyDownForUndoRedo(e)) return;
-      if (markdownEnabled && (e.metaKey || e.ctrlKey) && !e.shiftKey && (e.key === "b" || e.key === "i")) {
-        e.preventDefault();
-        const editor = editorRef.current;
-        if (!editor) return;
-        const offsets = getSelectionOffsets(editor);
-        if (!offsets || offsets.start === offsets.end) return;
-        const marker = e.key === "b" ? "**" : "*";
-        const currentSegments = readSegmentsFromDOM();
-        events.pushUndo(currentSegments);
-        const result = toggleMarkdownWrap(currentSegments, offsets.start, offsets.end, marker);
-        if (!result) return;
-        lastRenderedValue.current = result.segments;
-        onChange(result.segments);
-        renderSegmentsToDOM(result.segments);
-        setSelectionAtOffsets(editor, result.selectionStart, result.selectionEnd);
-        return;
-      }
-      if (activeTrigger && activeTrigger.config.mode === "dropdown" && suggestions.length > 0) {
-        if (e.key === "ArrowDown") {
-          e.preventDefault();
-          setSelectedSuggestionIndex((prev) => Math.min(prev + 1, suggestions.length - 1));
-          return;
-        }
-        if (e.key === "ArrowUp") {
-          e.preventDefault();
-          setSelectedSuggestionIndex((prev) => Math.max(prev - 1, 0));
-          return;
-        }
-        if (e.key === "Enter" || e.key === "Tab") {
-          e.preventDefault();
-          const selected = suggestions[selectedSuggestionIndex];
-          if (selected) {
-            selectSuggestionInternal(selected);
-          }
-          return;
-        }
-        if (e.key === "Escape") {
-          e.preventDefault();
-          dismissTrigger();
-          return;
-        }
-      }
-      if (e.key === " " && activeTrigger && activeTrigger.config.resolveOnSpace) {
-        const query = activeTrigger.query.trim();
-        if (query.length > 0) {
-          e.preventDefault();
-          autoResolveActiveTrigger(activeTrigger);
-          return;
-        }
-      }
-      if (markdownEnabled && e.key === "Tab" && !activeTrigger) {
-        const editor = editorRef.current;
-        if (editor) {
-          const segments = readSegmentsFromDOM();
-          const plainText = segmentsToPlainText(segments);
-          const cursorPos = getCursorOffset(editor);
-          if (cursorPos !== null) {
-            const ctx = getListContext(plainText, cursorPos);
-            if (ctx) {
-              e.preventDefault();
-              const result = e.shiftKey ? outdentListItem(segments, cursorPos) : indentListItem(segments, cursorPos);
-              if (result) applyEditResult(editor, result);
-              return;
-            }
-          }
-        }
-      }
-      if (e.key === "Enter" && e.shiftKey && !e.nativeEvent.isComposing) {
-        e.preventDefault();
-        const editor = editorRef.current;
-        if (editor) {
-          if (tryListContinuation(editor)) return;
-          const offsets = getSelectionOffsets(editor);
-          if (offsets) {
-            const currentSegments = readSegmentsFromDOM();
-            events.pushUndo(currentSegments);
-            const newSegments = replaceTextRange(currentSegments, offsets.start, offsets.end, "\n");
-            applyEditResult(editor, { segments: newSegments, cursorOffset: offsets.start + 1 });
-          }
-        }
-        return;
-      }
-      if (e.key === "Enter" && !e.shiftKey && !e.nativeEvent.isComposing) {
-        const editor = editorRef.current;
-        if (editor && tryListContinuation(editor)) {
-          e.preventDefault();
-          return;
-        }
-        if (onSubmit) {
-          e.preventDefault();
-          onSubmit(readSegmentsFromDOM());
-          return;
-        }
-      }
-      if (e.key === "Escape" && onEscape) {
-        onEscape();
-        return;
-      }
-      if ((e.key === "Backspace" || e.key === "Delete") && !e.nativeEvent.isComposing) {
-        const editor = editorRef.current;
-        if (editor) {
-          const offsets = getSelectionOffsets(editor);
-          if (offsets && offsets.start !== offsets.end) {
-            e.preventDefault();
-            const currentSegments = readSegmentsFromDOM();
-            events.pushUndo(currentSegments);
-            const newSegments = replaceTextRange(currentSegments, offsets.start, offsets.end, "");
-            applyEditResult(editor, { segments: newSegments, cursorOffset: offsets.start });
-            runTriggerDetection();
-            return;
-          }
-        }
-      }
-      if (e.key === "Backspace") {
-        const editor = editorRef.current;
-        if (editor) {
-          const segments = readSegmentsFromDOM();
-          const cursorPos = getCursorOffset(editor);
-          if (markdownEnabled && cursorPos !== null) {
-            const result = removeListPrefix(segments, cursorPos);
-            if (result) {
-              e.preventDefault();
-              applyEditResult(editor, result);
-              runTriggerDetection();
-              return;
-            }
-          }
-        }
-        if (handleChipBackspace()) {
-          e.preventDefault();
-          runTriggerDetection();
-          return;
-        }
-      }
-      if (e.key === "Delete" && handleChipForwardDelete()) {
-        e.preventDefault();
-        runTriggerDetection();
-        return;
-      }
-    },
-    [
-      activeTrigger,
-      suggestions,
-      selectedSuggestionIndex,
-      onSubmit,
-      onEscape,
-      readSegmentsFromDOM,
-      onChange,
-      renderSegmentsToDOM,
-      markdownEnabled,
-      dismissTrigger,
-      handleChipBackspace,
-      handleChipForwardDelete,
-      autoResolveActiveTrigger,
-      runTriggerDetection,
-      selectSuggestionInternal,
-      events
-    ]
-  );
-  const handle = useMemo(
-    () => ({
-      focus: () => editorRef.current?.focus(),
-      blur: () => editorRef.current?.blur(),
-      insertChip: (chip) => {
-        const segments = readSegmentsFromDOM();
-        const newChip = { type: "chip", ...chip };
-        const newSegments = [...segments, newChip, { type: "text", text: " " }];
-        onChange(newSegments);
-        renderSegmentsToDOM(newSegments);
-        onChipAdd?.(newChip);
-      },
-      getPlainText: () => segmentsToPlainText(readSegmentsFromDOM()),
-      clear: () => {
-        onChange([]);
-        const editor = editorRef.current;
-        if (editor) {
-          while (editor.firstChild) editor.removeChild(editor.firstChild);
-        }
-        events.resetUndoHistory();
-        if (undoTimer.current) {
-          clearTimeout(undoTimer.current);
-          undoTimer.current = null;
-        }
-        undoBaseState.current = null;
-      }
-    }),
-    [readSegmentsFromDOM, onChange, renderSegmentsToDOM, onChipAdd, events]
-  );
-  const eventHandlers = useMemo(
-    () => ({
-      onPaste: events.handlePaste,
-      onCopy: events.handleCopy,
-      onCut: events.handleCut,
-      onDrop: events.handleDrop,
-      onDragOver: events.handleDragOver,
-      onCompositionStart: events.handleCompositionStart,
-      onCompositionEnd: events.handleCompositionEnd,
-      onBlur: events.handleBlur
-    }),
-    [
-      events.handlePaste,
-      events.handleCopy,
-      events.handleCut,
-      events.handleDrop,
-      events.handleDragOver,
-      events.handleCompositionStart,
-      events.handleCompositionEnd,
-      events.handleBlur
-    ]
-  );
-  return {
-    editorRef,
-    activeTrigger,
-    suggestions,
-    suggestionsLoading,
-    suggestionsError,
-    selectedSuggestionIndex,
-    handleInput,
-    handleKeyDown,
-    handleClick,
-    selectSuggestion,
-    dismissTrigger,
-    handle,
-    triggerRect,
-    eventHandlers
-  };
-}
-function TriggerPopover({
-  suggestions,
-  loading,
-  error,
-  emptyMessage,
-  selectedIndex,
-  onSelect,
-  onDismiss,
-  triggerRect,
-  triggerChar
-}) {
-  const popoverRef = useRef(null);
-  const selectedRef = useRef(null);
-  useEffect(() => {
-    selectedRef.current?.scrollIntoView({ block: "nearest" });
-  }, [selectedIndex]);
-  useEffect(() => {
-    const handleClickOutside = (e) => {
-      const target = e.target;
-      if (popoverRef.current && target instanceof Node && !popoverRef.current.contains(target)) {
-        onDismiss();
-      }
-    };
-    document.addEventListener("mousedown", handleClickOutside);
-    return () => document.removeEventListener("mousedown", handleClickOutside);
-  }, [onDismiss]);
-  if (!triggerRect) return null;
-  if (suggestions.length === 0 && !loading && !error && !emptyMessage) return null;
-  const popoverMaxWidth = Math.min(320, window.innerWidth - 16);
-  const left = Math.min(triggerRect.left, window.innerWidth - popoverMaxWidth - 8);
-  const style = {
-    position: "fixed",
-    left: `${Math.max(8, left)}px`,
-    top: `${triggerRect.bottom + 4}px`,
-    zIndex: 50,
-    maxWidth: `${popoverMaxWidth}px`
-  };
-  return /* @__PURE__ */ jsx(
-    "div",
-    {
-      ref: popoverRef,
-      className: cn(
-        "max-h-[240px] min-w-[200px] overflow-y-auto",
-        "bg-popover rounded-xl border p-2 shadow-md",
-        "animate-in fade-in-0 zoom-in-95"
-      ),
-      style,
-      role: "listbox",
-      "aria-label": `${triggerChar} suggestions`,
-      children: loading ? /* @__PURE__ */ jsx(
-        "div",
-        {
-          role: "option",
-          "aria-selected": false,
-          className: "text-muted-foreground px-3 py-2 text-sm",
-          children: "Loading suggestions..."
-        }
-      ) : error ? /* @__PURE__ */ jsx("div", { role: "option", "aria-selected": false, className: "text-destructive px-3 py-2 text-sm", children: error }) : suggestions.length === 0 && emptyMessage ? /* @__PURE__ */ jsx(
-        "div",
-        {
-          role: "option",
-          "aria-selected": false,
-          className: "text-muted-foreground px-3 py-2 text-sm",
-          children: emptyMessage
-        }
-      ) : suggestions.map((suggestion, index) => /* @__PURE__ */ jsxs(
-        "button",
-        {
-          ref: index === selectedIndex ? selectedRef : void 0,
-          type: "button",
-          role: "option",
-          "aria-selected": index === selectedIndex,
-          className: cn(
-            "text-foreground flex w-full items-start gap-2 rounded-lg px-3 py-2 text-left text-sm",
-            "hover:bg-accent cursor-pointer transition-colors",
-            index === selectedIndex && "bg-accent"
-          ),
-          onMouseDown: (e) => {
-            e.preventDefault();
-            onSelect(suggestion);
-          },
-          children: [
-            suggestion.icon && /* @__PURE__ */ jsx("span", { className: "mt-0.5 shrink-0", children: suggestion.icon }),
-            /* @__PURE__ */ jsxs("div", { className: "min-w-0 flex-1", children: [
-              /* @__PURE__ */ jsx("div", { className: "truncate font-medium", children: suggestion.label }),
-              suggestion.description && /* @__PURE__ */ jsx("div", { className: "text-muted-foreground truncate text-xs", children: suggestion.description })
-            ] })
-          ]
-        },
-        suggestion.value
-      ))
-    }
-  );
-}
-function AnimatedPlaceholder({ texts, interval = 3e3 }) {
-  const [index, setIndex] = useState(0);
-  useEffect(() => {
-    if (texts.length <= 1) return;
-    const id = setInterval(() => {
-      setIndex((prev) => (prev + 1) % texts.length);
-    }, interval);
-    return () => clearInterval(id);
-  }, [texts.length, interval]);
-  return /* @__PURE__ */ jsx(
-    "div",
-    {
-      className: "pointer-events-none absolute top-0 left-0 overflow-hidden text-sm leading-relaxed select-none",
-      style: { color: "var(--prompt-area-placeholder, var(--muted-foreground))" },
-      "aria-hidden": "true",
-      children: /* @__PURE__ */ jsx(
-        "div",
-        {
-          className: "animate-in fade-in-0 slide-in-from-top-4 duration-300 ease-in-out",
-          children: texts[index]
-        },
-        index
-      )
-    }
-  );
-}
-function RemoveButton({ onClick, label, className }) {
-  return /* @__PURE__ */ jsx(
-    "button",
-    {
-      type: "button",
-      onClick: (e) => {
-        e.stopPropagation();
-        onClick();
-      },
-      className: cn(
-        "absolute top-0.5 right-0.5 grid h-3.5 w-3.5 cursor-pointer place-items-center",
-        "rounded-full bg-black/60 text-white hover:bg-black/80 dark:bg-white/60 dark:text-black dark:hover:bg-white/80",
-        "transition-colors",
-        className
-      ),
-      "aria-label": label,
-      children: /* @__PURE__ */ jsxs(
-        "svg",
-        {
-          width: "8",
-          height: "8",
-          viewBox: "0 0 10 10",
-          fill: "none",
-          stroke: "currentColor",
-          strokeWidth: "1.5",
-          strokeLinecap: "round",
-          children: [
-            /* @__PURE__ */ jsx("line", { x1: "2.75", y1: "2.75", x2: "7.25", y2: "7.25" }),
-            /* @__PURE__ */ jsx("line", { x1: "7.25", y1: "2.75", x2: "2.75", y2: "7.25" })
-          ]
-        }
-      )
-    }
-  );
-}
-function ImageStrip({ images, onRemove, onClick, className }) {
-  if (images.length === 0) return null;
-  return /* @__PURE__ */ jsx("div", { className: cn("flex flex-wrap gap-2", className), role: "list", "aria-label": "Attached images", children: images.map((image) => /* @__PURE__ */ jsxs(
-    "div",
-    {
-      role: "listitem",
-      className: cn(
-        "border-border relative h-16 w-16 flex-shrink-0 overflow-hidden rounded-md border",
-        onClick && "cursor-pointer"
-      ),
-      onClick: () => onClick?.(image),
-      children: [
-        /* @__PURE__ */ jsx(
-          "img",
-          {
-            src: image.url,
-            alt: image.alt ?? "Attached image",
-            className: "h-full w-full object-cover"
-          }
-        ),
-        image.loading && /* @__PURE__ */ jsx("div", { className: "absolute inset-0 flex items-center justify-center bg-black/40", children: /* @__PURE__ */ jsx("div", { className: "h-4 w-4 animate-spin rounded-full border-2 border-white border-t-transparent" }) }),
-        onRemove && /* @__PURE__ */ jsx(
-          RemoveButton,
-          {
-            onClick: () => onRemove(image),
-            label: `Remove ${image.alt ?? "image"}`
-          }
-        )
-      ]
-    },
-    image.id
-  )) });
-}
-function Svg({ className, children }) {
-  return /* @__PURE__ */ 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",
-      className,
-      children
-    }
-  );
-}
-var FileBody = /* @__PURE__ */ jsxs(Fragment, { children: [
-  /* @__PURE__ */ jsx("path", { d: "M6 22a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h8a2.4 2.4 0 0 1 1.704.706l3.588 3.588A2.4 2.4 0 0 1 20 8v12a2 2 0 0 1-2 2z" }),
-  /* @__PURE__ */ jsx("path", { d: "M14 2v5a1 1 0 0 0 1 1h5" })
-] });
-var File = ({ className }) => /* @__PURE__ */ jsx(Svg, { className, children: FileBody });
-var FileText = ({ className }) => /* @__PURE__ */ jsxs(Svg, { className, children: [
-  FileBody,
-  /* @__PURE__ */ jsx("path", { d: "M10 9H8" }),
-  /* @__PURE__ */ jsx("path", { d: "M16 13H8" }),
-  /* @__PURE__ */ jsx("path", { d: "M16 17H8" })
-] });
-var FileSpreadsheet = ({ className }) => /* @__PURE__ */ jsxs(Svg, { className, children: [
-  FileBody,
-  /* @__PURE__ */ jsx("path", { d: "M8 13h2" }),
-  /* @__PURE__ */ jsx("path", { d: "M14 13h2" }),
-  /* @__PURE__ */ jsx("path", { d: "M8 17h2" }),
-  /* @__PURE__ */ jsx("path", { d: "M14 17h2" })
-] });
-var FileCode = ({ className }) => /* @__PURE__ */ jsxs(Svg, { className, children: [
-  FileBody,
-  /* @__PURE__ */ jsx("path", { d: "M10 12.5 8 15l2 2.5" }),
-  /* @__PURE__ */ jsx("path", { d: "m14 12.5 2 2.5-2 2.5" })
-] });
-var ImageIcon = ({ className }) => /* @__PURE__ */ jsxs(Svg, { className, children: [
-  /* @__PURE__ */ jsx("rect", { width: "18", height: "18", x: "3", y: "3", rx: "2", ry: "2" }),
-  /* @__PURE__ */ jsx("circle", { cx: "9", cy: "9", r: "2" }),
-  /* @__PURE__ */ jsx("path", { d: "m21 15-3.086-3.086a2 2 0 0 0-2.828 0L6 21" })
-] });
-var COLLAPSE_THRESHOLD = 3;
-function getFileIconKey(type) {
-  if (!type) return "default";
-  if (type === "application/pdf") return "pdf";
-  if (type.includes("spreadsheet") || type === "text/csv") return "spreadsheet";
-  if (type.startsWith("text/") || type.includes("javascript") || type.includes("json") || type.includes("xml"))
-    return "code";
-  if (type.startsWith("image/")) return "image";
-  return "default";
-}
-var FILE_ICONS = {
-  pdf: FileText,
-  spreadsheet: FileSpreadsheet,
-  code: FileCode,
-  image: ImageIcon,
-  default: File
-};
-function formatFileSize(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
-}
-function getExtensionLabel(name) {
-  const dot = name.lastIndexOf(".");
-  if (dot === -1 || dot === name.length - 1) return null;
-  return name.slice(dot + 1).toUpperCase();
-}
-function FileCard({
-  file,
-  compact,
-  onRemove,
-  onClick
-}) {
-  const ext = getExtensionLabel(file.name);
-  const sizeStr = file.size != null ? formatFileSize(file.size) : null;
-  const meta = [ext, sizeStr].filter(Boolean).join(" \xB7 ");
-  return /* @__PURE__ */ jsxs(
-    "div",
-    {
-      role: "listitem",
-      className: cn(
-        "border-border relative flex flex-shrink-0 items-center gap-2 overflow-hidden rounded-lg border transition-colors",
-        "hover:bg-accent",
-        compact ? "h-10 w-36 px-2" : "h-14 w-48 px-3",
-        onClick && "cursor-pointer"
-      ),
-      onClick: () => onClick?.(file),
-      children: [
-        (() => {
-          const Icon = FILE_ICONS[getFileIconKey(file.type)];
-          return /* @__PURE__ */ jsx(
-            Icon,
-            {
-              className: cn("text-muted-foreground flex-shrink-0", compact ? "h-4 w-4" : "h-5 w-5")
-            }
-          );
-        })(),
-        /* @__PURE__ */ jsxs("div", { className: "min-w-0 flex-1", children: [
-          /* @__PURE__ */ jsx(
-            "div",
-            {
-              className: cn("truncate font-medium", compact ? "text-xs" : "text-sm"),
-              title: file.name,
-              children: file.name
-            }
-          ),
-          !compact && meta && /* @__PURE__ */ jsx("div", { className: "text-muted-foreground truncate text-xs", children: meta })
-        ] }),
-        file.loading && /* @__PURE__ */ jsx("div", { className: "absolute inset-0 flex items-center justify-center bg-black/40", children: /* @__PURE__ */ jsx("div", { className: "h-4 w-4 animate-spin rounded-full border-2 border-white border-t-transparent" }) }),
-        onRemove && /* @__PURE__ */ jsx(RemoveButton, { onClick: () => onRemove(file), label: `Remove ${file.name}` })
-      ]
-    }
-  );
-}
-function FileStrip({ files, onRemove, onClick, className }) {
-  const [expanded, setExpanded] = useState(false);
-  const popoverRef = useRef(null);
-  const toggleRef = useRef(null);
-  useEffect(() => {
-    if (!expanded) return;
-    const handleClick = (e) => {
-      const target = e.target;
-      if (popoverRef.current && !popoverRef.current.contains(target) && !toggleRef.current?.contains(target)) {
-        setExpanded(false);
-      }
-    };
-    document.addEventListener("mousedown", handleClick);
-    return () => document.removeEventListener("mousedown", handleClick);
-  }, [expanded]);
-  if (files.length === 0) return null;
-  const collapsible = files.length > COLLAPSE_THRESHOLD;
-  const compact = collapsible;
-  const hiddenCount = files.length - COLLAPSE_THRESHOLD;
-  const visibleFiles = files.slice(0, COLLAPSE_THRESHOLD);
-  return /* @__PURE__ */ jsxs("div", { className: cn("relative", className), children: [
-    /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap gap-2", role: "list", "aria-label": "Attached files", children: [
-      (collapsible ? visibleFiles : files).map((file) => /* @__PURE__ */ jsx(
-        FileCard,
-        {
-          file,
-          compact,
-          onRemove,
-          onClick
-        },
-        file.id
-      )),
-      collapsible && /* @__PURE__ */ jsx("div", { role: "listitem", children: /* @__PURE__ */ jsx(
-        "button",
-        {
-          ref: toggleRef,
-          type: "button",
-          onClick: () => setExpanded((v) => !v),
-          className: cn(
-            "border-border text-muted-foreground hover:bg-accent flex flex-shrink-0 cursor-pointer items-center justify-center rounded-lg border transition-colors",
-            compact ? "h-10 px-3 text-xs" : "h-14 px-4 text-sm"
-          ),
-          children: expanded ? "Show less" : `+${hiddenCount} more`
-        }
-      ) })
-    ] }),
-    expanded && /* @__PURE__ */ jsx(
-      "div",
-      {
-        ref: popoverRef,
-        className: cn(
-          "bg-popover border-border absolute bottom-full left-0 z-10 mb-2 max-h-48 overflow-y-auto rounded-lg border p-2 shadow-lg"
-        ),
-        children: /* @__PURE__ */ jsx("div", { className: "flex flex-wrap gap-2", role: "list", "aria-label": "More attached files", children: files.slice(COLLAPSE_THRESHOLD).map((file) => /* @__PURE__ */ jsx(
-          FileCard,
-          {
-            file,
-            compact,
-            onRemove,
-            onClick
-          },
-          file.id
-        )) })
-      }
-    )
-  ] });
-}
-function PromptArea({
-  value,
-  onChange,
-  triggers,
-  placeholder,
-  className,
-  disabled = false,
-  markdown,
-  onSubmit,
-  onEscape,
-  onChipClick,
-  onChipAdd,
-  onChipDelete,
-  onLinkClick,
-  onPaste,
-  onUndo,
-  onRedo,
-  minHeight = 80,
-  maxHeight,
-  autoFocus = false,
-  autoGrow = false,
-  "aria-label": ariaLabel,
-  "data-test-id": dataTestId,
-  images = [],
-  imagePosition = "above",
-  onImagePaste,
-  onImageRemove,
-  onImageClick,
-  files = [],
-  filePosition = "above",
-  onFileRemove,
-  onFileClick,
-  ref
-}) {
-  const {
-    editorRef,
-    activeTrigger,
-    suggestions,
-    suggestionsLoading,
-    suggestionsError,
-    selectedSuggestionIndex,
-    handleInput,
-    handleKeyDown,
-    handleClick,
-    selectSuggestion,
-    dismissTrigger,
-    handle,
-    triggerRect,
-    eventHandlers
-  } = usePromptArea({
-    value,
-    onChange,
-    triggers,
-    onSubmit,
-    onEscape,
-    onChipClick,
-    onChipAdd,
-    onChipDelete,
-    onLinkClick,
-    onPaste,
-    onUndo,
-    onRedo,
-    onImagePaste,
-    markdown
-  });
-  useImperativeHandle(ref, () => handle, [handle]);
-  useEffect(() => {
-    if (autoFocus) {
-      editorRef.current?.focus();
-    }
-  }, [autoFocus, editorRef]);
-  const [isFocused, setIsFocused] = useState(false);
-  const [editorHeight, setEditorHeight] = useState(void 0);
-  const syncHeight = useCallback(() => {
-    const el = editorRef.current;
-    if (!el) return;
-    el.style.height = "auto";
-    const contentHeight = el.scrollHeight;
-    el.style.height = `${contentHeight}px`;
-    setEditorHeight(contentHeight);
-  }, [editorRef]);
-  const handleFocus = useCallback(() => {
-    if (!autoGrow) return;
-    setIsFocused(true);
-    syncHeight();
-  }, [autoGrow, syncHeight]);
-  const handleBlurWithShrink = useCallback(() => {
-    eventHandlers.onBlur();
-    if (!autoGrow) return;
-    setTimeout(() => {
-      const editor = editorRef.current;
-      if (!editor) return;
-      const activeEl = document.activeElement;
-      if (activeEl && editor.parentElement?.contains(activeEl)) return;
-      setIsFocused(false);
-      setEditorHeight(void 0);
-    }, BLUR_DELAY_MS);
-  }, [eventHandlers, autoGrow, editorRef]);
-  const handleInputWithGrow = useCallback(() => {
-    handleInput();
-    if (autoGrow && isFocused) {
-      syncHeight();
-    }
-  }, [handleInput, autoGrow, isFocused, syncHeight]);
-  useEffect(() => {
-    if (autoGrow && isFocused) {
-      requestAnimationFrame(() => syncHeight());
-    }
-  }, [value, autoGrow, isFocused, syncHeight]);
-  const [hasOverflow, setHasOverflow] = useState(false);
-  const overflowTimerRef = useRef(null);
-  useEffect(() => {
-    if (!autoGrow) return;
-    const checkOverflow = () => {
-      if (isFocused) {
-        setHasOverflow(false);
-        return;
-      }
-      const el = editorRef.current;
-      if (!el) return;
-      setHasOverflow(el.scrollHeight > el.clientHeight);
-    };
-    const delay = isFocused ? 0 : 160;
-    overflowTimerRef.current = setTimeout(checkOverflow, delay);
-    return () => {
-      if (overflowTimerRef.current !== null) {
-        clearTimeout(overflowTimerRef.current);
-      }
-    };
-  }, [autoGrow, isFocused, value, editorRef]);
-  const editorStyle = useMemo(() => {
-    if (!autoGrow) {
-      return {
-        minHeight: `${minHeight}px`,
-        ...maxHeight ? { maxHeight: `${maxHeight}px`, overflowY: "auto" } : {}
-      };
-    }
-    return {
-      height: isFocused && editorHeight ? `${editorHeight}px` : `${minHeight}px`,
-      minHeight: `${minHeight}px`,
-      maxHeight: "70dvh",
-      overflowY: isFocused ? "auto" : "hidden",
-      transition: "height 150ms ease-out"
-    };
-  }, [autoGrow, minHeight, maxHeight, isFocused, editorHeight]);
-  const isEmpty = value.length === 0 || value.length === 1 && value[0].type === "text" && value[0].text === "";
-  const imageStrip = images.length > 0 ? /* @__PURE__ */ jsx(
-    ImageStrip,
-    {
-      images,
-      onRemove: onImageRemove,
-      onClick: onImageClick,
-      className: imagePosition === "above" ? "pb-2" : "pt-2"
-    }
-  ) : null;
-  const fileStrip = files.length > 0 ? /* @__PURE__ */ jsx(
-    FileStrip,
-    {
-      files,
-      onRemove: onFileRemove,
-      onClick: onFileClick,
-      className: filePosition === "above" ? "pb-2" : "pt-2"
-    }
-  ) : null;
-  return /* @__PURE__ */ jsxs("div", { className: cn("prompt-area-container relative", className), children: [
-    imagePosition === "above" && imageStrip,
-    filePosition === "above" && fileStrip,
-    /* @__PURE__ */ jsxs("div", { className: "relative", children: [
-      /* @__PURE__ */ jsx(
-        "div",
-        {
-          ref: editorRef,
-          contentEditable: !disabled,
-          suppressContentEditableWarning: true,
-          role: "textbox",
-          "aria-label": ariaLabel ?? "Text input",
-          "aria-multiline": "true",
-          "aria-disabled": disabled || void 0,
-          "data-test-id": dataTestId,
-          className: cn(
-            "prompt-area-editor",
-            "w-full min-w-0 break-words whitespace-pre-wrap outline-none",
-            "text-sm leading-relaxed",
-            disabled && "cursor-not-allowed opacity-50"
-          ),
-          style: editorStyle,
-          onFocus: handleFocus,
-          onInput: autoGrow ? handleInputWithGrow : handleInput,
-          onKeyDown: handleKeyDown,
-          onClick: handleClick,
-          onPaste: eventHandlers.onPaste,
-          onCopy: eventHandlers.onCopy,
-          onCut: eventHandlers.onCut,
-          onDrop: eventHandlers.onDrop,
-          onDragOver: eventHandlers.onDragOver,
-          onCompositionStart: eventHandlers.onCompositionStart,
-          onCompositionEnd: eventHandlers.onCompositionEnd,
-          onBlur: autoGrow ? handleBlurWithShrink : eventHandlers.onBlur
-        }
-      ),
-      autoGrow && hasOverflow && !isFocused && /* @__PURE__ */ jsx(
-        "div",
-        {
-          "aria-hidden": "true",
-          className: "pointer-events-auto absolute right-0 bottom-0 left-0 cursor-pointer",
-          style: { height: "32px" },
-          onClick: () => editorRef.current?.focus(),
-          children: /* @__PURE__ */ jsx(
-            "div",
-            {
-              className: "h-full w-full",
-              style: {
-                background: "linear-gradient(to bottom, transparent, color-mix(in srgb, var(--prompt-area-surface, var(--background)) 80%, transparent), var(--prompt-area-surface, var(--background)))"
-              }
-            }
-          )
-        }
-      ),
-      isEmpty && placeholder && (Array.isArray(placeholder) ? /* @__PURE__ */ jsx(AnimatedPlaceholder, { texts: placeholder }) : /* @__PURE__ */ jsx(
-        "div",
-        {
-          className: "pointer-events-none absolute top-0 left-0 text-sm leading-relaxed select-none",
-          style: { color: "var(--prompt-area-placeholder, var(--muted-foreground))" },
-          "aria-hidden": "true",
-          children: placeholder
-        }
-      ))
-    ] }),
-    filePosition === "below" && fileStrip,
-    imagePosition === "below" && imageStrip,
-    activeTrigger && activeTrigger.config.mode === "dropdown" && /* @__PURE__ */ jsx(
-      TriggerPopover,
-      {
-        suggestions,
-        loading: suggestionsLoading,
-        error: suggestionsError,
-        emptyMessage: activeTrigger.config.emptyMessage,
-        selectedIndex: selectedSuggestionIndex,
-        onSelect: selectSuggestion,
-        onDismiss: dismissTrigger,
-        triggerRect,
-        triggerChar: activeTrigger.config.char
-      }
-    )
-  ] });
-}
-
-export { BLUR_DELAY_MS, PromptArea, detectActiveTrigger, isValidTriggerPosition, mergeAdjacentTextSegments, parseInlineMarkdown, plainTextToSegments, resolveChip, resolveTriggersInSegments, segmentsEqual, segmentsToPlainText, usePromptArea };
-//# sourceMappingURL=chunk-E7HUXORB.js.map
-//# sourceMappingURL=chunk-E7HUXORB.js.map