@elabs-ai/components-ui 4.2.0 → 5.0.0

package/dist/chunk-U26XDHMX.js

@@ -0,0 +1,726 @@
+"use client";
+import {
+  defaultMentionFilter,
+  insertMention,
+  mentionAt,
+  mentionEnd,
+  remapMentions
+} from "./chunk-NMGNXW3J.js";
+import {
+  findTriggerQuery
+} from "./chunk-AZEABCK4.js";
+import {
+  mergeRefs
+} from "./chunk-L37QZALU.js";
+import {
+  Popover,
+  PopoverAnchor,
+  PopoverContent
+} from "./chunk-D3C3VVCX.js";
+import {
+  Textarea
+} from "./chunk-KUAVM54Y.js";
+import {
+  useLocale
+} from "./chunk-EJQYE4MY.js";
+import {
+  cn
+} from "./chunk-KBNWM27Q.js";
+
+// src/components/mention-input/mention-input.tsx
+import {
+  createContext,
+  forwardRef,
+  use,
+  useCallback,
+  useEffect,
+  useId,
+  useLayoutEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { Slot } from "@radix-ui/react-slot";
+import { jsx, jsxs } from "react/jsx-runtime";
+var EMPTY_VALUE = { text: "", mentions: [] };
+var MentionInputContext = createContext(null);
+function useMentionInput() {
+  const ctx = use(MentionInputContext);
+  if (!ctx) {
+    throw new Error("useMentionInput must be used inside a <MentionInput>.");
+  }
+  return ctx;
+}
+function step(list, from, direction) {
+  const count = list.length;
+  if (count === 0) return -1;
+  for (let i = 1; i <= count; i++) {
+    const index = ((from + direction * i) % count + count) % count;
+    if (!list[index]?.disabled) return index;
+  }
+  return -1;
+}
+function firstEnabled(list) {
+  const index = list.findIndex((o) => !o.disabled);
+  return index;
+}
+function lastEnabled(list) {
+  for (let i = list.length - 1; i >= 0; i--) {
+    if (!list[i]?.disabled) return i;
+  }
+  return -1;
+}
+var MIRRORED_PROPERTIES = [
+  "boxSizing",
+  "paddingTop",
+  "paddingRight",
+  "paddingBottom",
+  "paddingLeft",
+  "borderTopWidth",
+  "borderRightWidth",
+  "borderBottomWidth",
+  "borderLeftWidth",
+  "fontFamily",
+  "fontSize",
+  "fontWeight",
+  "fontStyle",
+  "fontVariant",
+  "fontStretch",
+  "fontFeatureSettings",
+  "fontVariationSettings",
+  "letterSpacing",
+  "lineHeight",
+  "textTransform",
+  "textIndent",
+  "wordSpacing",
+  "textAlign",
+  "direction",
+  "tabSize",
+  // Wrapping, copied rather than assumed: forcing `word-break: break-word` when
+  // the field says `normal` breaks long words one line early in the mirror.
+  "whiteSpace",
+  "overflowWrap",
+  "wordBreak"
+];
+var EXTRA_MIRROR_KEYS = [
+  "position",
+  "left",
+  "top",
+  "width",
+  "height",
+  "borderStyle",
+  "borderColor",
+  "overflow",
+  "margin"
+];
+function stylesEqual(a, b) {
+  const record = a;
+  const other = b;
+  for (const key of MIRRORED_PROPERTIES) {
+    if (record[key] !== other[key]) return false;
+  }
+  for (const key of EXTRA_MIRROR_KEYS) {
+    if (record[key] !== other[key]) return false;
+  }
+  return true;
+}
+function readMirrorStyle(textarea) {
+  const computed = getComputedStyle(textarea);
+  const style = {};
+  for (const property of MIRRORED_PROPERTIES) {
+    style[property] = computed[property];
+  }
+  const borderX = Number.parseFloat(computed.borderLeftWidth || "0") + Number.parseFloat(computed.borderRightWidth || "0");
+  const scrollbar = Math.max(0, textarea.offsetWidth - textarea.clientWidth - borderX);
+  return {
+    ...style,
+    position: "absolute",
+    left: textarea.offsetLeft,
+    top: textarea.offsetTop,
+    width: textarea.offsetWidth,
+    height: textarea.offsetHeight,
+    paddingRight: Number.parseFloat(computed.paddingRight || "0") + scrollbar,
+    borderStyle: "solid",
+    borderColor: "transparent",
+    // A textarea already computes `pre-wrap`; the fallback only covers a host
+    // that reset it, and an environment (jsdom) that resolves nothing.
+    whiteSpace: computed.whiteSpace || "pre-wrap",
+    overflow: "hidden",
+    margin: 0
+  };
+}
+function buildRuns(value, trigger) {
+  const runs = [];
+  const ordered = [...value.mentions].sort((a, b) => a.start - b.start);
+  let cursor = 0;
+  for (const mention of ordered) {
+    if (mention.start > cursor) {
+      runs.push({ key: `t${cursor}`, text: value.text.slice(cursor, mention.start) });
+    }
+    const end = mentionEnd(mention, trigger);
+    runs.push({ key: `m${mention.start}`, text: value.text.slice(mention.start, end), mention });
+    cursor = end;
+  }
+  if (cursor < value.text.length) {
+    runs.push({ key: `t${cursor}`, text: value.text.slice(cursor) });
+  }
+  return runs;
+}
+var MentionInput = forwardRef(function MentionInput2({
+  options,
+  value: valueProp,
+  defaultValue,
+  onValueChange,
+  trigger = "@",
+  filter = defaultMentionFilter,
+  onQueryChange,
+  open: openProp,
+  onOpenChange,
+  className,
+  children,
+  ...props
+}, ref) {
+  const uid = useId();
+  const listId = `${uid}-listbox`;
+  const textareaId = `${uid}-textarea`;
+  const optionId = useCallback((index) => `${uid}-option-${index}`, [uid]);
+  const rootRef = useRef(null);
+  const mergedRootRef = useMemo(() => mergeRefs(ref, rootRef), [ref]);
+  const textareaRef = useRef(null);
+  const isControlled = valueProp !== void 0;
+  const [internalValue, setInternalValue] = useState(defaultValue ?? EMPTY_VALUE);
+  const value = isControlled ? valueProp : internalValue;
+  const commit = useCallback(
+    (next) => {
+      if (!isControlled) setInternalValue(next);
+      onValueChange?.(next);
+    },
+    [isControlled, onValueChange]
+  );
+  const [caret, setCaret] = useState(() => (defaultValue?.text ?? "").length);
+  const pendingCaretRef = useRef(null);
+  const applyCaret = useCallback((position) => {
+    pendingCaretRef.current = position;
+    setCaret(position);
+    textareaRef.current?.setSelectionRange(position, position);
+  }, []);
+  useLayoutEffect(() => {
+    const position = pendingCaretRef.current;
+    if (position === null) return;
+    pendingCaretRef.current = null;
+    textareaRef.current?.setSelectionRange(position, position);
+  });
+  const queryInfo = useMemo(
+    () => findTriggerQuery(value.text, caret, trigger, {
+      isTriggerConsumed: (start) => mentionAt(value, start, trigger) !== void 0
+    }),
+    [value, caret, trigger]
+  );
+  const [dismissedStart, setDismissedStart] = useState(null);
+  useEffect(() => {
+    if (queryInfo === null && dismissedStart !== null) setDismissedStart(null);
+  }, [queryInfo, dismissedStart]);
+  const derivedOpen = queryInfo !== null && dismissedStart !== queryInfo.start;
+  const open = openProp ?? derivedOpen;
+  const query = open && queryInfo ? queryInfo.query : null;
+  const setOpen = useCallback(
+    (next) => {
+      onOpenChange?.(next);
+      if (!next) setDismissedStart(queryInfo?.start ?? null);
+    },
+    [onOpenChange, queryInfo]
+  );
+  const onQueryChangeRef = useRef(onQueryChange);
+  useEffect(() => {
+    onQueryChangeRef.current = onQueryChange;
+  }, [onQueryChange]);
+  useEffect(() => {
+    onQueryChangeRef.current?.(query);
+  }, [query]);
+  const filtered = useMemo(
+    () => open && query !== null ? options.filter((option) => filter(option, query)) : [],
+    [open, query, options, filter]
+  );
+  const [activeIndexState, setActiveIndexState] = useState(0);
+  const activeIndex = useMemo(() => {
+    const candidate = filtered[activeIndexState];
+    if (candidate && !candidate.disabled) return activeIndexState;
+    return firstEnabled(filtered);
+  }, [filtered, activeIndexState]);
+  useEffect(() => {
+    setActiveIndexState(0);
+  }, [query]);
+  const activeId = activeIndex >= 0 ? optionId(activeIndex) : void 0;
+  const insert = useCallback(
+    (option) => {
+      if (option.disabled || !queryInfo) return;
+      const result = insertMention(value, option, trigger, queryInfo.start, caret);
+      commit(result.value);
+      applyCaret(result.caret);
+    },
+    [queryInfo, value, trigger, caret, commit, applyCaret]
+  );
+  const close = useCallback(() => {
+    setOpen(false);
+  }, [setOpen]);
+  const removeMention = useCallback(
+    (mention) => {
+      const end = mentionEnd(mention, trigger);
+      const nextText = value.text.slice(0, mention.start) + value.text.slice(end);
+      commit({ text: nextText, mentions: remapMentions(value, nextText, trigger) });
+      applyCaret(mention.start);
+    },
+    [value, trigger, commit, applyCaret]
+  );
+  const syncCaret = useCallback((element) => {
+    setCaret(element.selectionStart ?? 0);
+  }, []);
+  const handleChange = useCallback(
+    (element) => {
+      const nextText = element.value;
+      commit({ text: nextText, mentions: remapMentions(value, nextText, trigger) });
+      setCaret(element.selectionStart ?? nextText.length);
+    },
+    [commit, value, trigger]
+  );
+  const handleKeyDownCapture = useCallback(
+    (event) => {
+      const element = event.currentTarget;
+      const position = element.selectionStart ?? 0;
+      const hasRange = element.selectionStart !== element.selectionEnd;
+      if (open) {
+        switch (event.key) {
+          case "ArrowDown":
+            event.preventDefault();
+            setActiveIndexState(step(filtered, activeIndex, 1));
+            return;
+          case "ArrowUp":
+            event.preventDefault();
+            setActiveIndexState(step(filtered, activeIndex < 0 ? 0 : activeIndex, -1));
+            return;
+          case "Home":
+            event.preventDefault();
+            setActiveIndexState(firstEnabled(filtered));
+            return;
+          case "End":
+            event.preventDefault();
+            setActiveIndexState(lastEnabled(filtered));
+            return;
+          case "Enter":
+          case "Tab": {
+            const option = activeIndex >= 0 ? filtered[activeIndex] : void 0;
+            if (option && !option.disabled) {
+              event.preventDefault();
+              insert(option);
+            }
+            return;
+          }
+          case "Escape":
+            event.preventDefault();
+            close();
+            return;
+          default:
+            break;
+        }
+      }
+      if (hasRange || event.metaKey || event.ctrlKey || event.altKey) return;
+      if (event.key === "Backspace") {
+        const mention = mentionAt(value, position - 1, trigger);
+        if (mention) {
+          event.preventDefault();
+          removeMention(mention);
+        }
+        return;
+      }
+      if (event.key === "Delete") {
+        const mention = mentionAt(value, position, trigger);
+        if (mention) {
+          event.preventDefault();
+          removeMention(mention);
+        }
+        return;
+      }
+      if (event.key === "ArrowLeft" && !event.shiftKey) {
+        const mention = mentionAt(value, position - 1, trigger);
+        if (mention && position - 1 > mention.start) {
+          event.preventDefault();
+          applyCaret(mention.start);
+        }
+        return;
+      }
+      if (event.key === "ArrowRight" && !event.shiftKey) {
+        const mention = mentionAt(value, position, trigger);
+        if (mention) {
+          event.preventDefault();
+          applyCaret(mentionEnd(mention, trigger));
+        }
+      }
+    },
+    [open, filtered, activeIndex, insert, close, value, trigger, removeMention, applyCaret]
+  );
+  const [mirrorStyle, setMirrorStyle] = useState(null);
+  const [scrollTop, setScrollTop] = useState(0);
+  const caretMarkerRef = useRef(null);
+  const [caretRect, setCaretRect] = useState({ left: 0, top: 0, height: 0 });
+  const remeasureMirror = useCallback(() => {
+    const element = textareaRef.current;
+    if (!element) return;
+    const next = readMirrorStyle(element);
+    setMirrorStyle((previous) => previous && stylesEqual(previous, next) ? previous : next);
+  }, []);
+  useLayoutEffect(() => {
+    remeasureMirror();
+  }, [remeasureMirror, value.text]);
+  useLayoutEffect(() => {
+    const element = textareaRef.current;
+    if (!element) return;
+    const teardown = [];
+    if (typeof ResizeObserver !== "undefined") {
+      const observer = new ResizeObserver(remeasureMirror);
+      observer.observe(element);
+      teardown.push(() => observer.disconnect());
+    }
+    if (typeof MutationObserver !== "undefined") {
+      const fieldObserver = new MutationObserver(remeasureMirror);
+      fieldObserver.observe(element, {
+        attributes: true,
+        attributeFilter: ["class", "style"]
+      });
+      teardown.push(() => fieldObserver.disconnect());
+      const themeScope = element.closest("[data-theme]") ?? (typeof document !== "undefined" ? document.documentElement : null);
+      if (themeScope) {
+        const themeObserver = new MutationObserver(remeasureMirror);
+        themeObserver.observe(themeScope, {
+          attributes: true,
+          attributeFilter: ["data-theme", "data-density", "data-decoration"]
+        });
+        teardown.push(() => themeObserver.disconnect());
+      }
+    }
+    let cancelled = false;
+    void document.fonts?.ready.then(() => {
+      if (!cancelled) remeasureMirror();
+    }).catch(() => void 0);
+    teardown.push(() => {
+      cancelled = true;
+    });
+    return () => {
+      for (const fn of teardown) fn();
+    };
+  }, [remeasureMirror]);
+  useLayoutEffect(() => {
+    if (!open) return;
+    const marker = caretMarkerRef.current;
+    const root = rootRef.current;
+    if (!marker || !root) return;
+    const rect = marker.getClientRects()[0] ?? marker.getBoundingClientRect();
+    const rootRect = root.getBoundingClientRect();
+    const next = {
+      left: rect.left - rootRect.left,
+      top: rect.top - rootRect.top,
+      height: rect.height
+    };
+    setCaretRect(
+      (previous) => previous.left === next.left && previous.top === next.top && previous.height === next.height ? previous : next
+    );
+  }, [open, caret, value.text, mirrorStyle, scrollTop]);
+  const runs = useMemo(() => buildRuns(value, trigger), [value, trigger]);
+  const contextValue = useMemo(
+    () => ({
+      state: { value, query, open, activeIndex, activeId, filtered },
+      actions: { insert, close, setActiveIndex: setActiveIndexState },
+      meta: { trigger, listId, textareaId, optionId }
+    }),
+    [
+      value,
+      query,
+      open,
+      activeIndex,
+      activeId,
+      filtered,
+      insert,
+      close,
+      trigger,
+      listId,
+      textareaId,
+      optionId
+    ]
+  );
+  const textareaContextValue = useMemo(
+    () => ({
+      textareaRef,
+      textareaId,
+      listId,
+      open,
+      activeId,
+      value: value.text,
+      onValueInput: handleChange,
+      onCaretSync: syncCaret,
+      onKeyDownCapture: handleKeyDownCapture,
+      onDismiss: close,
+      onScrollSync: setScrollTop
+    }),
+    [
+      textareaId,
+      listId,
+      open,
+      activeId,
+      value.text,
+      handleChange,
+      syncCaret,
+      handleKeyDownCapture,
+      close
+    ]
+  );
+  return /* @__PURE__ */ jsx(Popover, { open, onOpenChange: setOpen, children: /* @__PURE__ */ jsx(MentionInputContext, { value: contextValue, children: /* @__PURE__ */ jsx(TextareaWiringContext, { value: textareaContextValue, children: /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: mergedRootRef,
+      "data-slot": "mention-input",
+      className: cn("relative", className),
+      ...props,
+      children: [
+        children,
+        mirrorStyle ? /* @__PURE__ */ jsx(
+          "div",
+          {
+            "data-slot": "mention-input-overlay",
+            "aria-hidden": "true",
+            className: "pointer-events-none select-none text-transparent",
+            style: { ...mirrorStyle, zIndex: 1 },
+            children: /* @__PURE__ */ jsx("div", { style: { transform: `translateY(${-scrollTop}px)` }, children: runs.map(
+              (run) => run.mention ? /* @__PURE__ */ jsx(
+                "span",
+                {
+                  "data-slot": "mention-input-chip",
+                  className: "box-decoration-clone rounded-sm bg-primary/10",
+                  children: run.text
+                },
+                run.key
+              ) : /* @__PURE__ */ jsx("span", { children: run.text }, run.key)
+            ) })
+          }
+        ) : null,
+        open && mirrorStyle ? /* @__PURE__ */ jsx(
+          "div",
+          {
+            "data-slot": "mention-input-caret-mirror",
+            "aria-hidden": "true",
+            className: "pointer-events-none select-none",
+            style: { ...mirrorStyle, visibility: "hidden", zIndex: -1 },
+            children: /* @__PURE__ */ jsxs("div", { style: { transform: `translateY(${-scrollTop}px)` }, children: [
+              value.text.slice(0, caret),
+              /* @__PURE__ */ jsx("span", { ref: caretMarkerRef, children: value.text.slice(caret) || "." })
+            ] })
+          }
+        ) : null,
+        /* @__PURE__ */ jsx(PopoverAnchor, { asChild: true, children: /* @__PURE__ */ jsx(
+          "span",
+          {
+            "data-slot": "mention-input-anchor",
+            "aria-hidden": "true",
+            className: "pointer-events-none absolute",
+            style: {
+              left: caretRect.left,
+              top: caretRect.top,
+              width: 0,
+              height: caretRect.height
+            }
+          }
+        ) })
+      ]
+    }
+  ) }) }) });
+});
+var TextareaWiringContext = createContext(null);
+var MentionInputTextarea = forwardRef(
+  function MentionInputTextarea2({
+    asChild,
+    className,
+    // The seven handlers this component owns are destructured OUT of `props`
+    // so `{...props}` can be spread BEFORE them without clobbering them.
+    // Spreading props last (the obvious reading of "spread ...props onto the
+    // root") silently replaced the component's own wiring: a consumer passing
+    // `onChange` used to knock out `wiring.onValueInput`, and since the value
+    // is provider-controlled that left the field completely inert. Consumer
+    // handlers still run — each one is invoked from inside its counterpart —
+    // and every NON-handler prop (`id`, `name`, `aria-*`, `placeholder`, …)
+    // still wins, because the spread sits after those defaults.
+    onChange,
+    onKeyDownCapture,
+    onSelect,
+    onKeyUp,
+    onClick,
+    onScroll,
+    onBlur,
+    ...props
+  }, ref) {
+    const wiring = use(TextareaWiringContext);
+    if (!wiring) {
+      throw new Error("MentionInputTextarea must be used inside a <MentionInput>.");
+    }
+    const mergedRef = useMemo(
+      () => mergeRefs(ref, wiring.textareaRef),
+      [ref, wiring.textareaRef]
+    );
+    const Comp = asChild ? Slot : Textarea;
+    return /* @__PURE__ */ jsx(
+      Comp,
+      {
+        ref: mergedRef,
+        id: wiring.textareaId,
+        "data-slot": "mention-input-textarea",
+        "data-state": wiring.open ? "open" : "closed",
+        "aria-autocomplete": "list",
+        "aria-haspopup": "listbox",
+        "aria-controls": wiring.open ? wiring.listId : void 0,
+        "aria-activedescendant": wiring.activeId,
+        autoComplete: "off",
+        value: wiring.value,
+        className: cn("relative z-0", className),
+        ...props,
+        onChange: (event) => {
+          wiring.onValueInput(event.currentTarget);
+          onChange?.(event);
+        },
+        onKeyDownCapture: (event) => {
+          wiring.onKeyDownCapture(event);
+          onKeyDownCapture?.(event);
+        },
+        onSelect: (event) => {
+          wiring.onCaretSync(event.currentTarget);
+          onSelect?.(event);
+        },
+        onKeyUp: (event) => {
+          wiring.onCaretSync(event.currentTarget);
+          onKeyUp?.(event);
+        },
+        onClick: (event) => {
+          wiring.onCaretSync(event.currentTarget);
+          onClick?.(event);
+        },
+        onScroll: (event) => {
+          wiring.onScrollSync(event.currentTarget.scrollTop);
+          onScroll?.(event);
+        },
+        onBlur: (event) => {
+          wiring.onDismiss();
+          onBlur?.(event);
+        }
+      }
+    );
+  }
+);
+var MentionInputContent = forwardRef(function MentionInputContent2({ className, align = "start", ...props }, ref) {
+  const { meta } = useMentionInput();
+  const wiring = use(TextareaWiringContext);
+  return /* @__PURE__ */ jsx(
+    PopoverContent,
+    {
+      ref,
+      "data-slot": "mention-input-content",
+      align,
+      role: "presentation",
+      className: cn("w-72 p-0", className),
+      onOpenAutoFocus: (event) => event.preventDefault(),
+      onCloseAutoFocus: (event) => event.preventDefault(),
+      onPointerDownOutside: (event) => {
+        const target = event.detail.originalEvent.target;
+        if (target && wiring?.textareaRef.current?.contains(target)) event.preventDefault();
+        props.onPointerDownOutside?.(event);
+      },
+      id: `${meta.listId}-content`,
+      ...props
+    }
+  );
+});
+var MentionInputList = forwardRef(
+  function MentionInputList2({ className, children, ...props }, ref) {
+    const { t } = useLocale();
+    const { state, meta } = useMentionInput();
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        id: meta.listId,
+        "data-slot": "mention-input-list",
+        role: "listbox",
+        "aria-label": t("ui.mentionInput.listLabel"),
+        className: cn("max-h-60 overflow-y-auto p-1", className),
+        ...props,
+        children: typeof children === "function" ? state.filtered.map((option, index) => children(option, index)) : children
+      }
+    );
+  }
+);
+var MentionInputItem = forwardRef(
+  function MentionInputItem2({ option, className, children, ...props }, ref) {
+    const { state, actions, meta } = useMentionInput();
+    const index = state.filtered.findIndex((candidate) => candidate.id === option.id);
+    const isActive = index >= 0 && index === state.activeIndex;
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        id: index >= 0 ? meta.optionId(index) : void 0,
+        "data-slot": "mention-input-item",
+        role: "option",
+        "aria-selected": isActive,
+        "aria-disabled": option.disabled || void 0,
+        "data-active": isActive || void 0,
+        className: cn(
+          "relative flex cursor-pointer select-none items-center gap-2 rounded-sm px-2 py-1.5",
+          "text-body outline-none transition-colors duration-fast motion-reduce:transition-none",
+          "data-[active=true]:bg-accent data-[active=true]:text-accent-foreground",
+          "aria-disabled:pointer-events-none aria-disabled:opacity-50 [&_svg]:size-4",
+          className
+        ),
+        onMouseDown: (event) => {
+          event.preventDefault();
+          props.onMouseDown?.(event);
+        },
+        onClick: (event) => {
+          actions.insert(option);
+          props.onClick?.(event);
+        },
+        onMouseEnter: (event) => {
+          if (!option.disabled && index >= 0) actions.setActiveIndex(index);
+          props.onMouseEnter?.(event);
+        },
+        ...props,
+        children: children ?? /* @__PURE__ */ jsxs("span", { className: "flex min-w-0 flex-col", children: [
+          /* @__PURE__ */ jsx("span", { className: "truncate", children: option.label }),
+          option.description ? /* @__PURE__ */ jsx("span", { className: "truncate text-meta text-muted-foreground", children: option.description }) : null
+        ] })
+      }
+    );
+  }
+);
+var MentionInputEmpty = forwardRef(
+  function MentionInputEmpty2({ className, children, ...props }, ref) {
+    const { t } = useLocale();
+    const { state } = useMentionInput();
+    if (state.filtered.length > 0) return null;
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        "data-slot": "mention-input-empty",
+        className: cn("py-6 text-center text-body text-muted-foreground", className),
+        ...props,
+        children: children ?? t("noResults")
+      }
+    );
+  }
+);
+
+export {
+  useMentionInput,
+  MentionInput,
+  MentionInputTextarea,
+  MentionInputContent,
+  MentionInputList,
+  MentionInputItem,
+  MentionInputEmpty
+};
+//# sourceMappingURL=chunk-U26XDHMX.js.map