@kitn.ai/ui 0.20.1 → 0.22.0

package/dist/components/model-switcher.d.ts

@@ -1,5 +1,5 @@
-import { DropdownController } from '../ui/dropdown';
-import { ModelOption } from '../types';
+import { DropdownController } from '../ui/dropdown.js';
+import { ModelOption } from '../types.js';
 export interface ModelSwitcherProps {
     models: ModelOption[];
     currentModelId: string;

package/dist/components/prompt-input.d.ts

@@ -1,6 +1,6 @@
 import { JSX } from 'solid-js';
-import { TriggerDef, ComposerChange } from './composer';
-import { ComposerDoc } from '../primitives/composer-model';
+import { TriggerDef, ComposerChange } from './composer.js';
+import { ComposerDoc } from '../primitives/composer-model.js';
 interface PromptInputContextType {
     isLoading: boolean;
     value: () => string | ComposerDoc;

package/dist/components/response-compare-types.d.ts

@@ -1,5 +1,6 @@
-import { ToolPart } from './tool';
-import { AttachmentData } from './attachments';
+import { ToolPart } from './tool.js';
+import { AttachmentData } from './attachments.js';
+import { MessagePart } from '../elements/chat-types.js';
 /** One assistant response in a comparison. Rendered identically to an assistant
  *  message (reasoning + tools + attachments + markdown content) via `MessageBody`. */
 export interface CompareCandidate {
@@ -64,3 +65,11 @@ export declare function normalizeCandidates(candidates: unknown): {
 export declare function buildSelection(pair: ComparePair, chosenId: string): CompareSelection;
 /** Whether any candidate in the pair is still streaming (pick stays disabled). */
 export declare function isAnyStreaming(pair: ComparePair | null): boolean;
+/** Map a `CompareCandidate`'s flat legacy fields (content/reasoning/tools/
+ *  attachments) into the ordered `MessagePart[]` `MessageBody` now renders.
+ *  `CompareCandidate` stays its own independent shape (it is `<kai-compare>`'s
+ *  public `data` JSON, not a `ChatMessage`). This is purely a render-time
+ *  adapter, applied at each `MessageBody` call site. Order: reasoning (the
+ *  thinking trace) → tool calls (the actions taken) → attachments (anything
+ *  produced) → the final text answer, mirroring how an assistant turn reads. */
+export declare function candidateToParts(candidate: CompareCandidate): MessagePart[];

package/dist/components/response-compare.d.ts

@@ -1,7 +1,7 @@
 import { JSX, Accessor } from 'solid-js';
-import { CompareSelection, ResponseCompareData } from './response-compare-types';
-export type { CompareCandidate, ComparePair, CompareCollapse, ResponseCompareData, CompareSelection, } from './response-compare-types';
-export { normalizeCandidates, buildSelection, isAnyStreaming } from './response-compare-types';
+import { CompareSelection, ResponseCompareData } from './response-compare-types.js';
+export type { CompareCandidate, ComparePair, CompareCollapse, ResponseCompareData, CompareSelection, } from './response-compare-types.js';
+export { normalizeCandidates, buildSelection, isAnyStreaming, candidateToParts } from './response-compare-types.js';
 export type CompareLayout = 'auto' | 'columns' | 'tabs';
 /** Imperative handle exposed via `controllerRef` — surfaces the compare's latent
  *  capabilities (commit a pick by candidate id, focus the roving tab stop) so the

package/dist/components/source.d.ts

@@ -1,6 +1,11 @@
 import { JSX } from 'solid-js';
 export interface SourceProps {
-    href: string;
+    /** The citation's URL. OPTIONAL: every field of a model-produced citation is,
+     *  so a source can arrive with a title and no url. In that case the chip
+     *  renders as a plain, inert `<a>` with NO `href` attribute — which is valid
+     *  HTML and simply not a link — rather than `<a href="">`, which would
+     *  navigate to the current page. */
+    href?: string;
     children: JSX.Element;
 }
 declare function Source(props: SourceProps): JSX.Element;
@@ -16,8 +21,12 @@ export interface SourceContentProps {
     class?: string;
 }
 declare function SourceContent(props: SourceContentProps): JSX.Element;
-declare function SourceList(props: {
+export interface SourceListProps {
     children: JSX.Element;
     class?: string;
-}): JSX.Element;
+    /** `::part` name(s) exposed on the row. The message body passes `"citations"`
+     *  so consumers can target the citation row from outside the shadow boundary. */
+    part?: string;
+}
+declare function SourceList(props: SourceListProps): JSX.Element;
 export { Source, SourceTrigger, SourceContent, SourceList };

package/dist/components/tasks-card.d.ts

@@ -1,35 +1,7 @@
 import { JSX } from 'solid-js';
-import { CardEnvelope, CardHost, CardResolution } from '../primitives/card-contract';
-export interface TasksTask {
-    id: string;
-    label: string;
-    description?: string;
-    checked?: boolean;
-    disabled?: boolean;
-}
-export interface TasksCardData {
-    /**
-     * `select` (default) = checkbox rows + a confirm button that emits the contract
-     * `submit`. `progress` = an onboarding/checklist look: a header `done / total`
-     * count, circular indicators, per-item title + muted description, and NO confirm
-     * button (checking a row is itself the terminal action). Both share the same
-     * selection model (toggle by id, the `max` gate, `kai-value-change`); `progress`
-     * is purely a presentational variant.
-     */
-    mode?: 'select' | 'progress';
-    heading?: string;
-    tasks: TasksTask[];
-    selectAll?: boolean;
-    confirmLabel?: string;
-    allowEmpty?: boolean;
-    min?: number;
-    max?: number;
-    dismissible?: boolean;
-}
-export interface TasksCardResult {
-    selected: string[];
-}
-export type TasksCardEnvelope = CardEnvelope<'tasks', TasksCardData>;
+import { CardHost, CardResolution } from '../primitives/card-contract.js';
+import { TasksCardData, TasksTask } from '../primitives/card-data-types.js';
+export type { TasksCardData, TasksCardEnvelope, TasksCardResult, TasksTask, } from '../primitives/card-data-types.js';
 export declare const TASKS_CARD_TYPE: "tasks";
 /** De-dupe tasks by id (first wins). Returns the usable list + an optional error. */
 export declare function normalizeTasks(tasks: unknown): {

package/dist/components/thread.d.ts

@@ -1,7 +1,9 @@
 import { JSX } from 'solid-js';
-import { MessageActionDetail } from '../primitives/message-feedback';
-import { ChatMessage } from '../elements/chat-types';
-import { ProseSize } from '../primitives/chat-config';
+import { MessageActionDetail } from '../primitives/message-feedback.js';
+import { ChatMessage } from '../elements/chat-types.js';
+import { ProseSize } from '../primitives/chat-config.js';
+import { CardComponentMap } from '../primitives/card-registry.js';
+import { CardSchemaMap } from './card-renderer.js';
 /** Imperative handle exposed via `controllerRef` — the thread's scroll control,
  *  forwarded onto `<kai-thread>` as the `scrollToBottom()` instance method. */
 export interface ThreadController {
@@ -12,9 +14,19 @@ export interface ThreadProps {
     /** Extra classes for the thread root (e.g. `rounded-xl`). */
     class?: string;
     /** The full message thread to render, newest last. Each entry carries its role,
-     *  content, and optional reasoning/tools/attachments/actions/avatar. A new array
-     *  reference per streaming chunk re-renders (mutating in place does not). */
+     *  ordered `parts`, and optional actions/avatar/feedback. A new array reference
+     *  per streaming chunk re-renders (mutating in place does not). */
     messages: ChatMessage[];
+    /** Add/override card type -> component entries, forwarded to `CardRenderer`
+     *  for `card` parts. */
+    cardTypes?: CardComponentMap;
+    /** JSON Schemas for the card types this app renders, keyed by envelope type,
+     *  forwarded to `CardRenderer` for `card` parts. The companion of `cardTypes`:
+     *  that says what DRAWS a card, this says what a VALID one looks like.
+     *  `createCardRegistry(...).validationSchemas` is exactly this shape. Without it
+     *  the kit checks its own seven built-ins and leaves your own card type
+     *  unvalidated. A schema here WINS over a built-in of the same name. */
+    cardSchemas?: CardSchemaMap;
     /** Show a typing indicator on the pending assistant turn — use while awaiting
      *  the assistant's reply. */
     loading?: boolean;

package/dist/components/toast.d.ts

@@ -1,4 +1,4 @@
-import { ToastItem, ToastVariant, ToastAppearance } from '../primitives/toast-store';
+import { ToastItem, ToastVariant, ToastAppearance } from '../primitives/toast-store.js';
 export type { ToastItem, ToastVariant, ToastAppearance };
 /** Why a toast went away — surfaced to `onDismiss` (and the facade event). */
 export type ToastDismissReason = 'timeout' | 'close' | 'action';
@@ -30,7 +30,7 @@ export interface ToastRegionProps {
     /** Fired when a toast's action button is pressed. */
     onAction?: (id: string, label: string) => void;
 }
-interface ToastProps {
+export interface ToastProps {
     item: ToastItem;
     onDismiss: (reason: ToastDismissReason) => void;
     onAction?: (label: string) => void;

package/dist/components/tool-classify.d.ts

@@ -0,0 +1,8 @@
+/** Semantic classification of a tool call, used to pick a rendering. Derived from
+ *  the provider-chosen tool NAME, which is arbitrary, so this stays conservative and
+ *  prefers 'generic' over a confident wrong answer. */
+export type ToolKind = 'command' | 'file-change' | 'search' | 'fetch' | 'mcp' | 'image' | 'generic';
+/** Total, deterministic, side-effect free. ALWAYS terminates in 'generic' so an
+ *  unrecognized tool still renders a panel instead of a blank. Order matters:
+ *  'search' is tested before 'fetch' so `web_search` classifies as a search. */
+export declare function classifyTool(name: string): ToolKind;

package/dist/components/tool-types.d.ts

@@ -1,10 +1,38 @@
+import { ToolKind } from './tool-classify.js';
+/** The untranslated provider payload a part was normalized from.
+ *
+ *  Optional in the type but REQUIRED in practice for round-trip fidelity. Anthropic
+ *  returns a 400 invalid_request_error if `thinking` blocks are modified, reordered,
+ *  filtered or RECONSTRUCTED, so an encoder must send `raw.payload` back verbatim
+ *  rather than rebuilding a block from `text` + `signature`. */
+export interface RawOrigin {
+    /** Tagged origin, e.g. 'anthropic.content_block', 'openai.delta', `custom.${string}`. */
+    source: string;
+    payload: unknown;
+}
 /** A tool-call part rendered by <Tool>. Pure type — kept JSX-free so it can be
- *  imported by the framework-neutral state core and the React typecheck pass. */
+ *  imported by the framework-neutral state core and the React typecheck pass.
+ *
+ *  Adding a field here also requires adding it to `TOOL_KEYS` (and a comparator
+ *  in `TOOL_COMPARATORS`) in `state/parts.ts`, or `tsc` fails to compile: those
+ *  drive `upsertToolPart`'s dedupe check, and a field missing from them would
+ *  silently make that check ignore the new field, keeping a stale array
+ *  reference alive when only that field changed. */
 export interface ToolPart {
+    /** The tool name exactly as the provider reported it. */
     type: string;
+    /** Semantic classification for rendering. Derive with classifyTool(type). */
+    kind?: ToolKind;
     state: 'input-streaming' | 'input-available' | 'output-available' | 'output-error';
+    /** Last VALID parsed snapshot, fingerprint-deduped. The primary channel: this is
+     *  what the kit renders. */
     input?: Record<string, unknown>;
+    /** Raw accumulated argument fragments, for consumers wanting character-level
+     *  streaming. Most consumers should read `input` instead. */
+    rawInput?: string;
     output?: Record<string, unknown>;
     toolCallId?: string;
     errorText?: string;
+    /** The untranslated provider payload this was normalized from. */
+    raw?: RawOrigin;
 }

package/dist/components/tool.d.ts

@@ -1,7 +1,7 @@
 import { JSX } from 'solid-js';
-import { CollapsibleController } from '../ui/collapsible';
-import { ToolPart } from './tool-types';
-export type { ToolPart } from './tool-types';
+import { CollapsibleController } from '../ui/collapsible.js';
+import { ToolPart } from './tool-types.js';
+export type { ToolPart } from './tool-types.js';
 export interface ToolProps {
     toolPart: ToolPart;
     defaultOpen?: boolean;

package/dist/components/use-card-resolution.d.ts

@@ -1,5 +1,5 @@
 import { Accessor } from 'solid-js';
-import { CardResolution } from '../primitives/card-contract';
+import { CardResolution } from '../primitives/card-contract.js';
 export interface ResolutionController<R extends CardResolution = CardResolution> {
     resolution: Accessor<R | undefined>;
     isResolved: Accessor<boolean>;

package/dist/create-tween-COnPwAQN.js

@@ -0,0 +1,338 @@
+import { ssr as Le, ssrAttribute as we, escape as ye } from "solid-js/web";
+import { createMemo as U, onCleanup as G, createEffect as ue, untrack as ve, createSignal as le } from "solid-js";
+import { c as Re } from "./solid-Dt2nEwfl.js";
+var _e = ['<canvas part="canvas"', "></canvas>"];
+const Ce = "#1FD5F9";
+function Ie(e) {
+  const n = e.trim().match(/^#([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/);
+  if (!n) return Ie(Ce);
+  const [, o, a, s] = n;
+  return [parseInt(o, 16) / 255, parseInt(a, 16) / 255, parseInt(s, 16) / 255];
+}
+const Te = {
+  "1f": "float",
+  "1i": "int",
+  "1fv": "float",
+  "2f": "vec2",
+  "3f": "vec3",
+  "3fv": "vec3",
+  "4f": "vec4",
+  "4fv": "vec4",
+  Matrix2fv: "mat2",
+  Matrix3fv: "mat3",
+  Matrix4fv: "mat4"
+}, Oe = {
+  "1fv": 1,
+  "3fv": 3,
+  "4fv": 4,
+  Matrix2fv: 4,
+  Matrix3fv: 9,
+  Matrix4fv: 16
+};
+function Pe(e) {
+  const n = Oe[e.type];
+  if (!n || !Array.isArray(e.value)) return;
+  const o = e.value.length / n;
+  return o > 1 && Number.isInteger(o) ? o : void 0;
+}
+function he(e) {
+  return e.arraySize ?? Pe(e);
+}
+const ke = ["uniform float iTime;", "uniform vec2 iResolution;", "uniform vec4 iMouse;", "uniform int iFrame;", "uniform vec4 iDate;"].join(`
+`), De = `
+attribute vec3 aVertexPosition;
+void main() { gl_Position = vec4(aVertexPosition, 1.0); }
+`;
+function Ne(e, n, o) {
+  const a = Object.entries(n).map(([s, i]) => {
+    const u = he(i), m = u ? `[${u}]` : "";
+    return `uniform ${Te[i.type]} ${s}${m};`;
+  }).join(`
+`);
+  return [`precision ${o} float;`, ke, a, e, "void main() { mainImage(gl_FragColor, gl_FragCoord.xy); }"].join(`
+`);
+}
+function Ue(e) {
+  return Object.keys(e).sort().map((n) => {
+    const o = e[n];
+    return `${n}:${o.type}:${he(o) ?? ""}`;
+  }).join("|");
+}
+function me(e, n, o) {
+  const a = e.createShader(n);
+  if (!a) return "Could not create a WebGL shader.";
+  if (e.shaderSource(a, o), e.compileShader(a), !e.getShaderParameter(a, e.COMPILE_STATUS)) {
+    const s = e.getShaderInfoLog(a) ?? "Unknown shader compile error.";
+    return e.deleteShader(a), s;
+  }
+  return a;
+}
+function Be(e, n, o) {
+  const a = o.value;
+  switch (o.type) {
+    case "1f":
+      e.uniform1f(n, a);
+      break;
+    case "1i":
+      e.uniform1i(n, a);
+      break;
+    case "1fv":
+      e.uniform1fv(n, a);
+      break;
+    case "2f":
+      e.uniform2fv(n, a);
+      break;
+    case "3f":
+    case "3fv":
+      e.uniform3fv(n, a);
+      break;
+    case "4f":
+    case "4fv":
+      e.uniform4fv(n, a);
+      break;
+    case "Matrix2fv":
+      e.uniformMatrix2fv(n, !1, a);
+      break;
+    case "Matrix3fv":
+      e.uniformMatrix3fv(n, !1, a);
+      break;
+    case "Matrix4fv":
+      e.uniformMatrix4fv(n, !1, a);
+      break;
+  }
+}
+function Ve(e) {
+  let n;
+  const o = U(() => Ue(e.uniforms ?? {})), a = U(() => e.fragment), s = U(() => e.precision ?? "highp");
+  let i = "none", u = null, m = null, r = null, l = null, f = 0;
+  const d = typeof cancelAnimationFrame == "function" ? cancelAnimationFrame.bind(globalThis) : () => {
+  };
+  let v = null, b = !1, M = !1, E = !1, L = !1, S, x = !1, w = !0, _ = !1, C = 0, I = 0, W = 0;
+  const ge = () => {
+    var c;
+    return u || (u = n.getContext("webgl") ?? n.getContext("experimental-webgl"), u && (i = "live", m = ((c = u.getExtension) == null ? void 0 : c.call(u, "WEBGL_lose_context")) ?? null), u);
+  }, $ = () => {
+    f !== 0 || !l || L || (I = performance.now(), f = requestAnimationFrame(l));
+  }, V = () => {
+    f !== 0 && (d(f), f = 0, C += Math.max(0, performance.now() - I));
+  }, N = () => {
+    V();
+    const c = r;
+    r = null, c == null || c();
+  }, be = () => {
+    !m || i !== "live" || (i = "losing", m.loseContext());
+  }, j = () => {
+    m && (i = "restoring", m.restoreContext());
+  }, D = () => {
+    if (!(L || M || E))
+      if (w || _) {
+        if (i === "losing" || i === "restoring") return;
+        if (i === "lost") {
+          j();
+          return;
+        }
+        Ae();
+      } else m && i === "live" ? (N(), be()) : V();
+  }, Se = (c) => {
+    c === w || L || (w = c, D());
+  }, H = (c) => {
+    var y;
+    c.preventDefault();
+    const t = i === "losing";
+    if (i = "lost", N(), t) {
+      D();
+      return;
+    }
+    E = !0, (y = e.onError) == null || y.call(e, "WebGL context was lost.");
+  }, Y = () => {
+    i = "live", D();
+  }, xe = () => {
+    x || (x = !0, n.addEventListener("webglcontextlost", H, !1), n.addEventListener("webglcontextrestored", Y, !1), !(typeof IntersectionObserver > "u") && (w = !1, S = new IntersectionObserver((c) => {
+      const t = c[c.length - 1];
+      t && Se(t.isIntersecting);
+    }, {
+      threshold: 0
+    }), S.observe(n)));
+  }, Ae = () => {
+    var re, oe, ae, ie, se;
+    if (L || M || E || b) return;
+    const c = v;
+    if (!c) return;
+    if (r) {
+      $();
+      return;
+    }
+    const t = ge();
+    if (!t) {
+      M = !0, (re = e.onError) == null || re.call(e, "WebGL is not available in this browser.");
+      return;
+    }
+    if (t.isContextLost()) {
+      j();
+      return;
+    }
+    const {
+      source: y,
+      uniforms: Fe
+    } = c, R = me(t, t.VERTEX_SHADER, De);
+    if (typeof R == "string") {
+      b = !0, (oe = e.onError) == null || oe.call(e, R);
+      return;
+    }
+    const T = me(t, t.FRAGMENT_SHADER, y);
+    if (typeof T == "string") {
+      t.deleteShader(R), b = !0, (ae = e.onError) == null || ae.call(e, T);
+      return;
+    }
+    const g = t.createProgram();
+    if (!g) {
+      t.deleteShader(R), t.deleteShader(T), b = !0, (ie = e.onError) == null || ie.call(e, "Could not create a WebGL program.");
+      return;
+    }
+    if (t.attachShader(g, R), t.attachShader(g, T), t.linkProgram(g), !t.getProgramParameter(g, t.LINK_STATUS)) {
+      const h = t.getProgramInfoLog(g) ?? "Shader program failed to link.";
+      t.deleteProgram(g), t.deleteShader(R), t.deleteShader(T), b = !0, (se = e.onError) == null || se.call(e, h);
+      return;
+    }
+    t.useProgram(g);
+    const K = t.createBuffer();
+    t.bindBuffer(t.ARRAY_BUFFER, K), t.bufferData(t.ARRAY_BUFFER, new Float32Array([-1, -1, 0, 1, -1, 0, -1, 1, 0, 1, 1, 0]), t.STATIC_DRAW);
+    const X = t.getAttribLocation(g, "aVertexPosition");
+    t.enableVertexAttribArray(X), t.vertexAttribPointer(X, 3, t.FLOAT, !1, 0, 0), t.enable(t.BLEND), t.blendFunc(t.ONE, t.ONE_MINUS_SRC_ALPHA);
+    const O = (h) => t.getUniformLocation(g, h), Z = O("iTime"), J = O("iResolution"), Q = O("iMouse"), p = O("iFrame"), ee = O("iDate"), Ee = Object.keys(Fe).map((h) => [h, O(h)]), B = [0, 0, 0, 0], te = (h) => {
+      const A = n.getBoundingClientRect();
+      B[0] = h.clientX - A.left, B[1] = A.height - (h.clientY - A.top);
+    };
+    n.addEventListener("pointermove", te, {
+      passive: !0
+    });
+    const q = () => {
+      const h = globalThis.devicePixelRatio ?? 1, A = Math.max(1, Math.floor(n.clientWidth * h)), k = Math.max(1, Math.floor(n.clientHeight * h));
+      (n.width !== A || n.height !== k) && (n.width = A, n.height = k, t.viewport(0, 0, A, k));
+    }, P = typeof ResizeObserver < "u" ? new ResizeObserver(q) : void 0;
+    P == null || P.observe(n), q();
+    const ne = (h) => {
+      var k;
+      if (E || t.isContextLost()) return;
+      q();
+      const A = Math.max(0, (C + (h - I)) / 1e3);
+      if (Z && t.uniform1f(Z, A), J && t.uniform2fv(J, [n.width, n.height]), Q && t.uniform4fv(Q, B), p && t.uniform1i(p, W), ee) {
+        const F = /* @__PURE__ */ new Date();
+        t.uniform4fv(ee, [F.getFullYear(), F.getMonth(), F.getDate(), F.getHours() * 3600 + F.getMinutes() * 60 + F.getSeconds()]);
+      }
+      for (const [F, ce] of Ee) {
+        const fe = (k = e.uniforms) == null ? void 0 : k[F];
+        fe && ce && Be(t, ce, fe);
+      }
+      t.clearColor(0, 0, 0, 0), t.clear(t.COLOR_BUFFER_BIT), t.drawArrays(t.TRIANGLE_STRIP, 0, 4), W++, f = requestAnimationFrame(ne);
+    };
+    r = () => {
+      l = null, P == null || P.disconnect(), n.removeEventListener("pointermove", te), t.deleteProgram(g), t.deleteShader(R), t.deleteShader(T), t.deleteBuffer(K);
+    }, l = ne, $();
+  };
+  G(() => {
+    L = !0, S == null || S.disconnect(), x && (n.removeEventListener("webglcontextlost", H), n.removeEventListener("webglcontextrestored", Y)), N(), m && i === "live" && m.loseContext();
+  });
+  const Me = U(() => e.animateWhenNotVisible ?? !1);
+  return ue(() => {
+    _ = Me(), D();
+  }), ue(() => {
+    const c = a(), t = s();
+    o();
+    const y = ve(() => e.uniforms ?? {});
+    v = {
+      source: Ne(c, y, t),
+      uniforms: y
+    }, b = !1, xe(), D(), G(N);
+  }), Le(_e, we("class", ye(Re("block h-full w-full", e.class), !0), !1));
+}
+function z(e, n, o, a) {
+  const s = (r) => 3 * (1 - r) * (1 - r) * r * e + 3 * (1 - r) * r * r * o + r * r * r, i = (r) => 3 * (1 - r) * (1 - r) * r * n + 3 * (1 - r) * r * r * a + r * r * r, u = (r) => 3 * (1 - r) * (1 - r) * e + 6 * (1 - r) * r * (o - e) + 3 * r * r * (1 - o);
+  function m(r) {
+    let l = 0, f = 1;
+    for (let d = 0; d < 30; d++) {
+      const v = (l + f) / 2;
+      s(v) < r ? l = v : f = v;
+    }
+    return (l + f) / 2;
+  }
+  return (r) => {
+    if (r <= 0) return 0;
+    if (r >= 1) return 1;
+    let l = r;
+    for (let f = 0; f < 8; f++) {
+      const d = u(l);
+      if (Math.abs(d) < 1e-6) return i(m(r));
+      const v = l - (s(l) - r) / d;
+      if (v <= 0 || v >= 1) return i(m(r));
+      l = v;
+    }
+    return i(l);
+  };
+}
+const qe = {
+  linear: (e) => Math.min(1, Math.max(0, e)),
+  easeIn: z(0.42, 0, 1, 1),
+  easeOut: z(0, 0, 0.58, 1),
+  easeInOut: z(0.42, 0, 0.58, 1)
+};
+function ze(e, n) {
+  e = Math.max(0, e);
+  const o = Math.max(0.05, 1 - Math.min(0.95, n)), a = 10, s = a * Math.sqrt(Math.max(0, 1 - o * o));
+  return 1 - Math.exp(-o * a * e) * (Math.cos(s * e) + o * a / (s || 1) * Math.sin(s * e));
+}
+function de(e) {
+  return "type" in e && e.type === "spring";
+}
+function je(e) {
+  const [n, o] = le(e), [a, s] = le(!1);
+  let i = 0, u = !1;
+  const m = typeof cancelAnimationFrame == "function" ? cancelAnimationFrame.bind(globalThis) : () => {
+  }, r = () => {
+    i && m(i), i = 0;
+  };
+  G(() => {
+    u = !0, r(), s(!1);
+  });
+  function l(f, d) {
+    if (r(), u) return;
+    const v = Array.isArray(f), [b, M] = v ? f : [ve(n), f];
+    if (!d || !de(d) && d.duration === 0) {
+      s(!1), o(v ? b : M);
+      return;
+    }
+    const E = d.duration * 1e3;
+    if (E <= 0) {
+      s(!1), o(M);
+      return;
+    }
+    if (typeof requestAnimationFrame > "u") {
+      s(!1), o(M);
+      return;
+    }
+    const L = de(d) ? (C) => ze(C, d.bounce) : qe[d.ease ?? "easeOut"];
+    let S = b, x = M;
+    v && o(b);
+    let w = performance.now();
+    const _ = (C) => {
+      const I = Math.min(1, (C - w) / E);
+      if (o(S + (x - S) * L(I)), I < 1) {
+        i = requestAnimationFrame(_);
+        return;
+      }
+      if (!v) {
+        o(x), i = 0, s(!1);
+        return;
+      }
+      o(x), [S, x] = [x, S], w = performance.now(), i = requestAnimationFrame(_);
+    };
+    s(!0), i = requestAnimationFrame(_);
+  }
+  return { value: n, animating: a, to: l };
+}
+export {
+  Ce as D,
+  Ve as S,
+  je as c,
+  Ie as h
+};