@frontera-sdk/chat-ui 1.50.40

package/dist/chunk-XJFTVKLW.js

@@ -0,0 +1,2687 @@
+'use client';
+import { Button, Skeleton, ScrollArea } from './chunk-GTQH7MPF.js';
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogDescription } from './chunk-IQRPGFLI.js';
+import { cn } from './chunk-DGDHKMDB.js';
+import { SquareArrowTopRightIcon, Checkmark1Icon, ClipboardIcon, Book3Icon, ChevronDownMediumIcon, ApiAppIcon, TextToImageIcon, Robot4Icon, DeviceDesktopIcon, PhotoIcon, Code2Icon, Terminal2Icon, Folder1Icon, PencilIcon, FileTextIcon, WritingIcon, WorldSearchIcon, icons_exports } from './chunk-AFVU5VT6.js';
+import '@radix-ui/react-slot';
+import { cva } from 'class-variance-authority';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import * as CollapsiblePrimitive from '@radix-ui/react-collapsible';
+import * as HoverCardPrimitive from '@radix-ui/react-hover-card';
+import React, { useMemo, memo, forwardRef, useState, useEffect, createElement, useRef, useCallback } from 'react';
+import { Streamdown } from 'streamdown';
+import { motion } from 'motion/react';
+import { cjk } from '@streamdown/cjk';
+import { createMathPlugin } from '@streamdown/math';
+import { visit } from 'unist-util-visit';
+import { visitParents } from 'unist-util-visit-parents';
+
+cva(
+  "inline-flex items-center justify-center rounded-full border px-2 py-0.5 text-xs font-medium w-fit whitespace-nowrap shrink-0 [&>svg]:size-3 gap-1 [&>svg]:pointer-events-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive transition-[color,box-shadow] overflow-hidden",
+  {
+    variants: {
+      variant: {
+        default: "border-transparent bg-primary text-primary-foreground [a&]:hover:bg-primary/90",
+        secondary: "border-transparent bg-secondary text-secondary-foreground [a&]:hover:bg-secondary/90",
+        destructive: "border-transparent bg-destructive text-white [a&]:hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
+        outline: "text-foreground [a&]:hover:bg-accent [a&]:hover:text-accent-foreground"
+      }
+    },
+    defaultVariants: {
+      variant: "default"
+    }
+  }
+);
+var Collapsible = CollapsiblePrimitive.Root;
+var CollapsibleTrigger2 = CollapsiblePrimitive.CollapsibleTrigger;
+var CollapsibleContent2 = CollapsiblePrimitive.CollapsibleContent;
+var HoverCard = HoverCardPrimitive.Root;
+var HoverCardTrigger = HoverCardPrimitive.Trigger;
+function HoverCardContent({
+  className,
+  align = "center",
+  sideOffset = 4,
+  ...props
+}) {
+  return (
+    // Portalled like every other popup primitive here. Rendered inline it is
+    // clipped by any scrolling or `overflow-hidden` ancestor — a citation
+    // hover card inside a message card was cut off at the card's edge — and
+    // its z-100 is trapped in whatever stacking context that ancestor makes.
+    /* @__PURE__ */ jsx(HoverCardPrimitive.Portal, { children: /* @__PURE__ */ jsx(
+      HoverCardPrimitive.Content,
+      {
+        align,
+        sideOffset,
+        className: cn(
+          // Fade only, 100ms, ease-out. The old 150ms stacked a fade with a
+          // zoom-95 and a 2px slide, on `ease` — which starts slow, so the
+          // frames that confirm the click were the slowest, and the movement
+          // made a menu read as ARRIVING rather than already being there.
+          "data-[state=open]:animate-in data-[state=open]:fade-in-0 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 duration-100 ease-out z-100 w-64 rounded-md border bg-surface-overlay p-4 text-popover-foreground shadow-md outline-none",
+          className
+        ),
+        ...props
+      }
+    ) })
+  );
+}
+function componentName(icon) {
+  const joined = icon.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+  return /^[0-9]/.test(joined) ? `Icon_${joined}Icon` : `${joined}Icon`;
+}
+function normalizeFronteraIconName(value) {
+  return (value ?? "").trim().replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function resolveFronteraIcon(name) {
+  const key = componentName(normalizeFronteraIconName(name));
+  const icons = icons_exports;
+  return icons[key] ?? null;
+}
+function FronteraIcon({ icon, ...props }) {
+  const Icon3 = resolveFronteraIcon(icon);
+  if (!Icon3) {
+    return /* @__PURE__ */ jsx("span", { "aria-hidden": true, style: { display: "inline-block", width: "1em", height: "1em" } });
+  }
+  return /* @__PURE__ */ jsx(Icon3, { ...props });
+}
+var frontera_icon_default = FronteraIcon;
+var Shimmer = React.memo(({
+  children,
+  as: Component = "p",
+  className,
+  duration = 1.5,
+  spread = 2,
+  delay = 0,
+  repeatDelay = 0.5
+}) => {
+  const MotionComponent = useMemo(
+    () => motion.create(Component),
+    [Component]
+  );
+  const dynamicSpread = useMemo(() => {
+    return children.length * spread;
+  }, [children, spread]);
+  return /* @__PURE__ */ jsx(
+    MotionComponent,
+    {
+      className: cn(
+        "relative inline-block bg-size-[250%_100%,auto] bg-clip-text",
+        "text-transparent [--base-color:var(--color-muted-foreground)] [--base-gradient-color:var(--color-foreground)]",
+        "[background-repeat:no-repeat,padding-box] [--bg:linear-gradient(90deg,#0000_calc(50%-var(--spread)),var(--base-gradient-color),#0000_calc(50%+var(--spread)))]",
+        "dark:[--base-color:var(--color-muted-foreground)] dark:[--base-gradient-color:var(--color-foreground)] dark:[--bg:linear-gradient(90deg,#0000_calc(50%-var(--spread)),var(--base-gradient-color),#0000_calc(50%+var(--spread)))]",
+        className
+      ),
+      initial: { backgroundPosition: "105% center" },
+      animate: { backgroundPosition: "-5% center" },
+      transition: {
+        repeat: Number.POSITIVE_INFINITY,
+        duration,
+        ease: "linear",
+        delay,
+        repeatDelay
+      },
+      style: {
+        "--spread": `${dynamicSpread}px`,
+        backgroundImage: `var(--bg), linear-gradient(var(--base-color), var(--base-color))`
+      },
+      children
+    }
+  );
+});
+function Collapse({
+  open,
+  children,
+  className
+}) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      "data-state": open ? "open" : "closed",
+      className: cn(
+        "grid transition-[grid-template-rows] duration-200 ease-out motion-reduce:transition-none",
+        open ? "grid-rows-[1fr]" : "grid-rows-[0fr]",
+        className
+      ),
+      children: /* @__PURE__ */ jsx("div", { className: "min-h-0 overflow-hidden", children })
+    }
+  );
+}
+
+// src/vendor/ui/hooks/layout-motion.ts
+var LAYOUT_MOTION_ATTR = "data-layout-motion";
+var LAYOUT_MOTION_END_EVENT = "sebati:layout-motion-end";
+function isLayoutMoving(node) {
+  return !!node?.closest(`[${LAYOUT_MOTION_ATTR}]`);
+}
+function deferDuringLayoutMotion(getNode, measure) {
+  let missed = false;
+  const onEnd = () => {
+    if (!missed) return;
+    missed = false;
+    measure();
+  };
+  window.addEventListener(LAYOUT_MOTION_END_EVENT, onEnd);
+  return {
+    measure: () => {
+      if (isLayoutMoving(getNode())) {
+        missed = true;
+        return;
+      }
+      measure();
+    },
+    dispose: () => window.removeEventListener(LAYOUT_MOTION_END_EVENT, onEnd)
+  };
+}
+function measureScrollFade(el) {
+  const { scrollTop, scrollHeight, clientHeight } = el;
+  const maxScroll = scrollHeight - clientHeight;
+  if (maxScroll <= 1) return { top: false, bottom: false };
+  return {
+    top: scrollTop > 1,
+    bottom: scrollTop < maxScroll - 1
+  };
+}
+function nextFade(prev, el) {
+  const next = measureScrollFade(el);
+  return next.top === prev.top && next.bottom === prev.bottom ? prev : next;
+}
+function ScrollFadeEdges({
+  children,
+  className,
+  fadeFromClassName = "from-surface-raised"
+}) {
+  const observerRef = useRef(null);
+  const gateRef = useRef(null);
+  const [fade, setFade] = useState({
+    top: false,
+    bottom: false
+  });
+  const setViewportRef = useCallback((el) => {
+    observerRef.current?.disconnect();
+    observerRef.current = null;
+    gateRef.current?.dispose();
+    gateRef.current = null;
+    if (!el) return;
+    const measure = () => setFade((prev) => nextFade(prev, el));
+    measure();
+    const gate = deferDuringLayoutMotion(() => el, measure);
+    gateRef.current = gate;
+    const ro = new ResizeObserver(gate.measure);
+    ro.observe(el);
+    for (const child of el.children) {
+      ro.observe(child);
+    }
+    observerRef.current = ro;
+  }, []);
+  useEffect(
+    () => () => {
+      observerRef.current?.disconnect();
+      gateRef.current?.dispose();
+    },
+    []
+  );
+  const onScroll = useCallback((event) => {
+    const el = event.currentTarget;
+    setFade((prev) => nextFade(prev, el));
+  }, []);
+  const fadeBase = cn(
+    "pointer-events-none absolute inset-x-0 z-10 h-10",
+    fadeFromClassName
+  );
+  return /* @__PURE__ */ jsxs("div", { className: "relative", children: [
+    fade.top ? /* @__PURE__ */ jsx(
+      "div",
+      {
+        "aria-hidden": true,
+        className: cn(fadeBase, "top-0 bg-linear-to-b to-transparent")
+      }
+    ) : null,
+    /* @__PURE__ */ jsx(
+      ScrollArea,
+      {
+        className: "w-full",
+        viewportRef: setViewportRef,
+        viewportProps: {
+          onScroll,
+          // Override primitive `size-full` — h-full expands with content and
+          // prevents max-h from creating a scroll region.
+          className: cn("!h-auto w-full", className)
+        },
+        children
+      }
+    ),
+    fade.bottom ? /* @__PURE__ */ jsx(
+      "div",
+      {
+        "aria-hidden": true,
+        className: cn(fadeBase, "bottom-0 bg-linear-to-t to-transparent")
+      }
+    ) : null
+  ] });
+}
+var math = createMathPlugin({ singleDollarTextMath: true });
+var BASE_PLUGINS = { math, cjk };
+var codePluginPromise = null;
+function loadCodePlugin() {
+  codePluginPromise ??= import('@streamdown/code').then((m) => m.code);
+  return codePluginPromise;
+}
+function useStreamdownPlugins() {
+  const [code, setCode] = useState(null);
+  useEffect(() => {
+    void loadCodePlugin().then(setCode);
+  }, []);
+  return useMemo(
+    () => code ? { code, math, cjk } : BASE_PLUGINS,
+    [code]
+  );
+}
+function rehypeUnwrapLiSoloP() {
+  return (tree) => {
+    visit(tree, "element", (li) => {
+      if (li.tagName !== "li") return;
+      let p = null;
+      let pIndex = -1;
+      for (let i = 0; i < li.children.length; i++) {
+        const c = li.children[i];
+        if (!c || c.type !== "element" || c.tagName !== "p") continue;
+        if (p) return;
+        p = c;
+        pIndex = i;
+      }
+      if (!p || pIndex < 0) return;
+      li.children.splice(pIndex, 1, ...p.children);
+    });
+  };
+}
+function rehypeWrapParagraphTextNodes() {
+  return (tree) => {
+    visitParents(tree, "element", (node, ancestors) => {
+      if (node.tagName !== "p") return;
+      const parent = ancestors.at(-1);
+      if (parent?.type === "element" && parent.tagName === "li") return;
+      const wrapped = [];
+      for (const child of node.children) {
+        if (child.type === "text" && child.value.trim().length > 0) {
+          wrapped.push({
+            type: "element",
+            tagName: "span",
+            properties: { dataStreamdown: "text" },
+            children: [{ type: "text", value: child.value }]
+          });
+        } else {
+          wrapped.push(child);
+        }
+      }
+      node.children = wrapped;
+    });
+  };
+}
+
+// src/vendor/ui/ai-elements/normalize-math.ts
+function normalizeMathDelimiters(input) {
+  if (!input.includes("\\[") && !input.includes("\\(")) return input;
+  const segments = input.split(/(```[\s\S]*?```|`[^`\n]*`)/g);
+  return segments.map((seg, i) => {
+    if (i % 2 === 1) return seg;
+    return seg.replace(/\\\[([\s\S]+?)\\\]/g, (_m, body) => `$$${body}$$`).replace(/\\\(([\s\S]+?)\\\)/g, (_m, body) => `$${body}$`);
+  }).join("");
+}
+function escapeCurrencyDollars(input) {
+  if (!input.includes("$")) return input;
+  const segments = input.split(/(```[\s\S]*?```|`[^`\n]*`)/g);
+  return segments.map((seg, i) => {
+    if (i % 2 === 1) return seg;
+    return seg.replace(/(^|[^\\$])\$(?=\d)/g, (_m, before) => `${before}\\$`);
+  }).join("");
+}
+function prepareMarkdown(input) {
+  return escapeCurrencyDollars(normalizeMathDelimiters(input));
+}
+var Message = ({
+  className,
+  from,
+  presentation = "document",
+  ...props
+}) => /* @__PURE__ */ jsx(
+  "div",
+  {
+    className: cn(
+      "group flex w-full max-w-[95%] flex-col gap-2",
+      from === "user" ? "is-user dark ml-auto justify-end" : "is-assistant",
+      // Descendants opt into bubble styling with `group-[.is-bubble]:…`, so
+      // the mode travels down without another prop on every component between
+      // here and the text.
+      presentation === "bubble" && "is-bubble",
+      className
+    ),
+    ...props
+  }
+);
+var MessageContent = ({
+  children,
+  className,
+  ...props
+}) => /* @__PURE__ */ jsx(
+  "div",
+  {
+    className: cn(
+      // `overflow-clip`, not `hidden` — see MarkdownContainer: `hidden` makes
+      // this a scrollport and traps the code block's sticky header here.
+      "is-user:dark flex w-fit min-w-0 max-w-full flex-col gap-2 overflow-clip text-sm",
+      // Softer corner on phones: the prompt is the only bubble on the screen
+      // there, so it reads as a turn rather than as another card.
+      "group-[.is-user]:ml-auto group-[.is-user]:rounded-2xl max-md:group-[.is-user]:rounded-2xl group-[.is-user]:bg-surface-raised-active group-[.is-user]:px-3 group-[.is-user]:py-2 group-[.is-user]:text-foreground",
+      "group-[.is-assistant]:text-foreground",
+      // Bubble mode: both sides get the SAME corner. In document mode the
+      // user's prompt is the only bubble on screen and a tighter radius keeps
+      // it from reading as a card; here it sits opposite the Agent's bubbles
+      // all the way down the thread, and two different radii facing each other
+      // is the thing the eye catches.
+      "group-[.is-user.is-bubble]:rounded-2xl group-[.is-user.is-bubble]:max-w-2xl",
+      className
+    ),
+    ...props,
+    children
+  }
+);
+var STREAMDOWN_CONTROLS = { mermaid: { fullscreen: false } };
+function LinkSafetyModal({ isOpen, onClose, onConfirm, url }) {
+  const [copied, setCopied] = useState(false);
+  return /* @__PURE__ */ jsx(
+    Dialog,
+    {
+      open: isOpen,
+      onOpenChange: (open) => {
+        if (!open) {
+          setCopied(false);
+          onClose();
+        }
+      },
+      children: /* @__PURE__ */ jsxs(DialogContent, { className: "z-[200] max-w-md space-y-4", overlayClassName: "z-[200]", children: [
+        /* @__PURE__ */ jsxs(DialogHeader, { children: [
+          /* @__PURE__ */ jsxs(DialogTitle, { className: "flex items-center gap-2", children: [
+            /* @__PURE__ */ jsx(SquareArrowTopRightIcon, { className: "size-5 text-muted-foreground" }),
+            "Open external link?"
+          ] }),
+          /* @__PURE__ */ jsx(DialogDescription, { children: "You're about to visit an external website." })
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "break-all rounded-md border border-border bg-muted px-3 items-center flex font-mono text-sm text-foreground h-8", children: url }),
+        /* @__PURE__ */ jsxs("div", { className: "flex gap-2", children: [
+          /* @__PURE__ */ jsxs(
+            Button,
+            {
+              variant: "outline",
+              className: "flex-1",
+              onClick: () => {
+                void navigator.clipboard?.writeText(url);
+                setCopied(true);
+              },
+              children: [
+                copied ? /* @__PURE__ */ jsx(Checkmark1Icon, {}) : /* @__PURE__ */ jsx(ClipboardIcon, {}),
+                copied ? "Copied" : "Copy link"
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsxs(Button, { className: "flex-1", onClick: onConfirm, children: [
+            /* @__PURE__ */ jsx(SquareArrowTopRightIcon, {}),
+            "Open link"
+          ] })
+        ] })
+      ] })
+    }
+  );
+}
+var STREAMDOWN_LINK_SAFETY = {
+  enabled: true,
+  renderModal: (props) => /* @__PURE__ */ jsx(LinkSafetyModal, { ...props })
+};
+var STREAMDOWN_REHYPE_PLUGINS = [
+  rehypeUnwrapLiSoloP,
+  rehypeWrapParagraphTextNodes
+];
+var MessageResponse = memo(
+  ({ className, children, ...props }) => {
+    const plugins = useStreamdownPlugins();
+    const content = typeof children === "string" ? prepareMarkdown(children) : children;
+    return /* @__PURE__ */ jsx(
+      Streamdown,
+      {
+        className: cn(
+          "size-full [&>*:first-child]:mt-0 [&>*:last-child]:mb-0 prose-li:my-0 prose-li:py-0",
+          className
+        ),
+        controls: STREAMDOWN_CONTROLS,
+        linkSafety: STREAMDOWN_LINK_SAFETY,
+        plugins,
+        rehypePlugins: STREAMDOWN_REHYPE_PLUGINS,
+        ...props,
+        children: content
+      }
+    );
+  },
+  (prevProps, nextProps) => prevProps.children === nextProps.children && prevProps.components === nextProps.components && // className is chrome, independent of the markdown. Skipping it froze
+  // restyles of an unchanged answer — including assistant bubble corners
+  // when they still lived here, which made every n+1 bubble look last.
+  prevProps.className === nextProps.className
+);
+MessageResponse.displayName = "MessageResponse";
+var MessageToolbar = ({
+  className,
+  children,
+  ...props
+}) => /* @__PURE__ */ jsx(
+  "div",
+  {
+    className: cn(
+      "mt-4 flex w-full items-center justify-between gap-4",
+      className
+    ),
+    ...props,
+    children
+  }
+);
+
+// src/vendor/lib/tool-activity-label.ts
+var MAX_INTENT = 80;
+var MAX_LABEL_JSON_LENGTH = 32e3;
+function truncate(s, max = MAX_INTENT) {
+  if (s.length <= max) return s;
+  const cut = s.slice(0, max - 1);
+  const lastSpace = cut.lastIndexOf(" ");
+  return (lastSpace > 24 ? cut.slice(0, lastSpace) : cut) + "\u2026";
+}
+function titleCaseWords(s) {
+  return s.split(/\s+/).filter(Boolean).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join(" ");
+}
+function capitalizeWord(s) {
+  if (!s) return s;
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function humanizeTokens(tokens) {
+  return tokens.join(" ");
+}
+var APP_SKILL_DISPLAY = {
+  gmail: "Google Gmail",
+  "google-calendar": "Google Calendar",
+  "google-drive": "Google Drive",
+  "google-sheets": "Google Sheets",
+  "google-analytics": "Google Analytics",
+  "google-accounts": "Google Accounts",
+  slack: "Slack",
+  notion: "Notion",
+  linear: "Linear",
+  figma: "Figma",
+  jira: "Jira",
+  salesforce: "Salesforce",
+  hubspot: "HubSpot",
+  discord: "Discord"
+};
+function extractSkillSlug(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const o = input;
+  const v = o.skill_name ?? o.name;
+  return typeof v === "string" && v.trim() ? v.trim() : void 0;
+}
+function unwrapSkillOutput(output) {
+  if (!output || typeof output !== "object") return void 0;
+  let o = output;
+  if ("value" in o && o.value && typeof o.value === "object") {
+    o = o.value;
+  }
+  return o;
+}
+function resolveSkillLabel(input, output) {
+  const out = unwrapSkillOutput(output);
+  const fromOutput = out?.displayName;
+  if (typeof fromOutput === "string" && fromOutput.trim()) {
+    return fromOutput.trim();
+  }
+  const slug = extractSkillSlug(input);
+  return slug ? formatSkillDisplayName(slug) : void 0;
+}
+function formatSkillDisplayName(slug) {
+  const normalized = slug.replace(/_/g, "-").replace(/-guide$/i, "");
+  if (APP_SKILL_DISPLAY[normalized]) return APP_SKILL_DISPLAY[normalized];
+  return titleCaseWords(normalized.replace(/-/g, " "));
+}
+function skillSlugToAppKind(slug) {
+  return slug.replace(/_/g, "-").replace(/-guide$/i, "");
+}
+function tokenizeToolName(name) {
+  const n = name.trim();
+  if (!n) return [];
+  if (n.includes("_")) {
+    return n.split("_").filter(Boolean).map((t) => t.toLowerCase());
+  }
+  return n.replace(/([a-z])([A-Z])/g, "$1 $2").split(/\s+/).filter(Boolean).map((t) => t.toLowerCase());
+}
+var VERB_PAST = {
+  search: "searched",
+  query: "queried",
+  get: "retrieved",
+  fetch: "fetched",
+  list: "listed",
+  find: "found",
+  read: "read",
+  run: "ran",
+  execute: "executed",
+  create: "created",
+  update: "updated",
+  delete: "deleted",
+  send: "sent",
+  submit: "submitted",
+  validate: "validated",
+  check: "checked",
+  discover: "discovered",
+  generate: "generated",
+  forecast: "forecasted",
+  detect: "detected",
+  analyze: "analyzed",
+  contribute: "analyzed"
+};
+function parseLabelJson(text) {
+  if (text.length > MAX_LABEL_JSON_LENGTH) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+function unwrapAiJson(raw) {
+  if (typeof raw === "string") return parseLabelJson(raw);
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+  const r = raw;
+  if (r.type === "json" && "value" in r) return r.value;
+  const content = Array.isArray(r.content) ? r.content : r.type === "content" && Array.isArray(r.value) ? r.value : null;
+  if (content) {
+    const textItem = content.find(
+      (item) => item.type === "text" && typeof item.text === "string"
+    );
+    return textItem ? parseLabelJson(textItem.text) : null;
+  }
+  return raw;
+}
+function inferToolResultCount(raw) {
+  const data = unwrapAiJson(raw);
+  if (data == null) return null;
+  if (Array.isArray(data)) return data.length;
+  if (typeof data !== "object") return null;
+  const o = data;
+  for (const key of [
+    "rows",
+    "data",
+    "results",
+    "items",
+    "records",
+    "citations",
+    "documents",
+    "matches"
+  ]) {
+    const v = o[key];
+    if (Array.isArray(v)) return v.length;
+  }
+  for (const key of ["total", "count", "rowCount", "length"]) {
+    const v = o[key];
+    if (typeof v === "number" && Number.isFinite(v)) return v;
+  }
+  return null;
+}
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function extractIntentSnippet(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const o = input;
+  const preferKeys = [
+    "action",
+    "query",
+    "prompt",
+    "sql",
+    "command",
+    "cmd",
+    "code",
+    "message",
+    "text",
+    "question",
+    "title",
+    "task",
+    "input",
+    "search",
+    "path",
+    "filePath",
+    "file",
+    "url",
+    "name"
+  ];
+  for (const k of preferKeys) {
+    const v = o[k];
+    if (typeof v !== "string") continue;
+    const t = v.trim();
+    if (t && !UUID_RE.test(t)) return truncate(t);
+  }
+  return void 0;
+}
+var TOOL_ROW_CONFIG = {
+  readFile: { done: "Read", running: "Reading", fail: "Read failed", targetKeys: ["path", "filePath", "file"], mono: true },
+  readFileBuffer: { done: "Read", running: "Reading", fail: "Read failed", targetKeys: ["path", "filePath", "file"], mono: true },
+  writeFile: { done: "Wrote", running: "Writing", fail: "Write failed", targetKeys: ["path", "filePath", "file"], mono: true },
+  exists: { done: "Checked", running: "Checking", fail: "Check failed", targetKeys: ["path", "filePath", "file"], mono: true },
+  readdir: { done: "Listed", running: "Listing", fail: "List failed", targetKeys: ["path", "dir", "filePath"], mono: true },
+  resolvePath: { done: "Resolved path", running: "Resolving path", fail: "Path resolve failed", targetKeys: ["path"], mono: true },
+  symlink: { done: "Linked", running: "Linking", fail: "Link failed", targetKeys: ["path", "target", "from"], mono: true },
+  bash: { done: "Ran", running: "Running", fail: "Command failed", targetKeys: ["command", "cmd"], mono: true },
+  run_js: { done: "Ran js", running: "Running js", fail: "JS failed", targetKeys: ["code"], mono: true },
+  run_python: { done: "Ran python", running: "Running python", fail: "Python failed", targetKeys: ["code"], mono: true },
+  read_file: { done: "Read", running: "Reading", fail: "Read failed", targetKeys: ["path", "filePath", "file"], mono: true },
+  write_file: { done: "Wrote", running: "Writing", fail: "Write failed", targetKeys: ["path", "filePath", "file"], mono: true },
+  edit_file: { done: "Edited", running: "Editing", fail: "Edit failed", targetKeys: ["path", "filePath", "file"], mono: true },
+  view_image: { done: "Viewed image", running: "Viewing image", fail: "View failed", targetKeys: ["path"], mono: true },
+  web_search: { done: "Searched the web", running: "Searching the web", fail: "Web search failed", targetKeys: ["query", "search"], quote: true },
+  searchKnowledge: { done: "Searched knowledge", running: "Searching knowledge", fail: "Knowledge search failed", targetKeys: ["query"], quote: true },
+  search_memory: { done: "Searched memory", running: "Searching memory", fail: "Memory search failed", targetKeys: ["queries"], quote: true },
+  createDocument: { done: "Created document", running: "Writing document", fail: "Document failed", targetKeys: ["title"] },
+  updateDocument: { done: "Updated document", running: "Updating document", fail: "Update failed", targetKeys: ["title"] },
+  skill: {
+    done: "Used",
+    running: "Loading",
+    fail: "Skill failed",
+    targetKeys: ["skill_name", "name"]
+  },
+  createImage: { done: "Created image", running: "Generating image", fail: "Image failed", targetKeys: ["prompt"], quote: true },
+  // Artifact tools take an artifactId (a uuid — meaningless in the transcript,
+  // and filtered by pickTarget/extractIntentSnippet); the human title resolves
+  // from the tool OUTPUT via the generic `title` fallback in describeToolRow.
+  createSlides: { done: "Created slides", running: "Creating slides", fail: "Slides failed", targetKeys: ["title"], quote: true },
+  readSlides: { done: "Read slides", running: "Reading slides", fail: "Read failed", quote: true },
+  updateSlides: { done: "Updated slides", running: "Updating slides", fail: "Update failed", quote: true },
+  createSpreadsheet: { done: "Created spreadsheet", running: "Creating spreadsheet", fail: "Spreadsheet failed", targetKeys: ["title"], quote: true },
+  readSpreadsheet: { done: "Read spreadsheet", running: "Reading spreadsheet", fail: "Read failed", targetKeys: ["url"], quote: true },
+  updateSpreadsheet: { done: "Updated spreadsheet", running: "Updating spreadsheet", fail: "Update failed", targetKeys: ["title"], quote: true },
+  createPdf: { done: "Created PDF", running: "Creating PDF", fail: "PDF failed", targetKeys: ["title"], quote: true },
+  readPdf: { done: "Read PDF", running: "Reading PDF", fail: "Read failed", targetKeys: ["url"], quote: true }
+};
+var GERUND = {
+  search: "Searching",
+  query: "Querying",
+  get: "Fetching",
+  fetch: "Fetching",
+  list: "Listing",
+  read: "Reading",
+  run: "Running",
+  execute: "Running",
+  create: "Creating",
+  update: "Updating",
+  delete: "Deleting",
+  send: "Sending",
+  submit: "Submitting",
+  validate: "Validating",
+  check: "Checking",
+  find: "Finding",
+  generate: "Generating",
+  analyze: "Analyzing",
+  detect: "Detecting"
+};
+function truncateTail(s, max) {
+  if (s.length <= max) return s;
+  return "\u2026" + s.slice(s.length - (max - 1));
+}
+function pickTarget(input, keys) {
+  if (!input || typeof input !== "object" || !keys) return void 0;
+  const o = input;
+  for (const k of keys) {
+    const v = o[k];
+    if (typeof v !== "string") continue;
+    const t = v.trim();
+    if (t && !UUID_RE.test(t)) return t;
+  }
+  return void 0;
+}
+function describeToolRow(toolName, state, input, output, errorText) {
+  const authored = pickTarget(input, ["action"]);
+  if (authored) {
+    return {
+      verb: truncate(authored, 80),
+      target: void 0,
+      targetMono: false
+    };
+  }
+  const displayName = toolName.includes("__") ? toolName.split("__").pop() ?? toolName : toolName;
+  const cfg = TOOL_ROW_CONFIG[toolName] ?? TOOL_ROW_CONFIG[displayName];
+  const isError = state === "output-error" || state === "error";
+  const isDenied = state === "output-denied";
+  const isRunning = ["input-streaming", "partial-call", "input-available", "call"].includes(state);
+  let target;
+  if (toolName === "skill" || displayName === "skill") {
+    target = resolveSkillLabel(input, output);
+  } else {
+    target = cfg ? pickTarget(input, cfg.targetKeys) : extractIntentSnippet(input);
+    if (!target) {
+      target = pickTarget(unwrapAiJson(output), ["title"]);
+    }
+  }
+  const targetMono = cfg?.mono ?? false;
+  if (target) {
+    if (toolName === "skill" || displayName === "skill") ; else if (cfg?.quote) {
+      target = `"${truncate(target, 70)}"`;
+    } else if (targetMono) {
+      target = truncateTail(target, 64);
+    } else {
+      target = truncate(target, 72);
+    }
+  }
+  const tokens = tokenizeToolName(displayName);
+  const head = tokens[0] ?? "";
+  const rest = tokens.slice(1);
+  const objectPhrase = rest.length ? humanizeTokens(rest) : displayName.replace(/_/g, " ").toLowerCase();
+  let verb;
+  if (isError) {
+    verb = cfg?.done ?? capitalizeWord(objectPhrase);
+  } else if (isDenied) {
+    verb = `${objectPhrase} denied`;
+  } else if (cfg) {
+    verb = isRunning ? cfg.running : cfg.done;
+  } else if (isRunning) {
+    const gerund = GERUND[head] ?? "Running";
+    verb = rest.length ? `${gerund} ${objectPhrase}` : gerund;
+  } else {
+    const past = VERB_PAST[head];
+    verb = past ? rest.length ? `${capitalizeWord(past)} ${objectPhrase}` : capitalizeWord(past) : capitalizeWord(objectPhrase);
+  }
+  let hint;
+  let hintTone;
+  if (isError) {
+    hint = void 0;
+    hintTone = "muted";
+  } else if (isDenied) {
+    hint = "denied";
+    hintTone = "danger";
+  } else if (!isRunning) {
+    const count = inferToolResultCount(output);
+    if (count !== null) {
+      hint = `${count} ${count === 1 ? "result" : "results"}`;
+      hintTone = "muted";
+    }
+  }
+  return { verb, target, targetMono, hint, hintTone };
+}
+function getIconsTree(data, names) {
+  const icons = data.icons;
+  const aliases = data.aliases || /* @__PURE__ */ Object.create(null);
+  const resolved = /* @__PURE__ */ Object.create(null);
+  function resolve(name) {
+    if (icons[name]) return resolved[name] = [];
+    if (!(name in resolved)) {
+      resolved[name] = null;
+      const parent = aliases[name] && aliases[name].parent;
+      const value = parent && resolve(parent);
+      if (value) resolved[name] = [parent].concat(value);
+    }
+    return resolved[name];
+  }
+  Object.keys(icons).concat(Object.keys(aliases)).forEach(resolve);
+  return resolved;
+}
+var defaultIconDimensions = Object.freeze({
+  left: 0,
+  top: 0,
+  width: 16,
+  height: 16
+});
+var defaultIconTransformations = Object.freeze({
+  rotate: 0,
+  vFlip: false,
+  hFlip: false
+});
+var defaultIconProps = Object.freeze({
+  ...defaultIconDimensions,
+  ...defaultIconTransformations
+});
+var defaultExtendedIconProps = Object.freeze({
+  ...defaultIconProps,
+  body: "",
+  hidden: false
+});
+function mergeIconTransformations(obj1, obj2) {
+  const result = {};
+  if (!obj1.hFlip !== !obj2.hFlip) result.hFlip = true;
+  if (!obj1.vFlip !== !obj2.vFlip) result.vFlip = true;
+  const rotate = ((obj1.rotate || 0) + (obj2.rotate || 0)) % 4;
+  if (rotate) result.rotate = rotate;
+  return result;
+}
+function mergeIconData(parent, child) {
+  const result = mergeIconTransformations(parent, child);
+  for (const key in defaultExtendedIconProps) if (key in defaultIconTransformations) {
+    if (key in parent && !(key in result)) result[key] = defaultIconTransformations[key];
+  } else if (key in child) result[key] = child[key];
+  else if (key in parent) result[key] = parent[key];
+  return result;
+}
+function internalGetIconData(data, name, tree) {
+  const icons = data.icons;
+  const aliases = data.aliases || /* @__PURE__ */ Object.create(null);
+  let currentProps = {};
+  function parse(name$1) {
+    currentProps = mergeIconData(icons[name$1] || aliases[name$1], currentProps);
+  }
+  parse(name);
+  tree.forEach(parse);
+  return mergeIconData(data, currentProps);
+}
+function parseIconSet(data, callback) {
+  const names = [];
+  if (typeof data !== "object" || typeof data.icons !== "object") return names;
+  if (data.not_found instanceof Array) data.not_found.forEach((name) => {
+    callback(name, null);
+    names.push(name);
+  });
+  const tree = getIconsTree(data);
+  for (const name in tree) {
+    const item = tree[name];
+    if (item) {
+      callback(name, internalGetIconData(data, name, item));
+      names.push(name);
+    }
+  }
+  return names;
+}
+var optionalPropertyDefaults = {
+  provider: "",
+  aliases: {},
+  not_found: {},
+  ...defaultIconDimensions
+};
+function checkOptionalProps(item, defaults) {
+  for (const prop in defaults) if (prop in item && typeof item[prop] !== typeof defaults[prop]) return false;
+  return true;
+}
+function quicklyValidateIconSet(obj) {
+  if (typeof obj !== "object" || obj === null) return null;
+  const data = obj;
+  if (typeof data.prefix !== "string" || !obj.icons || typeof obj.icons !== "object") return null;
+  if (!checkOptionalProps(obj, optionalPropertyDefaults)) return null;
+  const icons = data.icons;
+  for (const name in icons) {
+    const icon = icons[name];
+    if (!name || typeof icon.body !== "string" || !checkOptionalProps(icon, defaultExtendedIconProps)) return null;
+  }
+  const aliases = data.aliases || /* @__PURE__ */ Object.create(null);
+  for (const name in aliases) {
+    const icon = aliases[name];
+    const parent = icon.parent;
+    if (!name || typeof parent !== "string" || !icons[parent] && !aliases[parent] || !checkOptionalProps(icon, defaultExtendedIconProps)) return null;
+  }
+  return data;
+}
+var dataStorage = /* @__PURE__ */ Object.create(null);
+function newStorage(provider, prefix) {
+  return {
+    provider,
+    prefix,
+    icons: /* @__PURE__ */ Object.create(null),
+    missing: /* @__PURE__ */ new Set()
+  };
+}
+function getStorage(provider, prefix) {
+  const providerStorage = dataStorage[provider] || (dataStorage[provider] = /* @__PURE__ */ Object.create(null));
+  return providerStorage[prefix] || (providerStorage[prefix] = newStorage(provider, prefix));
+}
+function addIconSet(storage2, data) {
+  if (!quicklyValidateIconSet(data)) return [];
+  return parseIconSet(data, (name, icon) => {
+    if (icon) storage2.icons[name] = icon;
+    else storage2.missing.add(name);
+  });
+}
+function addIconToStorage(storage2, name, icon) {
+  try {
+    if (typeof icon.body === "string") {
+      storage2.icons[name] = { ...icon };
+      return true;
+    }
+  } catch (err) {
+  }
+  return false;
+}
+var matchIconName = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+var stringToIcon = (value, validate, allowSimpleName, provider = "") => {
+  const colonSeparated = value.split(":");
+  if (value.slice(0, 1) === "@") {
+    if (colonSeparated.length < 2 || colonSeparated.length > 3) return null;
+    provider = colonSeparated.shift().slice(1);
+  }
+  if (colonSeparated.length > 3 || !colonSeparated.length) return null;
+  if (colonSeparated.length > 1) {
+    const name$1 = colonSeparated.pop();
+    const prefix = colonSeparated.pop();
+    const result = {
+      provider: colonSeparated.length > 0 ? colonSeparated[0] : provider,
+      prefix,
+      name: name$1
+    };
+    return validate && !validateIconName(result) ? null : result;
+  }
+  const name = colonSeparated[0];
+  const dashSeparated = name.split("-");
+  if (dashSeparated.length > 1) {
+    const result = {
+      provider,
+      prefix: dashSeparated.shift(),
+      name: dashSeparated.join("-")
+    };
+    return validate && !validateIconName(result) ? null : result;
+  }
+  if (allowSimpleName && provider === "") {
+    const result = {
+      provider,
+      prefix: "",
+      name
+    };
+    return validate && !validateIconName(result, allowSimpleName) ? null : result;
+  }
+  return null;
+};
+var validateIconName = (icon, allowSimpleName) => {
+  if (!icon) return false;
+  return !!((allowSimpleName && icon.prefix === "" || !!icon.prefix) && !!icon.name);
+};
+var simpleNames = false;
+function allowSimpleNames(allow) {
+  if (typeof allow === "boolean") simpleNames = allow;
+  return simpleNames;
+}
+function getIconData(name) {
+  const icon = typeof name === "string" ? stringToIcon(name, true, simpleNames) : name;
+  if (icon) {
+    const storage2 = getStorage(icon.provider, icon.prefix);
+    const iconName = icon.name;
+    return storage2.icons[iconName] || (storage2.missing.has(iconName) ? null : void 0);
+  }
+}
+function addIcon(name, data) {
+  const icon = stringToIcon(name, true, simpleNames);
+  if (!icon) return false;
+  const storage2 = getStorage(icon.provider, icon.prefix);
+  if (data) return addIconToStorage(storage2, icon.name, data);
+  else {
+    storage2.missing.add(icon.name);
+    return true;
+  }
+}
+function addCollection(data, provider) {
+  if (typeof data !== "object") return false;
+  if (typeof provider !== "string") provider = data.provider || "";
+  if (simpleNames && !provider && !data.prefix) {
+    let added = false;
+    if (quicklyValidateIconSet(data)) {
+      data.prefix = "";
+      parseIconSet(data, (name, icon) => {
+        if (addIcon(name, icon)) added = true;
+      });
+    }
+    return added;
+  }
+  const prefix = data.prefix;
+  if (!validateIconName({
+    prefix,
+    name: "a"
+  })) return false;
+  const storage2 = getStorage(provider, prefix);
+  return !!addIconSet(storage2, data);
+}
+var defaultIconSizeCustomisations = Object.freeze({
+  width: null,
+  height: null
+});
+var defaultIconCustomisations = Object.freeze({
+  ...defaultIconSizeCustomisations,
+  ...defaultIconTransformations
+});
+var unitsSplit = /(-?[0-9.]*[0-9]+[0-9.]*)/g;
+var unitsTest = /^-?[0-9.]*[0-9]+[0-9.]*$/g;
+function calculateSize(size, ratio, precision) {
+  if (ratio === 1) return size;
+  precision = precision || 100;
+  if (typeof size === "number") return Math.ceil(size * ratio * precision) / precision;
+  if (typeof size !== "string") return size;
+  const oldParts = size.split(unitsSplit);
+  if (oldParts === null || !oldParts.length) return size;
+  const newParts = [];
+  let code = oldParts.shift();
+  let isNumber = unitsTest.test(code);
+  while (true) {
+    if (isNumber) {
+      const num = parseFloat(code);
+      if (isNaN(num)) newParts.push(code);
+      else newParts.push(Math.ceil(num * ratio * precision) / precision);
+    } else newParts.push(code);
+    code = oldParts.shift();
+    if (code === void 0) return newParts.join("");
+    isNumber = !isNumber;
+  }
+}
+function splitSVGDefs(content, tag = "defs") {
+  let defs = "";
+  const index = content.indexOf("<" + tag);
+  while (index >= 0) {
+    const start = content.indexOf(">", index);
+    const end = content.indexOf("</" + tag);
+    if (start === -1 || end === -1) break;
+    const endEnd = content.indexOf(">", end);
+    if (endEnd === -1) break;
+    defs += content.slice(start + 1, end).trim();
+    content = content.slice(0, index).trim() + content.slice(endEnd + 1);
+  }
+  return {
+    defs,
+    content
+  };
+}
+function mergeDefsAndContent(defs, content) {
+  return defs ? "<defs>" + defs + "</defs>" + content : content;
+}
+function wrapSVGContent(body, start, end) {
+  const split = splitSVGDefs(body);
+  return mergeDefsAndContent(split.defs, start + split.content + end);
+}
+var isUnsetKeyword = (value) => value === "unset" || value === "undefined" || value === "none";
+function iconToSVG(icon, customisations) {
+  const fullIcon = {
+    ...defaultIconProps,
+    ...icon
+  };
+  const fullCustomisations = {
+    ...defaultIconCustomisations,
+    ...customisations
+  };
+  const box = {
+    left: fullIcon.left,
+    top: fullIcon.top,
+    width: fullIcon.width,
+    height: fullIcon.height
+  };
+  let body = fullIcon.body;
+  [fullIcon, fullCustomisations].forEach((props) => {
+    const transformations = [];
+    const hFlip = props.hFlip;
+    const vFlip = props.vFlip;
+    let rotation = props.rotate;
+    if (hFlip) if (vFlip) rotation += 2;
+    else {
+      transformations.push("translate(" + (box.width + box.left).toString() + " " + (0 - box.top).toString() + ")");
+      transformations.push("scale(-1 1)");
+      box.top = box.left = 0;
+    }
+    else if (vFlip) {
+      transformations.push("translate(" + (0 - box.left).toString() + " " + (box.height + box.top).toString() + ")");
+      transformations.push("scale(1 -1)");
+      box.top = box.left = 0;
+    }
+    let tempValue;
+    if (rotation < 0) rotation -= Math.floor(rotation / 4) * 4;
+    rotation = rotation % 4;
+    switch (rotation) {
+      case 1:
+        tempValue = box.height / 2 + box.top;
+        transformations.unshift("rotate(90 " + tempValue.toString() + " " + tempValue.toString() + ")");
+        break;
+      case 2:
+        transformations.unshift("rotate(180 " + (box.width / 2 + box.left).toString() + " " + (box.height / 2 + box.top).toString() + ")");
+        break;
+      case 3:
+        tempValue = box.width / 2 + box.left;
+        transformations.unshift("rotate(-90 " + tempValue.toString() + " " + tempValue.toString() + ")");
+        break;
+    }
+    if (rotation % 2 === 1) {
+      if (box.left !== box.top) {
+        tempValue = box.left;
+        box.left = box.top;
+        box.top = tempValue;
+      }
+      if (box.width !== box.height) {
+        tempValue = box.width;
+        box.width = box.height;
+        box.height = tempValue;
+      }
+    }
+    if (transformations.length) body = wrapSVGContent(body, '<g transform="' + transformations.join(" ") + '">', "</g>");
+  });
+  const customisationsWidth = fullCustomisations.width;
+  const customisationsHeight = fullCustomisations.height;
+  const boxWidth = box.width;
+  const boxHeight = box.height;
+  let width;
+  let height;
+  if (customisationsWidth === null) {
+    height = customisationsHeight === null ? "1em" : customisationsHeight === "auto" ? boxHeight : customisationsHeight;
+    width = calculateSize(height, boxWidth / boxHeight);
+  } else {
+    width = customisationsWidth === "auto" ? boxWidth : customisationsWidth;
+    height = customisationsHeight === null ? calculateSize(width, boxHeight / boxWidth) : customisationsHeight === "auto" ? boxHeight : customisationsHeight;
+  }
+  const attributes = {};
+  const setAttr = (prop, value) => {
+    if (!isUnsetKeyword(value)) attributes[prop] = value.toString();
+  };
+  setAttr("width", width);
+  setAttr("height", height);
+  const viewBox = [
+    box.left,
+    box.top,
+    boxWidth,
+    boxHeight
+  ];
+  attributes.viewBox = viewBox.join(" ");
+  return {
+    attributes,
+    viewBox,
+    body
+  };
+}
+var regex = /\sid="(\S+)"/g;
+var randomPrefix = "IconifyId" + Date.now().toString(16) + (Math.random() * 16777216 | 0).toString(16);
+var counter = 0;
+function replaceIDs(body, prefix = randomPrefix) {
+  const ids = [];
+  let match;
+  while (match = regex.exec(body)) ids.push(match[1]);
+  if (!ids.length) return body;
+  const suffix = "suffix" + (Math.random() * 16777216 | Date.now()).toString(16);
+  ids.forEach((id) => {
+    const newID = typeof prefix === "function" ? prefix(id) : prefix + (counter++).toString();
+    const escapedID = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    body = body.replace(new RegExp('([#;"])(' + escapedID + ')([")]|\\.[a-z])', "g"), "$1" + newID + suffix + "$3");
+  });
+  body = body.replace(new RegExp(suffix, "g"), "");
+  return body;
+}
+var storage = /* @__PURE__ */ Object.create(null);
+function setAPIModule(provider, item) {
+  storage[provider] = item;
+}
+function getAPIModule(provider) {
+  return storage[provider] || storage[""];
+}
+function createAPIConfig(source) {
+  let resources;
+  if (typeof source.resources === "string") resources = [source.resources];
+  else {
+    resources = source.resources;
+    if (!(resources instanceof Array) || !resources.length) return null;
+  }
+  const result = {
+    resources,
+    path: source.path || "/",
+    maxURL: source.maxURL || 500,
+    rotate: source.rotate || 750,
+    timeout: source.timeout || 5e3,
+    random: source.random === true,
+    index: source.index || 0,
+    dataAfterTimeout: source.dataAfterTimeout !== false
+  };
+  return result;
+}
+var configStorage = /* @__PURE__ */ Object.create(null);
+var fallBackAPISources = ["https://api.simplesvg.com", "https://api.unisvg.com"];
+var fallBackAPI = [];
+while (fallBackAPISources.length > 0) if (fallBackAPISources.length === 1) fallBackAPI.push(fallBackAPISources.shift());
+else if (Math.random() > 0.5) fallBackAPI.push(fallBackAPISources.shift());
+else fallBackAPI.push(fallBackAPISources.pop());
+configStorage[""] = createAPIConfig({ resources: ["https://api.iconify.design"].concat(fallBackAPI) });
+function addAPIProvider(provider, customConfig) {
+  const config = createAPIConfig(customConfig);
+  if (config === null) return false;
+  configStorage[provider] = config;
+  return true;
+}
+function getAPIConfig(provider) {
+  return configStorage[provider];
+}
+var detectFetch = () => {
+  let callback;
+  try {
+    callback = fetch;
+    if (typeof callback === "function") return callback;
+  } catch (err) {
+  }
+};
+var fetchModule = detectFetch();
+function calculateMaxLength(provider, prefix) {
+  const config = getAPIConfig(provider);
+  if (!config) return 0;
+  let result;
+  if (!config.maxURL) result = 0;
+  else {
+    let maxHostLength = 0;
+    config.resources.forEach((item) => {
+      const host = item;
+      maxHostLength = Math.max(maxHostLength, host.length);
+    });
+    const url = prefix + ".json?icons=";
+    result = config.maxURL - maxHostLength - config.path.length - url.length;
+  }
+  return result;
+}
+function shouldAbort(status) {
+  return status === 404;
+}
+var prepare = (provider, prefix, icons) => {
+  const results = [];
+  const maxLength = calculateMaxLength(provider, prefix);
+  const type = "icons";
+  let item = {
+    type,
+    provider,
+    prefix,
+    icons: []
+  };
+  let length = 0;
+  icons.forEach((name, index) => {
+    length += name.length + 1;
+    if (length >= maxLength && index > 0) {
+      results.push(item);
+      item = {
+        type,
+        provider,
+        prefix,
+        icons: []
+      };
+      length = name.length;
+    }
+    item.icons.push(name);
+  });
+  results.push(item);
+  return results;
+};
+function getPath(provider) {
+  if (typeof provider === "string") {
+    const config = getAPIConfig(provider);
+    if (config) return config.path;
+  }
+  return "/";
+}
+var send = (host, params, callback) => {
+  if (!fetchModule) {
+    callback("abort", 424);
+    return;
+  }
+  let path = getPath(params.provider);
+  switch (params.type) {
+    case "icons": {
+      const prefix = params.prefix;
+      const icons = params.icons;
+      const iconsList = icons.join(",");
+      const urlParams = new URLSearchParams({ icons: iconsList });
+      path += prefix + ".json?" + urlParams.toString();
+      break;
+    }
+    case "custom": {
+      const uri = params.uri;
+      path += uri.slice(0, 1) === "/" ? uri.slice(1) : uri;
+      break;
+    }
+    default:
+      callback("abort", 400);
+      return;
+  }
+  let defaultError = 503;
+  fetchModule(host + path).then((response) => {
+    const status = response.status;
+    if (status !== 200) {
+      setTimeout(() => {
+        callback(shouldAbort(status) ? "abort" : "next", status);
+      });
+      return;
+    }
+    defaultError = 501;
+    return response.json();
+  }).then((data) => {
+    if (typeof data !== "object" || data === null) {
+      setTimeout(() => {
+        if (data === 404) callback("abort", data);
+        else callback("next", defaultError);
+      });
+      return;
+    }
+    setTimeout(() => {
+      callback("success", data);
+    });
+  }).catch(() => {
+    callback("next", defaultError);
+  });
+};
+var fetchAPIModule = {
+  prepare,
+  send
+};
+function removeCallback(storages, id) {
+  storages.forEach((storage2) => {
+    const items = storage2.loaderCallbacks;
+    if (items) storage2.loaderCallbacks = items.filter((row) => row.id !== id);
+  });
+}
+function updateCallbacks(storage2) {
+  if (!storage2.pendingCallbacksFlag) {
+    storage2.pendingCallbacksFlag = true;
+    setTimeout(() => {
+      storage2.pendingCallbacksFlag = false;
+      const items = storage2.loaderCallbacks ? storage2.loaderCallbacks.slice(0) : [];
+      if (!items.length) return;
+      let hasPending = false;
+      const provider = storage2.provider;
+      const prefix = storage2.prefix;
+      items.forEach((item) => {
+        const icons = item.icons;
+        const oldLength = icons.pending.length;
+        icons.pending = icons.pending.filter((icon) => {
+          if (icon.prefix !== prefix) return true;
+          const name = icon.name;
+          if (storage2.icons[name]) icons.loaded.push({
+            provider,
+            prefix,
+            name
+          });
+          else if (storage2.missing.has(name)) icons.missing.push({
+            provider,
+            prefix,
+            name
+          });
+          else {
+            hasPending = true;
+            return true;
+          }
+          return false;
+        });
+        if (icons.pending.length !== oldLength) {
+          if (!hasPending) removeCallback([storage2], item.id);
+          item.callback(icons.loaded.slice(0), icons.missing.slice(0), icons.pending.slice(0), item.abort);
+        }
+      });
+    });
+  }
+}
+var idCounter = 0;
+function storeCallback(callback, icons, pendingSources) {
+  const id = idCounter++;
+  const abort = removeCallback.bind(null, pendingSources, id);
+  if (!icons.pending.length) return abort;
+  const item = {
+    id,
+    icons,
+    callback,
+    abort
+  };
+  pendingSources.forEach((storage2) => {
+    (storage2.loaderCallbacks || (storage2.loaderCallbacks = [])).push(item);
+  });
+  return abort;
+}
+function sortIcons(icons) {
+  const result = {
+    loaded: [],
+    missing: [],
+    pending: []
+  };
+  const storage2 = /* @__PURE__ */ Object.create(null);
+  icons.sort((a, b) => {
+    if (a.provider !== b.provider) return a.provider.localeCompare(b.provider);
+    if (a.prefix !== b.prefix) return a.prefix.localeCompare(b.prefix);
+    return a.name.localeCompare(b.name);
+  });
+  let lastIcon = {
+    provider: "",
+    prefix: "",
+    name: ""
+  };
+  icons.forEach((icon) => {
+    if (lastIcon.name === icon.name && lastIcon.prefix === icon.prefix && lastIcon.provider === icon.provider) return;
+    lastIcon = icon;
+    const provider = icon.provider;
+    const prefix = icon.prefix;
+    const name = icon.name;
+    const providerStorage = storage2[provider] || (storage2[provider] = /* @__PURE__ */ Object.create(null));
+    const localStorage = providerStorage[prefix] || (providerStorage[prefix] = getStorage(provider, prefix));
+    let list;
+    if (name in localStorage.icons) list = result.loaded;
+    else if (prefix === "" || localStorage.missing.has(name)) list = result.missing;
+    else list = result.pending;
+    const item = {
+      provider,
+      prefix,
+      name
+    };
+    list.push(item);
+  });
+  return result;
+}
+function listToIcons(list, validate = true, simpleNames2 = false) {
+  const result = [];
+  list.forEach((item) => {
+    const icon = typeof item === "string" ? stringToIcon(item, validate, simpleNames2) : item;
+    if (icon) result.push(icon);
+  });
+  return result;
+}
+var defaultConfig = {
+  resources: [],
+  index: 0,
+  timeout: 2e3,
+  rotate: 750,
+  random: false,
+  dataAfterTimeout: false
+};
+function sendQuery(config, payload, query, done) {
+  const resourcesCount = config.resources.length;
+  const startIndex = config.random ? Math.floor(Math.random() * resourcesCount) : config.index;
+  let resources;
+  if (config.random) {
+    let list = config.resources.slice(0);
+    resources = [];
+    while (list.length > 1) {
+      const nextIndex = Math.floor(Math.random() * list.length);
+      resources.push(list[nextIndex]);
+      list = list.slice(0, nextIndex).concat(list.slice(nextIndex + 1));
+    }
+    resources = resources.concat(list);
+  } else resources = config.resources.slice(startIndex).concat(config.resources.slice(0, startIndex));
+  const startTime = Date.now();
+  let status = "pending";
+  let queriesSent = 0;
+  let lastError;
+  let timer = null;
+  let queue = [];
+  let doneCallbacks = [];
+  if (typeof done === "function") doneCallbacks.push(done);
+  function resetTimer() {
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  }
+  function abort() {
+    if (status === "pending") status = "aborted";
+    resetTimer();
+    queue.forEach((item) => {
+      if (item.status === "pending") item.status = "aborted";
+    });
+    queue = [];
+  }
+  function subscribe(callback, overwrite) {
+    if (overwrite) doneCallbacks = [];
+    if (typeof callback === "function") doneCallbacks.push(callback);
+  }
+  function getQueryStatus() {
+    return {
+      startTime,
+      payload,
+      status,
+      queriesSent,
+      queriesPending: queue.length,
+      subscribe,
+      abort
+    };
+  }
+  function failQuery() {
+    status = "failed";
+    doneCallbacks.forEach((callback) => {
+      callback(void 0, lastError);
+    });
+  }
+  function clearQueue() {
+    queue.forEach((item) => {
+      if (item.status === "pending") item.status = "aborted";
+    });
+    queue = [];
+  }
+  function moduleResponse(item, response, data) {
+    const isError = response !== "success";
+    queue = queue.filter((queued) => queued !== item);
+    switch (status) {
+      case "pending":
+        break;
+      case "failed":
+        if (isError || !config.dataAfterTimeout) return;
+        break;
+      default:
+        return;
+    }
+    if (response === "abort") {
+      lastError = data;
+      failQuery();
+      return;
+    }
+    if (isError) {
+      lastError = data;
+      if (!queue.length) if (!resources.length) failQuery();
+      else execNext();
+      return;
+    }
+    resetTimer();
+    clearQueue();
+    if (!config.random) {
+      const index = config.resources.indexOf(item.resource);
+      if (index !== -1 && index !== config.index) config.index = index;
+    }
+    status = "completed";
+    doneCallbacks.forEach((callback) => {
+      callback(data);
+    });
+  }
+  function execNext() {
+    if (status !== "pending") return;
+    resetTimer();
+    const resource = resources.shift();
+    if (resource === void 0) {
+      if (queue.length) {
+        timer = setTimeout(() => {
+          resetTimer();
+          if (status === "pending") {
+            clearQueue();
+            failQuery();
+          }
+        }, config.timeout);
+        return;
+      }
+      failQuery();
+      return;
+    }
+    const item = {
+      status: "pending",
+      resource,
+      callback: (status$1, data) => {
+        moduleResponse(item, status$1, data);
+      }
+    };
+    queue.push(item);
+    queriesSent++;
+    timer = setTimeout(execNext, config.rotate);
+    query(resource, payload, item.callback);
+  }
+  setTimeout(execNext);
+  return getQueryStatus;
+}
+function initRedundancy(cfg) {
+  const config = {
+    ...defaultConfig,
+    ...cfg
+  };
+  let queries = [];
+  function cleanup() {
+    queries = queries.filter((item) => item().status === "pending");
+  }
+  function query(payload, queryCallback, doneCallback) {
+    const query$1 = sendQuery(config, payload, queryCallback, (data, error) => {
+      cleanup();
+      if (doneCallback) doneCallback(data, error);
+    });
+    queries.push(query$1);
+    return query$1;
+  }
+  function find(callback) {
+    return queries.find((value) => {
+      return callback(value);
+    }) || null;
+  }
+  const instance = {
+    query,
+    find,
+    setIndex: (index) => {
+      config.index = index;
+    },
+    getIndex: () => config.index,
+    cleanup
+  };
+  return instance;
+}
+function emptyCallback$1() {
+}
+var redundancyCache = /* @__PURE__ */ Object.create(null);
+function getRedundancyCache(provider) {
+  if (!redundancyCache[provider]) {
+    const config = getAPIConfig(provider);
+    if (!config) return;
+    const redundancy = initRedundancy(config);
+    const cachedReundancy = {
+      config,
+      redundancy
+    };
+    redundancyCache[provider] = cachedReundancy;
+  }
+  return redundancyCache[provider];
+}
+function sendAPIQuery(target, query, callback) {
+  let redundancy;
+  let send2;
+  if (typeof target === "string") {
+    const api = getAPIModule(target);
+    if (!api) {
+      callback(void 0, 424);
+      return emptyCallback$1;
+    }
+    send2 = api.send;
+    const cached = getRedundancyCache(target);
+    if (cached) redundancy = cached.redundancy;
+  } else {
+    const config = createAPIConfig(target);
+    if (config) {
+      redundancy = initRedundancy(config);
+      const moduleKey = target.resources ? target.resources[0] : "";
+      const api = getAPIModule(moduleKey);
+      if (api) send2 = api.send;
+    }
+  }
+  if (!redundancy || !send2) {
+    callback(void 0, 424);
+    return emptyCallback$1;
+  }
+  return redundancy.query(query, send2, callback)().abort;
+}
+function emptyCallback() {
+}
+function loadedNewIcons(storage2) {
+  if (!storage2.iconsLoaderFlag) {
+    storage2.iconsLoaderFlag = true;
+    setTimeout(() => {
+      storage2.iconsLoaderFlag = false;
+      updateCallbacks(storage2);
+    });
+  }
+}
+function checkIconNamesForAPI(icons) {
+  const valid = [];
+  const invalid = [];
+  icons.forEach((name) => {
+    (name.match(matchIconName) ? valid : invalid).push(name);
+  });
+  return {
+    valid,
+    invalid
+  };
+}
+function parseLoaderResponse(storage2, icons, data) {
+  function checkMissing() {
+    const pending = storage2.pendingIcons;
+    icons.forEach((name) => {
+      if (pending) pending.delete(name);
+      if (!storage2.icons[name]) storage2.missing.add(name);
+    });
+  }
+  if (data && typeof data === "object") try {
+    const parsed = addIconSet(storage2, data);
+    if (!parsed.length) {
+      checkMissing();
+      return;
+    }
+  } catch (err) {
+    console.error(err);
+  }
+  checkMissing();
+  loadedNewIcons(storage2);
+}
+function parsePossiblyAsyncResponse(response, callback) {
+  if (response instanceof Promise) response.then((data) => {
+    callback(data);
+  }).catch(() => {
+    callback(null);
+  });
+  else callback(response);
+}
+function loadNewIcons(storage2, icons) {
+  if (!storage2.iconsToLoad) storage2.iconsToLoad = icons;
+  else storage2.iconsToLoad = storage2.iconsToLoad.concat(icons).sort();
+  if (!storage2.iconsQueueFlag) {
+    storage2.iconsQueueFlag = true;
+    setTimeout(() => {
+      storage2.iconsQueueFlag = false;
+      const { provider, prefix } = storage2;
+      const icons$1 = storage2.iconsToLoad;
+      delete storage2.iconsToLoad;
+      if (!icons$1 || !icons$1.length) return;
+      const customIconLoader = storage2.loadIcon;
+      if (storage2.loadIcons && (icons$1.length > 1 || !customIconLoader)) {
+        parsePossiblyAsyncResponse(storage2.loadIcons(icons$1, prefix, provider), (data) => {
+          parseLoaderResponse(storage2, icons$1, data);
+        });
+        return;
+      }
+      if (customIconLoader) {
+        icons$1.forEach((name) => {
+          const response = customIconLoader(name, prefix, provider);
+          parsePossiblyAsyncResponse(response, (data) => {
+            const iconSet = data ? {
+              prefix,
+              icons: { [name]: data }
+            } : null;
+            parseLoaderResponse(storage2, [name], iconSet);
+          });
+        });
+        return;
+      }
+      const { valid, invalid } = checkIconNamesForAPI(icons$1);
+      if (invalid.length) parseLoaderResponse(storage2, invalid, null);
+      if (!valid.length) return;
+      const api = prefix.match(matchIconName) ? getAPIModule(provider) : null;
+      if (!api) {
+        parseLoaderResponse(storage2, valid, null);
+        return;
+      }
+      const params = api.prepare(provider, prefix, valid);
+      params.forEach((item) => {
+        sendAPIQuery(provider, item, (data) => {
+          parseLoaderResponse(storage2, item.icons, data);
+        });
+      });
+    });
+  }
+}
+var loadIcons = (icons, callback) => {
+  const cleanedIcons = listToIcons(icons, true, allowSimpleNames());
+  const sortedIcons = sortIcons(cleanedIcons);
+  if (!sortedIcons.pending.length) {
+    let callCallback = true;
+    if (callback) setTimeout(() => {
+      if (callCallback) callback(sortedIcons.loaded, sortedIcons.missing, sortedIcons.pending, emptyCallback);
+    });
+    return () => {
+      callCallback = false;
+    };
+  }
+  const newIcons = /* @__PURE__ */ Object.create(null);
+  const sources = [];
+  let lastProvider, lastPrefix;
+  sortedIcons.pending.forEach((icon) => {
+    const { provider, prefix } = icon;
+    if (prefix === lastPrefix && provider === lastProvider) return;
+    lastProvider = provider;
+    lastPrefix = prefix;
+    sources.push(getStorage(provider, prefix));
+    const providerNewIcons = newIcons[provider] || (newIcons[provider] = /* @__PURE__ */ Object.create(null));
+    if (!providerNewIcons[prefix]) providerNewIcons[prefix] = [];
+  });
+  sortedIcons.pending.forEach((icon) => {
+    const { provider, prefix, name } = icon;
+    const storage2 = getStorage(provider, prefix);
+    const pendingQueue = storage2.pendingIcons || (storage2.pendingIcons = /* @__PURE__ */ new Set());
+    if (!pendingQueue.has(name)) {
+      pendingQueue.add(name);
+      newIcons[provider][prefix].push(name);
+    }
+  });
+  sources.forEach((storage2) => {
+    const list = newIcons[storage2.provider][storage2.prefix];
+    if (list.length) loadNewIcons(storage2, list);
+  });
+  return callback ? storeCallback(callback, sortedIcons, sources) : emptyCallback;
+};
+function mergeCustomisations(defaults, item) {
+  const result = { ...defaults };
+  for (const key in item) {
+    const value = item[key];
+    const valueType = typeof value;
+    if (key in defaultIconSizeCustomisations) {
+      if (value === null || value && (valueType === "string" || valueType === "number")) result[key] = value;
+    } else if (valueType === typeof result[key]) result[key] = key === "rotate" ? value % 4 : value;
+  }
+  return result;
+}
+var separator = /[\s,]+/;
+function flipFromString(custom, flip) {
+  flip.split(separator).forEach((str) => {
+    const value = str.trim();
+    switch (value) {
+      case "horizontal":
+        custom.hFlip = true;
+        break;
+      case "vertical":
+        custom.vFlip = true;
+        break;
+    }
+  });
+}
+function rotateFromString(value, defaultValue = 0) {
+  const units = value.replace(/^-?[0-9.]*/, "");
+  function cleanup(value$1) {
+    while (value$1 < 0) value$1 += 4;
+    return value$1 % 4;
+  }
+  if (units === "") {
+    const num = parseInt(value);
+    return isNaN(num) ? 0 : cleanup(num);
+  } else if (units !== value) {
+    let split = 0;
+    switch (units) {
+      case "%":
+        split = 25;
+        break;
+      case "deg":
+        split = 90;
+    }
+    if (split) {
+      let num = parseFloat(value.slice(0, value.length - units.length));
+      if (isNaN(num)) return 0;
+      num = num / split;
+      return num % 1 === 0 ? cleanup(num) : 0;
+    }
+  }
+  return defaultValue;
+}
+function iconToHTML(body, attributes) {
+  let renderAttribsHTML = body.indexOf("xlink:") === -1 ? "" : ' xmlns:xlink="http://www.w3.org/1999/xlink"';
+  for (const attr in attributes) renderAttribsHTML += " " + attr + '="' + attributes[attr] + '"';
+  return '<svg xmlns="http://www.w3.org/2000/svg"' + renderAttribsHTML + ">" + body + "</svg>";
+}
+function encodeSVGforURL(svg) {
+  return svg.replace(/"/g, "'").replace(/%/g, "%25").replace(/#/g, "%23").replace(/</g, "%3C").replace(/>/g, "%3E").replace(/\s+/g, " ");
+}
+function svgToData(svg) {
+  return "data:image/svg+xml," + encodeSVGforURL(svg);
+}
+function svgToURL(svg) {
+  return 'url("' + svgToData(svg) + '")';
+}
+var policy;
+function createPolicy() {
+  try {
+    policy = window.trustedTypes.createPolicy("iconify", { createHTML: (s) => s });
+  } catch (err) {
+    policy = null;
+  }
+}
+function cleanUpInnerHTML(html) {
+  if (policy === void 0) createPolicy();
+  return policy ? policy.createHTML(html) : html;
+}
+var defaultExtendedIconCustomisations = {
+  ...defaultIconCustomisations,
+  inline: false
+};
+var svgDefaults = {
+  "xmlns": "http://www.w3.org/2000/svg",
+  "xmlnsXlink": "http://www.w3.org/1999/xlink",
+  "aria-hidden": true,
+  "role": "img"
+};
+var commonProps = {
+  display: "inline-block"
+};
+var monotoneProps = {
+  backgroundColor: "currentColor"
+};
+var coloredProps = {
+  backgroundColor: "transparent"
+};
+var propsToAdd = {
+  Image: "var(--svg)",
+  Repeat: "no-repeat",
+  Size: "100% 100%"
+};
+var propsToAddTo = {
+  WebkitMask: monotoneProps,
+  mask: monotoneProps,
+  background: coloredProps
+};
+for (const prefix in propsToAddTo) {
+  const list = propsToAddTo[prefix];
+  for (const prop in propsToAdd) {
+    list[prefix + prop] = propsToAdd[prop];
+  }
+}
+var inlineDefaults = {
+  ...defaultExtendedIconCustomisations,
+  inline: true
+};
+function fixSize(value) {
+  return value + (value.match(/^[-0-9.]+$/) ? "px" : "");
+}
+var render = (icon, props, name) => {
+  const defaultProps = props.inline ? inlineDefaults : defaultExtendedIconCustomisations;
+  const customisations = mergeCustomisations(defaultProps, props);
+  const mode = props.mode || "svg";
+  const style = {};
+  const customStyle = props.style || {};
+  const componentProps = {
+    ...mode === "svg" ? svgDefaults : {}
+  };
+  if (name) {
+    const iconName = stringToIcon(name, false, true);
+    if (iconName) {
+      const classNames = ["iconify"];
+      const props2 = [
+        "provider",
+        "prefix"
+      ];
+      for (const prop of props2) {
+        if (iconName[prop]) {
+          classNames.push("iconify--" + iconName[prop]);
+        }
+      }
+      componentProps.className = classNames.join(" ");
+    }
+  }
+  for (let key in props) {
+    const value = props[key];
+    if (value === void 0) {
+      continue;
+    }
+    switch (key) {
+      // Properties to ignore
+      case "icon":
+      case "style":
+      case "children":
+      case "onLoad":
+      case "mode":
+      case "ssr":
+      case "fallback":
+        break;
+      // Forward ref
+      case "_ref":
+        componentProps.ref = value;
+        break;
+      // Merge class names
+      case "className":
+        componentProps[key] = (componentProps[key] ? componentProps[key] + " " : "") + value;
+        break;
+      // Boolean attributes
+      case "inline":
+      case "hFlip":
+      case "vFlip":
+        customisations[key] = value === true || value === "true" || value === 1;
+        break;
+      // Flip as string: 'horizontal,vertical'
+      case "flip":
+        if (typeof value === "string") {
+          flipFromString(customisations, value);
+        }
+        break;
+      // Color: copy to style
+      case "color":
+        style.color = value;
+        break;
+      // Rotation as string
+      case "rotate":
+        if (typeof value === "string") {
+          customisations[key] = rotateFromString(value);
+        } else if (typeof value === "number") {
+          customisations[key] = value;
+        }
+        break;
+      // Remove aria-hidden
+      case "ariaHidden":
+      case "aria-hidden":
+        if (value !== true && value !== "true") {
+          delete componentProps["aria-hidden"];
+        }
+        break;
+      // Copy missing property if it does not exist in customisations
+      default:
+        if (defaultProps[key] === void 0) {
+          componentProps[key] = value;
+        }
+    }
+  }
+  const item = iconToSVG(icon, customisations);
+  const renderAttribs = item.attributes;
+  if (customisations.inline) {
+    style.verticalAlign = "-0.125em";
+  }
+  if (mode === "svg") {
+    componentProps.style = {
+      ...style,
+      ...customStyle
+    };
+    Object.assign(componentProps, renderAttribs);
+    let localCounter = 0;
+    let id = props.id;
+    if (typeof id === "string") {
+      id = id.replace(/-/g, "_");
+    }
+    componentProps.dangerouslySetInnerHTML = {
+      __html: cleanUpInnerHTML(replaceIDs(item.body, id ? () => id + "ID" + localCounter++ : "iconifyReact"))
+    };
+    return createElement("svg", componentProps);
+  }
+  const { body, width, height } = icon;
+  const useMask = mode === "mask" || (mode === "bg" ? false : body.indexOf("currentColor") !== -1);
+  const html = iconToHTML(body, {
+    ...renderAttribs,
+    width: width + "",
+    height: height + ""
+  });
+  componentProps.style = {
+    ...style,
+    "--svg": svgToURL(html),
+    "width": fixSize(renderAttribs.width),
+    "height": fixSize(renderAttribs.height),
+    ...commonProps,
+    ...useMask ? monotoneProps : coloredProps,
+    ...customStyle
+  };
+  return createElement("span", componentProps);
+};
+allowSimpleNames(true);
+setAPIModule("", fetchAPIModule);
+if (typeof document !== "undefined" && typeof window !== "undefined") {
+  const _window = window;
+  if (_window.IconifyPreload !== void 0) {
+    const preload = _window.IconifyPreload;
+    const err = "Invalid IconifyPreload syntax.";
+    if (typeof preload === "object" && preload !== null) {
+      (preload instanceof Array ? preload : [preload]).forEach((item) => {
+        try {
+          if (
+            // Check if item is an object and not null/array
+            typeof item !== "object" || item === null || item instanceof Array || // Check for 'icons' and 'prefix'
+            typeof item.icons !== "object" || typeof item.prefix !== "string" || // Add icon set
+            !addCollection(item)
+          ) {
+            console.error(err);
+          }
+        } catch (e) {
+          console.error(err);
+        }
+      });
+    }
+  }
+  if (_window.IconifyProviders !== void 0) {
+    const providers = _window.IconifyProviders;
+    if (typeof providers === "object" && providers !== null) {
+      for (let key in providers) {
+        const err = "IconifyProviders[" + key + "] is invalid.";
+        try {
+          const value = providers[key];
+          if (typeof value !== "object" || !value || value.resources === void 0) {
+            continue;
+          }
+          if (!addAPIProvider(key, value)) {
+            console.error(err);
+          }
+        } catch (e) {
+          console.error(err);
+        }
+      }
+    }
+  }
+}
+function IconComponent(props) {
+  const [mounted, setMounted] = useState(!!props.ssr);
+  const [abort, setAbort] = useState({});
+  function getInitialState(mounted2) {
+    if (mounted2) {
+      const name2 = props.icon;
+      if (typeof name2 === "object") {
+        return {
+          name: "",
+          data: name2
+        };
+      }
+      const data2 = getIconData(name2);
+      if (data2) {
+        return {
+          name: name2,
+          data: data2
+        };
+      }
+    }
+    return {
+      name: ""
+    };
+  }
+  const [state, setState] = useState(getInitialState(!!props.ssr));
+  function cleanup() {
+    const callback = abort.callback;
+    if (callback) {
+      callback();
+      setAbort({});
+    }
+  }
+  function changeState(newState) {
+    if (JSON.stringify(state) !== JSON.stringify(newState)) {
+      cleanup();
+      setState(newState);
+      return true;
+    }
+  }
+  function updateState() {
+    var _a;
+    const name2 = props.icon;
+    if (typeof name2 === "object") {
+      changeState({
+        name: "",
+        data: name2
+      });
+      return;
+    }
+    const data2 = getIconData(name2);
+    if (changeState({
+      name: name2,
+      data: data2
+    })) {
+      if (data2 === void 0) {
+        const callback = loadIcons([name2], updateState);
+        setAbort({
+          callback
+        });
+      } else if (data2) {
+        (_a = props.onLoad) === null || _a === void 0 ? void 0 : _a.call(props, name2);
+      }
+    }
+  }
+  useEffect(() => {
+    setMounted(true);
+    return cleanup;
+  }, []);
+  useEffect(() => {
+    if (mounted) {
+      updateState();
+    }
+  }, [props.icon, mounted]);
+  const { name, data } = state;
+  if (!data) {
+    return props.children ? props.children : props.fallback ? props.fallback : createElement("span", {});
+  }
+  return render({
+    ...defaultIconProps,
+    ...data
+  }, props, name);
+}
+var Icon = forwardRef((props, ref) => IconComponent({
+  ...props,
+  _ref: ref
+}));
+forwardRef((props, ref) => IconComponent({
+  inline: true,
+  ...props,
+  _ref: ref
+}));
+function Icon2(props) {
+  return /* @__PURE__ */ jsx(Icon, { fallback: /* @__PURE__ */ jsx(Skeleton, { className: props.className }), ...props });
+}
+var APP_ICON_FRAME = "flex items-center justify-center border border-border rounded-md shrink-0 size-10";
+function AppIconFrame({
+  className,
+  children
+}) {
+  return /* @__PURE__ */ jsx("div", { className: cn(APP_ICON_FRAME, className), children });
+}
+var BRAND_ICONS = {
+  google: "logos:google-icon",
+  gmail: "logos:google-gmail",
+  "google-calendar": "logos:google-calendar",
+  "google-drive": "logos:google-drive",
+  slack: "logos:slack-icon",
+  notion: "logos:notion-icon",
+  github: "simple-icons:github",
+  gitlab: "logos:gitlab-icon",
+  linear: "simple-icons:linear",
+  asana: "logos:asana-icon",
+  hubspot: "logos:hubspot",
+  airtable: "logos:airtable",
+  todoist: "simple-icons:todoist",
+  clickup: "simple-icons:clickup",
+  dropbox: "logos:dropbox",
+  bitbucket: "logos:bitbucket",
+  sentry: "logos:sentry-icon",
+  spotify: "logos:spotify-icon",
+  reddit: "logos:reddit-icon",
+  netlify: "logos:netlify-icon",
+  calendly: "simple-icons:calendly",
+  salesforce: "logos:salesforce",
+  zoom: "logos:zoom-icon",
+  intercom: "simple-icons:intercom",
+  "microsoft-teams": "logos:microsoft-teams",
+  box: "logos:box",
+  mailchimp: "logos:mailchimp-freddie",
+  // pipedrive logo includes black wordmark text — invisible on dark
+  // bg. Use the masked /public asset instead (see ASSET_ICONS below).
+  xero: "simple-icons:xero",
+  pagerduty: "simple-icons:pagerduty",
+  typeform: "simple-icons:typeform",
+  // harvest — no Iconify slug; monogram letter fallback.
+  eventbrite: "simple-icons:eventbrite",
+  // klaviyo / freshbooks / harvest — no Iconify slug exists across
+  // simple-icons / logos / arcticons. Fall through to monogram letter.
+  square: "simple-icons:square",
+  front: "arcticons:front",
+  basecamp: "simple-icons:basecamp",
+  jira: "logos:jira",
+  confluence: "logos:confluence",
+  figma: "logos:figma",
+  vercel: "simple-icons:vercel",
+  sendgrid: "logos:sendgrid-icon",
+  stripe: "logos:stripe",
+  "outlook-mail": "vscode-icons:file-type-outlook",
+  "outlook-calendar": "vscode-icons:file-type-outlook",
+  // The outlook-mail catalog row seeds `icon: 'outlook'`, and `icon` wins
+  // over `kind` — without this alias it falls through to the monogram.
+  // Seeded rows already carry the value in the DB, so fixing the seed
+  // wouldn't repair existing installs.
+  outlook: "vscode-icons:file-type-outlook",
+  onedrive: "logos:microsoft-onedrive",
+  // `logos` has no sharepoint mark — selfhst carries the full-colour brand
+  // icon, so this stays visually consistent with the logos entries around it.
+  sharepoint: "selfhst:microsoft-sharepoint",
+  mcp: "codicon:mcp",
+  // Channel platforms (not in app catalog but rendered with the same component)
+  discord: "logos:discord-icon",
+  telegram: "logos:telegram",
+  whatsapp: "logos:whatsapp-icon",
+  teams: "logos:microsoft-teams",
+  email: "mingcute:mail-line",
+  webhook: "material-symbols:webhook",
+  cron: "mingcute:time-line",
+  form: "mingcute:list-check-line",
+  // 10 data-source adapters
+  postgres: "logos:postgresql",
+  mysql: "logos:mysql",
+  mongodb: "logos:mongodb-icon",
+  supabase: "logos:supabase-icon",
+  // `logos:` has no Sheets entry. Monochrome mdi mark, matching the one
+  // the artifact library uses for spreadsheets (artifact-format-icon.tsx)
+  // — full-color alternatives sit in a different visual generation from
+  // the rest of the set.
+  "google-sheets": "mdi:google-spreadsheet",
+  "google-analytics": "logos:google-analytics",
+  // bigquery + gcs have no dedicated logos: slug; use google-cloud mark
+  bigquery: "logos:google-cloud",
+  gcs: "logos:google-cloud",
+  posthog: "simple-icons:posthog",
+  shopify: "logos:shopify"
+};
+var BRAND_ICON_TINT = {
+  "google-sheets": "text-[#0F9D58]"
+};
+var ASSET_ICONS = {
+  rill: { src: "/rill-svg.svg", color: "#4C40F8" },
+  klaviyo: { src: "/klaviyo.svg", color: "#5C4FE7" },
+  freshbooks: { src: "/freshbooks.svg", color: "#0075DD" },
+  harvest: { src: "/harvest.svg", color: "#FA5D00" },
+  pipedrive: { src: "/pipedrive.svg", color: "#1A1A1A" },
+  // Verification plugin family — neutral @frontera/icons glyphs, one per
+  // plugin so the three read as distinct capabilities in the catalog.
+  "document-intelligence": { src: "/document-intelligence.svg", color: "#2563EB" },
+  "bank-statement-analysis": { src: "/bank-statement-analysis.svg", color: "#059669" },
+  "extraction-templates": { src: "/extraction-templates.svg", color: "#7C3AED" }
+};
+var SIZE = {
+  sm: { box: "size-6", icon: "size-3.5", text: "text-xs" },
+  md: { box: "size-8", icon: "size-5", text: "text-xs" },
+  lg: { box: "size-10", icon: "size-8", text: "text-sm" }
+};
+function getAppBrandIconId(kind, icon) {
+  const iconKey = kind;
+  return BRAND_ICONS[iconKey] ?? null;
+}
+function AppIcon({
+  kind,
+  icon,
+  iconUrl,
+  displayName,
+  size = "sm",
+  className = ""
+}) {
+  const dims = SIZE[size];
+  const iconKey = icon || kind;
+  if (iconUrl) {
+    return (
+      // eslint-disable-next-line @next/next/no-img-element
+      /* @__PURE__ */ jsx(
+        "img",
+        {
+          src: iconUrl,
+          alt: displayName ?? kind,
+          draggable: false,
+          className: `inline-block object-contain ${dims.icon} ${className}`
+        }
+      )
+    );
+  }
+  const asset = ASSET_ICONS[iconKey];
+  if (asset) {
+    return /* @__PURE__ */ jsx(
+      "span",
+      {
+        className: `inline-flex items-center justify-center overflow-hidden rounded-md ${dims.box} ${className}`,
+        style: { backgroundColor: asset.color },
+        "aria-label": displayName ?? kind,
+        role: "img",
+        children: /* @__PURE__ */ jsx(
+          "span",
+          {
+            "aria-hidden": true,
+            className: `${dims.icon} block`,
+            style: {
+              WebkitMaskImage: `url(${asset.src})`,
+              maskImage: `url(${asset.src})`,
+              WebkitMaskRepeat: "no-repeat",
+              maskRepeat: "no-repeat",
+              WebkitMaskSize: "contain",
+              maskSize: "contain",
+              WebkitMaskPosition: "center",
+              maskPosition: "center",
+              backgroundColor: "#ffffff"
+            }
+          }
+        )
+      }
+    );
+  }
+  const brand = BRAND_ICONS[iconKey];
+  if (brand) {
+    return /* @__PURE__ */ jsx(
+      "span",
+      {
+        className: cn(
+          "inline-flex items-center justify-center",
+          BRAND_ICON_TINT[iconKey] ?? "text-foreground"
+        ),
+        children: /* @__PURE__ */ jsx(Icon2, { icon: brand, className: dims.icon })
+      }
+    );
+  }
+  const letter = (displayName?.[0] ?? kind[0] ?? "?").toUpperCase();
+  return /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: `inline-flex items-center justify-center rounded-md border bg-muted text-foreground font-mono font-medium ${dims.box} ${dims.text} ${className}`,
+      children: letter
+    }
+  );
+}
+var RUNNING_STATES = /* @__PURE__ */ new Set([
+  "input-streaming",
+  "partial-call",
+  "input-available",
+  "call"
+]);
+var TIMELINE_ICON_BEAD = "flex w-4 h-7 shrink-0 items-center justify-center rounded-full bg-surface-chat";
+function getSkillContent(output) {
+  if (!output || typeof output !== "object") return null;
+  let o = output;
+  if ("value" in o && o.value && typeof o.value === "object") {
+    o = o.value;
+  }
+  return typeof o.content === "string" && o.content.trim() ? o.content : null;
+}
+function SkillToolItem({
+  state,
+  input,
+  output,
+  className
+}) {
+  const [open, setOpen] = useState(false);
+  const slug = extractSkillSlug(input);
+  const displayName = resolveSkillLabel(input, output);
+  const appKind = slug ? skillSlugToAppKind(slug) : "";
+  const brandIconId = appKind ? getAppBrandIconId(appKind) : null;
+  const isRunning = RUNNING_STATES.has(state);
+  const isError = state === "output-error" || state === "error";
+  const content = getSkillContent(output);
+  const hasContent = !!content && !isError;
+  const prefix = isError ? "Skill failed" : isRunning ? "Loading" : "Used";
+  return /* @__PURE__ */ jsxs("div", { className: cn("relative z-10", className), children: [
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: () => hasContent && setOpen((v) => !v),
+        "aria-expanded": hasContent ? open : void 0,
+        className: cn(
+          "group/row flex w-full min-w-0 items-center gap-2 py-0.5 text-left text-sm text-muted-foreground",
+          hasContent ? "transition-colors hover:text-foreground" : "cursor-default"
+        ),
+        children: [
+          /* @__PURE__ */ jsx("span", { className: TIMELINE_ICON_BEAD, children: brandIconId ? /* @__PURE__ */ jsx(frontera_icon_default, { icon: brandIconId, className: "size-3.5 opacity-90" }) : /* @__PURE__ */ jsx(Book3Icon, { className: "size-3.5 opacity-80" }) }),
+          isRunning ? /* @__PURE__ */ jsx(Shimmer, { as: "span", className: "min-w-0 truncate text-sm", children: displayName ? `${prefix} ${displayName} skill` : `${prefix} skill\u2026` }) : /* @__PURE__ */ jsx("span", { className: "min-w-0 truncate", children: isError ? /* @__PURE__ */ jsx("span", { className: " text-destructive", children: prefix }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsxs("span", { children: [
+              prefix,
+              " "
+            ] }),
+            displayName ? /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx("span", { className: " text-foreground", children: displayName }),
+              /* @__PURE__ */ jsx("span", { children: " skill" })
+            ] }) : /* @__PURE__ */ jsx("span", { className: "", children: "skill" })
+          ] }) }),
+          hasContent && /* @__PURE__ */ jsx(
+            ChevronDownMediumIcon,
+            {
+              className: cn(
+                "size-3.5 shrink-0 text-muted-foreground/60 transition-transform",
+                !open && "-rotate-90"
+              )
+            }
+          )
+        ]
+      }
+    ),
+    hasContent && /* @__PURE__ */ jsx(Collapse, { open, children: /* @__PURE__ */ jsx("div", { className: "mt-1.5 ml-6 rounded-lg border border-muted-foreground/10 bg-surface-raised overflow-hidden shadow-xs", children: /* @__PURE__ */ jsx(ScrollFadeEdges, { className: "max-h-52 p-4", children: /* @__PURE__ */ jsx(
+      MessageResponse,
+      {
+        className: "prose prose-sm dark:prose-invert max-w-none leading-relaxed prose-headings:font-medium prose-p:text-muted-foreground prose-li:text-muted-foreground",
+        children: content
+      }
+    ) }) }) })
+  ] });
+}
+function BlueprintIcon({ className, ...rest }) {
+  return /* @__PURE__ */ jsxs(
+    "svg",
+    {
+      viewBox: "0 0 24 24",
+      fill: "none",
+      xmlns: "http://www.w3.org/2000/svg",
+      "aria-hidden": true,
+      className: cn("shrink-0", className),
+      ...rest,
+      children: [
+        /* @__PURE__ */ jsx(
+          "path",
+          {
+            d: "M21.9165 3.57282C21.9665 3.38787 21.9731 3.19389 21.9361 3.00593C21.899 2.81797 21.8191 2.64108 21.7026 2.48898C21.5861 2.33687 21.4361 2.21364 21.2644 2.12885C21.0926 2.04405 20.9036 1.99996 20.712 2H7.82207C4.6072 2 2.00057 3.48949 2.00057 5.32678V5.94952L3.30588 15.3066H17.2431C17.5059 15.3066 17.7619 15.2236 17.9747 15.0695C18.1875 14.9154 18.3462 14.698 18.4282 14.4484L21.8975 3.63719C21.9592 3.44978 21.9755 3.25042 21.9451 3.05548C21.9147 2.86055 21.8386 2.67559 21.7229 2.5158C21.6072 2.35601 21.4552 2.22594 21.2795 2.13628C21.1037 2.04662 20.9093 1.99991 20.712 2",
+            fill: "currentColor",
+            fillOpacity: 0.4
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "path",
+          {
+            d: "M9.34401 21.1216C9.26407 21.3763 9.10494 21.5988 8.88978 21.7568C8.67462 21.9148 8.41465 22 8.14772 22H7.8494C4.6185 22 1.99978 20.5033 1.99978 18.6572V5.28674C1.99978 7.13241 4.619 8.6291 7.8494 8.6291H11.6328C11.8305 8.62903 12.0253 8.6757 12.2015 8.7653C12.3777 8.8549 12.5301 8.98489 12.6465 9.14466C12.7628 9.30444 12.8398 9.48946 12.871 9.68463C12.9022 9.8798 12.8868 10.0796 12.8261 10.2677L9.34401 21.1216Z",
+            fill: "currentColor"
+          }
+        )
+      ]
+    }
+  );
+}
+var iconClass = "size-3.5 shrink-0";
+function getToolMeta(toolName, className) {
+  const displayName = toolName.includes("__") ? toolName.split("__").pop() ?? toolName : toolName;
+  const label = displayName.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+  if (toolName.startsWith("blueprint_")) {
+    return {
+      label: toolName.slice("blueprint_".length).replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()),
+      icon: /* @__PURE__ */ jsx(BlueprintIcon, { className: cn(iconClass, className, "text-muted-foreground group-hover/row:text-primary") })
+    };
+  }
+  switch (displayName) {
+    case "web_search":
+      return {
+        label: "Web Search",
+        icon: /* @__PURE__ */ jsx(WorldSearchIcon, { className: cn(iconClass, className) })
+      };
+    case "createDocument":
+      return {
+        label: "Create Document",
+        icon: /* @__PURE__ */ jsx(WritingIcon, { className: cn(iconClass, className) })
+      };
+    case "updateDocument":
+      return {
+        label: "Update Document",
+        icon: /* @__PURE__ */ jsx(PencilIcon, { className: cn(iconClass, className) })
+      };
+    case "skill":
+      return {
+        label: "Skill",
+        icon: /* @__PURE__ */ jsx(Book3Icon, { className: cn(iconClass, className) })
+      };
+    case "resolvePath":
+      return {
+        label: "Resolve Path",
+        icon: /* @__PURE__ */ jsx(Folder1Icon, { className: cn(iconClass, className) })
+      };
+    case "readFile":
+    case "readFileBuffer":
+    case "read_file":
+      return {
+        label: "Read File",
+        icon: /* @__PURE__ */ jsx(FileTextIcon, { className: cn(iconClass, className) })
+      };
+    case "exists":
+      return {
+        label: "Exists",
+        icon: /* @__PURE__ */ jsx(FileTextIcon, { className: cn(iconClass, className) })
+      };
+    case "writeFile":
+    case "write_file":
+      return {
+        label: "Write File",
+        icon: /* @__PURE__ */ jsx(PencilIcon, { className: cn(iconClass, className) })
+      };
+    case "edit_file":
+      return {
+        label: "Edit File",
+        icon: /* @__PURE__ */ jsx(PencilIcon, { className: cn(iconClass, className) })
+      };
+    case "readdir":
+      return {
+        label: "Read Directory",
+        icon: /* @__PURE__ */ jsx(Folder1Icon, { className: cn(iconClass, className) })
+      };
+    case "symlink":
+      return {
+        label: "Create Symlink",
+        icon: /* @__PURE__ */ jsx(Folder1Icon, { className: cn(iconClass, className) })
+      };
+    case "bash":
+    case "shell":
+      return {
+        label: "Bash Command",
+        icon: /* @__PURE__ */ jsx(Terminal2Icon, { className: cn(iconClass, className) })
+      };
+    case "run_js":
+    case "runJs":
+    case "run_python":
+    case "runPython":
+      return {
+        label: displayName === "run_python" || displayName === "runPython" ? "Run Python" : "Run JavaScript",
+        icon: /* @__PURE__ */ jsx(Code2Icon, { className: cn(iconClass, className) })
+      };
+    case "view_image":
+    case "viewImage":
+      return {
+        label: "View Image",
+        icon: /* @__PURE__ */ jsx(PhotoIcon, { className: cn(iconClass, className) })
+      };
+    case "expose_app":
+      return {
+        label: "Expose App",
+        icon: /* @__PURE__ */ jsx(DeviceDesktopIcon, { className: cn(iconClass, className) })
+      };
+    case "setup_web_app":
+      return {
+        label: "Set Up Web App",
+        icon: /* @__PURE__ */ jsx(DeviceDesktopIcon, { className: cn(iconClass, className) })
+      };
+    case "think":
+      return {
+        label: "Internal Check",
+        icon: /* @__PURE__ */ jsx(
+          frontera_icon_default,
+          {
+            icon: "message-circle-dashed",
+            className: cn(iconClass, className)
+          }
+        )
+      };
+    case "delegate":
+      return {
+        label: "Sub-agent",
+        icon: /* @__PURE__ */ jsx(Robot4Icon, { className: cn(iconClass, className) })
+      };
+    case "createImage":
+      return {
+        label: "Create Image",
+        icon: /* @__PURE__ */ jsx(TextToImageIcon, { className: cn(iconClass, className) })
+      };
+    default:
+      return {
+        label,
+        icon: /* @__PURE__ */ jsx(ApiAppIcon, { className: cn(iconClass, className) })
+      };
+  }
+}
+function ToolGroupReasoningDetail({ text }) {
+  const plugins = useStreamdownPlugins();
+  const visibleText = useMemo(
+    () => text.replace(/\[REDACTED\]/g, "").trim(),
+    [text]
+  );
+  return /* @__PURE__ */ jsx("div", { className: "pl-6 pt-1", children: /* @__PURE__ */ jsx(
+    ScrollFadeEdges,
+    {
+      className: "max-h-52",
+      fadeFromClassName: "from-surface-chat",
+      children: /* @__PURE__ */ jsx(
+        Streamdown,
+        {
+          className: "space-y-1.5 text-[13px] leading-relaxed text-muted-foreground/80 [&>*:first-child]:mt-0 [&>*:last-child]:mb-0 [&_h1,&_h2,&_h3,&_h4,&_h5,&_h6]:text-[13px]! [&_h1,&_h2,&_h3,&_h4,&_h5,&_h6]:font-semibold [&_h1,&_h2,&_h3,&_h4,&_h5,&_h6]:mt-3!",
+          plugins,
+          linkSafety: STREAMDOWN_LINK_SAFETY,
+          children: visibleText
+        }
+      )
+    }
+  ) });
+}
+var ToolGroupReasoningItem = ({
+  className,
+  text,
+  isStreaming = false,
+  ...props
+}) => {
+  const [open, setOpen] = useState(false);
+  const expanded = isStreaming || open;
+  return /* @__PURE__ */ jsxs("div", { className: cn("relative z-10 py-0.5", className), ...props, children: [
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: () => setOpen((v) => !v),
+        "aria-expanded": expanded,
+        className: "flex w-full items-center gap-2 text-left text-sm text-muted-foreground transition-colors hover:text-foreground",
+        children: [
+          /* @__PURE__ */ jsx("span", { className: "flex w-4 h-7 shrink-0 items-center justify-center rounded-full bg-surface-chat", children: /* @__PURE__ */ jsx(
+            frontera_icon_default,
+            {
+              icon: "message-circle-dashed",
+              className: "size-3.5 opacity-80"
+            }
+          ) }),
+          isStreaming ? /* @__PURE__ */ jsx(Shimmer, { as: "span", className: "text-sm", children: "Thinking\u2026" }) : /* @__PURE__ */ jsx("span", { className: "", children: "Thought process" }),
+          /* @__PURE__ */ jsx(
+            ChevronDownMediumIcon,
+            {
+              className: cn(
+                "size-3.5 shrink-0 text-muted-foreground/60 transition-transform",
+                !expanded && "-rotate-90"
+              )
+            }
+          )
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx(Collapse, { open: expanded, children: expanded ? /* @__PURE__ */ jsx(ToolGroupReasoningDetail, { text }) : null })
+  ] });
+};
+
+export { AppIcon, AppIconFrame, Collapse, Collapsible, CollapsibleContent2 as CollapsibleContent, CollapsibleTrigger2 as CollapsibleTrigger, HoverCard, HoverCardContent, HoverCardTrigger, Icon2 as Icon, Message, MessageContent, MessageResponse, MessageToolbar, STREAMDOWN_LINK_SAFETY, Shimmer, SkillToolItem, ToolGroupReasoningItem, deferDuringLayoutMotion, describeToolRow, frontera_icon_default, getToolMeta, useStreamdownPlugins };