@elabs-ai/components-ui 4.2.0 → 5.1.0

package/dist/chunk-IVEDMK5U.js

@@ -0,0 +1,61 @@
+"use client";
+import {
+  cn
+} from "./chunk-FXWWDMMP.js";
+
+// src/components/scroll-area/scroll-area.tsx
+import { forwardRef } from "react";
+import * as ScrollAreaPrimitive from "@radix-ui/react-scroll-area";
+import { jsx, jsxs } from "react/jsx-runtime";
+var ScrollArea = forwardRef(
+  function ScrollArea2({ className, children, viewportProps, ...props }, ref) {
+    return /* @__PURE__ */ jsxs(
+      ScrollAreaPrimitive.Root,
+      {
+        ref,
+        className: cn("relative overflow-hidden", className),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsx(
+            ScrollAreaPrimitive.Viewport,
+            {
+              ...viewportProps,
+              className: cn(
+                "size-full rounded-[inherit]",
+                // A viewport made focusable needs a visible ring, like every other tab stop.
+                viewportProps?.tabIndex !== void 0 && "focus-ring-inset",
+                viewportProps?.className
+              ),
+              children
+            }
+          ),
+          /* @__PURE__ */ jsx(ScrollBar, {}),
+          /* @__PURE__ */ jsx(ScrollAreaPrimitive.Corner, {})
+        ]
+      }
+    );
+  }
+);
+var ScrollBar = forwardRef(function ScrollBar2({ className, orientation = "vertical", ...props }, ref) {
+  return /* @__PURE__ */ jsx(
+    ScrollAreaPrimitive.ScrollAreaScrollbar,
+    {
+      ref,
+      orientation,
+      className: cn(
+        "flex touch-none select-none transition-colors",
+        orientation === "vertical" && "h-full w-2.5 border-s border-s-transparent p-px",
+        orientation === "horizontal" && "h-2.5 flex-col border-t border-t-transparent p-px",
+        className
+      ),
+      ...props,
+      children: /* @__PURE__ */ jsx(ScrollAreaPrimitive.ScrollAreaThumb, { className: "relative flex-1 rounded-full bg-border" })
+    }
+  );
+});
+
+export {
+  ScrollArea,
+  ScrollBar
+};
+//# sourceMappingURL=chunk-IVEDMK5U.js.map

package/dist/chunk-IVEDMK5U.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/scroll-area/scroll-area.tsx"],"sourcesContent":["import { forwardRef, type ComponentPropsWithoutRef, type ElementRef } from \"react\";\nimport * as ScrollAreaPrimitive from \"@radix-ui/react-scroll-area\";\nimport { cn } from \"../../lib/cn\";\n\nexport interface ScrollAreaProps extends ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.Root> {\n  /**\n   * Props for the scrolling VIEWPORT — the element that actually overflows, which is\n   * otherwise unreachable from the outside.\n   *\n   * The viewport is deliberately NOT focusable by default: when the content inside it is\n   * focusable (a list of links, rows of buttons) a keyboard user reaches the overflow by\n   * tabbing through it, and a tab stop on the viewport would be noise. When the content is\n   * plain text or non-focusable rows, that same user cannot scroll it at all — axe's\n   * `scrollable-region-focusable` is the gate that catches it. Make it a named tab stop the\n   * way `ChartFrame` does for its scrolling body:\n   *\n   * ```tsx\n   * viewportProps={{ tabIndex: 0, role: \"group\", \"aria-label\": \"Scrollable list\" }}\n   * ```\n   *\n   * `role=\"group\"` rather than `\"region\"`: ARIA 1.2 forbids `aria-label` on a generic\n   * element, and `group` gives the name a host without adding a landmark.\n   */\n  viewportProps?: ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.Viewport>;\n}\n\nexport const ScrollArea = forwardRef<ElementRef<typeof ScrollAreaPrimitive.Root>, ScrollAreaProps>(\n  function ScrollArea({ className, children, viewportProps, ...props }, ref) {\n    return (\n      <ScrollAreaPrimitive.Root\n        ref={ref}\n        className={cn(\"relative overflow-hidden\", className)}\n        {...props}\n      >\n        <ScrollAreaPrimitive.Viewport\n          {...viewportProps}\n          className={cn(\n            \"size-full rounded-[inherit]\",\n            // A viewport made focusable needs a visible ring, like every other tab stop.\n            viewportProps?.tabIndex !== undefined && \"focus-ring-inset\",\n            viewportProps?.className,\n          )}\n        >\n          {children}\n        </ScrollAreaPrimitive.Viewport>\n        <ScrollBar />\n        <ScrollAreaPrimitive.Corner />\n      </ScrollAreaPrimitive.Root>\n    );\n  },\n);\n\nexport const ScrollBar = forwardRef<\n  ElementRef<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>,\n  ComponentPropsWithoutRef<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>\n>(function ScrollBar({ className, orientation = \"vertical\", ...props }, ref) {\n  return (\n    <ScrollAreaPrimitive.ScrollAreaScrollbar\n      ref={ref}\n      orientation={orientation}\n      className={cn(\n        \"flex touch-none select-none transition-colors\",\n        orientation === \"vertical\" && \"h-full w-2.5 border-s border-s-transparent p-px\",\n        orientation === \"horizontal\" && \"h-2.5 flex-col border-t border-t-transparent p-px\",\n        className,\n      )}\n      {...props}\n    >\n      <ScrollAreaPrimitive.ScrollAreaThumb className=\"relative flex-1 rounded-full bg-border\" />\n    </ScrollAreaPrimitive.ScrollAreaScrollbar>\n  );\n});\n"],"mappings":";;;;;;AAAA,SAAS,kBAAkE;AAC3E,YAAY,yBAAyB;AA4B/B,SAKE,KALF;AAHC,IAAM,aAAa;AAAA,EACxB,SAASA,YAAW,EAAE,WAAW,UAAU,eAAe,GAAG,MAAM,GAAG,KAAK;AACzE,WACE;AAAA,MAAqB;AAAA,MAApB;AAAA,QACC;AAAA,QACA,WAAW,GAAG,4BAA4B,SAAS;AAAA,QAClD,GAAG;AAAA,QAEJ;AAAA;AAAA,YAAqB;AAAA,YAApB;AAAA,cACE,GAAG;AAAA,cACJ,WAAW;AAAA,gBACT;AAAA;AAAA,gBAEA,eAAe,aAAa,UAAa;AAAA,gBACzC,eAAe;AAAA,cACjB;AAAA,cAEC;AAAA;AAAA,UACH;AAAA,UACA,oBAAC,aAAU;AAAA,UACX,oBAAqB,4BAApB,EAA2B;AAAA;AAAA;AAAA,IAC9B;AAAA,EAEJ;AACF;AAEO,IAAM,YAAY,WAGvB,SAASC,WAAU,EAAE,WAAW,cAAc,YAAY,GAAG,MAAM,GAAG,KAAK;AAC3E,SACE;AAAA,IAAqB;AAAA,IAApB;AAAA,MACC;AAAA,MACA;AAAA,MACA,WAAW;AAAA,QACT;AAAA,QACA,gBAAgB,cAAc;AAAA,QAC9B,gBAAgB,gBAAgB;AAAA,QAChC;AAAA,MACF;AAAA,MACC,GAAG;AAAA,MAEJ,8BAAqB,qCAApB,EAAoC,WAAU,0CAAyC;AAAA;AAAA,EAC1F;AAEJ,CAAC;","names":["ScrollArea","ScrollBar"]}

package/dist/chunk-IY23F2Y5.js

@@ -0,0 +1,2 @@
+"use client";
+//# sourceMappingURL=chunk-IY23F2Y5.js.map

package/dist/chunk-IY23F2Y5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-JCRBDA66.js

@@ -0,0 +1,2 @@
+"use client";
+//# sourceMappingURL=chunk-JCRBDA66.js.map

package/dist/chunk-JCRBDA66.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-JTY3REOB.js

@@ -0,0 +1,76 @@
+"use client";
+import {
+  Spinner
+} from "./chunk-W7OIVERI.js";
+import {
+  useLocale
+} from "./chunk-EJQYE4MY.js";
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle
+} from "./chunk-SLDJYJEG.js";
+import {
+  buttonVariants
+} from "./chunk-C5QBV5RE.js";
+import {
+  cn
+} from "./chunk-FXWWDMMP.js";
+
+// src/components/confirm-dialog/confirm-dialog.tsx
+import "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function ConfirmDialog({
+  open,
+  onOpenChange,
+  title,
+  description,
+  confirmLabel,
+  cancelLabel,
+  onConfirm,
+  onCancel,
+  tone = "default",
+  loading = false,
+  children,
+  className
+}) {
+  const { t } = useLocale();
+  function handleConfirm(event) {
+    event.preventDefault();
+    if (loading) return;
+    onConfirm();
+  }
+  return /* @__PURE__ */ jsx(AlertDialog, { open, onOpenChange, children: /* @__PURE__ */ jsxs(AlertDialogContent, { "data-slot": "confirm-dialog", className, children: [
+    /* @__PURE__ */ jsxs(AlertDialogHeader, { children: [
+      /* @__PURE__ */ jsx(AlertDialogTitle, { "data-slot": "confirm-dialog-title", children: title }),
+      /* @__PURE__ */ jsx(AlertDialogDescription, { "data-slot": "confirm-dialog-description", children: description })
+    ] }),
+    children,
+    /* @__PURE__ */ jsxs(AlertDialogFooter, { children: [
+      /* @__PURE__ */ jsx(AlertDialogCancel, { "data-slot": "confirm-dialog-cancel", onClick: onCancel, children: cancelLabel ?? t("ui.confirmDialog.cancel") }),
+      /* @__PURE__ */ jsxs(
+        AlertDialogAction,
+        {
+          "data-slot": "confirm-dialog-confirm",
+          className: cn(tone === "destructive" && buttonVariants({ variant: "destructive" })),
+          "aria-busy": loading || void 0,
+          onClick: handleConfirm,
+          children: [
+            loading ? /* @__PURE__ */ jsx(Spinner, { className: "text-current", label: t("loading") }) : null,
+            confirmLabel ?? t("ui.confirmDialog.confirm")
+          ]
+        }
+      )
+    ] })
+  ] }) });
+}
+
+export {
+  ConfirmDialog
+};
+//# sourceMappingURL=chunk-JTY3REOB.js.map

package/dist/chunk-JTY3REOB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/confirm-dialog/confirm-dialog.tsx"],"sourcesContent":["\"use client\";\n\nimport { type MouseEvent, type ReactNode } from \"react\";\nimport {\n  AlertDialog,\n  AlertDialogAction,\n  AlertDialogCancel,\n  AlertDialogContent,\n  AlertDialogDescription,\n  AlertDialogFooter,\n  AlertDialogHeader,\n  AlertDialogTitle,\n} from \"../alert-dialog\";\nimport { buttonVariants } from \"../button\";\nimport { cn } from \"../../lib/cn\";\nimport { useLocale } from \"../locale-provider\";\nimport { Spinner } from \"../spinner\";\n\nexport interface ConfirmDialogProps {\n  /** Controlled open state — the app owns it. */\n  open: boolean;\n  /** Fires on cancel, Escape, and any other Radix dismissal. */\n  onOpenChange: (open: boolean) => void;\n  /** What is about to happen, as a question or a statement. */\n  title: ReactNode;\n  /**\n   * The consequence, spelled out. **Required**: `AlertDialogContent` is\n   * inaccessible to screen-reader users without a description (Radix warns), and\n   * a confirmation whose only text is its title cannot state what is at stake.\n   */\n  description: ReactNode;\n  /**\n   * The confirm action's label. States the CONSEQUENCE (\"Delete skill\"), never\n   * \"OK\" — a label that names the outcome is the last chance to catch a mistake.\n   * Defaults to a generic \"Confirm\", which you should almost always replace.\n   */\n  confirmLabel?: ReactNode;\n  /** The safe action's label. Defaults to \"Cancel\". */\n  cancelLabel?: ReactNode;\n  /** Runs when the confirm action is activated. */\n  onConfirm: () => void;\n  /** Runs when the safe action is activated (in addition to `onOpenChange`). */\n  onCancel?: () => void;\n  /** Visual tone of the CONFIRM action only. The dialog chrome never changes. */\n  tone?: \"default\" | \"destructive\";\n  /**\n   * The confirm request is in flight: the action swaps its label for a spinner\n   * and reports `aria-busy`. It deliberately stays ENABLED\n   * (`.claude/rules/interaction-guidelines.md`, Forms — a submit is never\n   * pre-disabled); repeat activations are ignored while it is set.\n   */\n  loading?: boolean;\n  /** Extra body content between the description and the actions. */\n  children?: ReactNode;\n  className?: string;\n}\n\n/**\n * A destructive/irreversible confirmation (#341).\n *\n * Built on `AlertDialog`, not `Dialog`, and that is the entire point of it\n * existing as a named component rather than a recipe: `AlertDialogContent`\n * prevents its own open-autofocus and focuses the mounted `AlertDialogCancel`\n * instead, so **initial focus lands on the safe action** — but only if a Cancel\n * is actually mounted, which a hand-rolled confirmation routinely forgets (and a\n * plain `Dialog` cannot do at all). `ConfirmDialog` always renders one, so the\n * wrong choice is unrepresentable. It also inherits `AlertDialog`'s refusal to\n * dismiss on an outside click.\n *\n * Cancel is FIRST in the DOM so assistive tech reads the safe action first;\n * `AlertDialogFooter`'s `flex-col-reverse sm:flex-row sm:justify-end` still\n * paints the confirm action bottom-right on every breakpoint.\n *\n * **Confirming does not close the dialog** — `onConfirm` fires and the app sets\n * `open={false}` when it is ready (immediately for a synchronous action, after\n * the request for an async one, which is what makes `loading` coherent).\n * Cancelling closes through `onOpenChange(false)` as usual.\n *\n * ```tsx\n * <ConfirmDialog\n *   open={open}\n *   onOpenChange={setOpen}\n *   tone=\"destructive\"\n *   title={`Delete ${skill.name}?`}\n *   description={`Removing it also deletes its ${skill.runs} saved runs. This cannot be undone.`}\n *   confirmLabel={`Delete ${skill.name}`}\n *   onConfirm={() => { deleteSkill(); setOpen(false); }}\n * />\n * ```\n */\nexport function ConfirmDialog({\n  open,\n  onOpenChange,\n  title,\n  description,\n  confirmLabel,\n  cancelLabel,\n  onConfirm,\n  onCancel,\n  tone = \"default\",\n  loading = false,\n  children,\n  className,\n}: ConfirmDialogProps) {\n  const { t } = useLocale();\n\n  function handleConfirm(event: MouseEvent<HTMLButtonElement>) {\n    // Radix's Action is a `Dialog.Close`; preventing the default stops it\n    // closing so the app stays in charge of `open` (and an in-flight request\n    // keeps its spinner on screen).\n    event.preventDefault();\n    if (loading) return;\n    onConfirm();\n  }\n\n  return (\n    <AlertDialog open={open} onOpenChange={onOpenChange}>\n      <AlertDialogContent data-slot=\"confirm-dialog\" className={className}>\n        <AlertDialogHeader>\n          <AlertDialogTitle data-slot=\"confirm-dialog-title\">{title}</AlertDialogTitle>\n          <AlertDialogDescription data-slot=\"confirm-dialog-description\">\n            {description}\n          </AlertDialogDescription>\n        </AlertDialogHeader>\n        {children}\n        <AlertDialogFooter>\n          <AlertDialogCancel data-slot=\"confirm-dialog-cancel\" onClick={onCancel}>\n            {cancelLabel ?? t(\"ui.confirmDialog.cancel\")}\n          </AlertDialogCancel>\n          <AlertDialogAction\n            data-slot=\"confirm-dialog-confirm\"\n            className={cn(tone === \"destructive\" && buttonVariants({ variant: \"destructive\" }))}\n            aria-busy={loading || undefined}\n            onClick={handleConfirm}\n          >\n            {/* `text-current` so the spinner inherits the action's foreground\n                token instead of `Spinner`'s muted default, which would drop\n                below 3:1 on a filled button. */}\n            {loading ? <Spinner className=\"text-current\" label={t(\"loading\")} /> : null}\n            {confirmLabel ?? t(\"ui.confirmDialog.confirm\")}\n          </AlertDialogAction>\n        </AlertDialogFooter>\n      </AlertDialogContent>\n    </AlertDialog>\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,OAAgD;AAoHxC,SACE,KADF;AA5BD,SAAS,cAAc;AAAA,EAC5B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA,OAAO;AAAA,EACP,UAAU;AAAA,EACV;AAAA,EACA;AACF,GAAuB;AACrB,QAAM,EAAE,EAAE,IAAI,UAAU;AAExB,WAAS,cAAc,OAAsC;AAI3D,UAAM,eAAe;AACrB,QAAI,QAAS;AACb,cAAU;AAAA,EACZ;AAEA,SACE,oBAAC,eAAY,MAAY,cACvB,+BAAC,sBAAmB,aAAU,kBAAiB,WAC7C;AAAA,yBAAC,qBACC;AAAA,0BAAC,oBAAiB,aAAU,wBAAwB,iBAAM;AAAA,MAC1D,oBAAC,0BAAuB,aAAU,8BAC/B,uBACH;AAAA,OACF;AAAA,IACC;AAAA,IACD,qBAAC,qBACC;AAAA,0BAAC,qBAAkB,aAAU,yBAAwB,SAAS,UAC3D,yBAAe,EAAE,yBAAyB,GAC7C;AAAA,MACA;AAAA,QAAC;AAAA;AAAA,UACC,aAAU;AAAA,UACV,WAAW,GAAG,SAAS,iBAAiB,eAAe,EAAE,SAAS,cAAc,CAAC,CAAC;AAAA,UAClF,aAAW,WAAW;AAAA,UACtB,SAAS;AAAA,UAKR;AAAA,sBAAU,oBAAC,WAAQ,WAAU,gBAAe,OAAO,EAAE,SAAS,GAAG,IAAK;AAAA,YACtE,gBAAgB,EAAE,0BAA0B;AAAA;AAAA;AAAA,MAC/C;AAAA,OACF;AAAA,KACF,GACF;AAEJ;","names":[]}

package/dist/chunk-JVCIAEFT.js

@@ -0,0 +1,68 @@
+"use client";
+import {
+  cn
+} from "./chunk-FXWWDMMP.js";
+
+// src/components/collapsible-panel/use-collapsible-panel.ts
+import { useCallback, useMemo, useState } from "react";
+var DEFAULT_WIDTH_CLASSNAME = "w-(--collapsible-panel-width)";
+var DEFAULT_SPACER_COLLAPSED_CLASSNAME = "group-data-[state=collapsed]:w-0";
+var DEFAULT_CONTAINER_SLIDE_CLASSNAMES = {
+  left: "left-0 group-data-[state=collapsed]:left-[calc(var(--collapsible-panel-width)*-1)]",
+  right: "right-0 group-data-[state=collapsed]:right-[calc(var(--collapsible-panel-width)*-1)]"
+};
+function useCollapsiblePanel({
+  side = "left",
+  open: openProp,
+  defaultOpen = true,
+  onOpenChange,
+  widthClassName = DEFAULT_WIDTH_CLASSNAME,
+  spacerCollapsedClassName = DEFAULT_SPACER_COLLAPSED_CLASSNAME,
+  containerSlideClassNames = DEFAULT_CONTAINER_SLIDE_CLASSNAMES,
+  containerPosition = "viewport"
+} = {}) {
+  const [uncontrolledOpen, setUncontrolledOpen] = useState(defaultOpen);
+  const isControlled = openProp !== void 0;
+  const open = isControlled ? openProp : uncontrolledOpen;
+  const setOpen = useCallback(
+    (value) => {
+      const next = typeof value === "function" ? value(open) : value;
+      if (!isControlled) setUncontrolledOpen(next);
+      onOpenChange?.(next);
+    },
+    [isControlled, onOpenChange, open]
+  );
+  const toggle = useCallback(() => setOpen((o) => !o), [setOpen]);
+  const state = open ? "expanded" : "collapsed";
+  const spacerClassName = useMemo(
+    () => cn(
+      "relative",
+      widthClassName,
+      "bg-transparent transition-[width] duration-base ease-linear",
+      spacerCollapsedClassName
+    ),
+    [spacerCollapsedClassName, widthClassName]
+  );
+  const containerClassName = useMemo(
+    () => cn(
+      containerPosition === "inset" ? "absolute inset-y-0 z-10 hidden h-full" : "fixed inset-y-0 z-10 hidden h-svh",
+      widthClassName,
+      "transition-[left,right,width] duration-base ease-linear md:flex",
+      containerSlideClassNames[side]
+    ),
+    [containerPosition, containerSlideClassNames, side, widthClassName]
+  );
+  const attrs = useMemo(
+    () => ({ "data-state": state, "data-side": side }),
+    [side, state]
+  );
+  return useMemo(
+    () => ({ open, state, side, setOpen, toggle, attrs, spacerClassName, containerClassName }),
+    [open, state, side, setOpen, toggle, attrs, spacerClassName, containerClassName]
+  );
+}
+
+export {
+  useCollapsiblePanel
+};
+//# sourceMappingURL=chunk-JVCIAEFT.js.map

package/dist/chunk-JVCIAEFT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/collapsible-panel/use-collapsible-panel.ts"],"sourcesContent":["\"use client\";\n\n/**\n * useCollapsiblePanel — THE canonical collapsing-panel mechanism (#190,\n * research 09 §B.2/§E.1).\n *\n * Extracted from Sidebar's collapse (sidebar.tsx): an always-mounted,\n * two-element width tween — a gap SPACER that reserves/releases the inline\n * width (`transition-[width] duration-base ease-linear`, collapsing to `w-0`)\n * and a fixed CONTAINER that slides off-screen\n * (`transition-[left,right,width] duration-base ease-linear`). `duration-base`\n * is the gated `--t-base` motion token, so reduced-motion is honoured for free\n * (pure CSS — the shared base stays motion-free, research 09 decision 2).\n *\n * The hook owns:\n *   - the state machine — controlled + uncontrolled `open` per\n *     component-api.md (`isControlled = open !== undefined`, never flips\n *     modes) with `setOpen`/`toggle`;\n *   - the `data-state`/`data-side` attrs for the group element;\n *   - the assembly of the two class fragments in the canonical order.\n *\n * Width / collapse-trigger / slide utilities are passed as LITERAL class\n * strings by the consumer (Tailwind's scanner must see each literal in\n * source — a template-interpolated class is never generated), with\n * state-keyed defaults for a generic panel. Sidebar passes its\n * `--sidebar-width` + `group-data-[collapsible=offcanvas]` literals and gets\n * back its exact original fragments (the byte-identical re-point).\n */\nimport { useCallback, useMemo, useState } from \"react\";\nimport { cn } from \"../../lib/cn\";\n\nexport type CollapsiblePanelSide = \"left\" | \"right\";\nexport type CollapsiblePanelState = \"expanded\" | \"collapsed\";\n/**\n * Where the CONTAINER fragment positions itself. `\"viewport\"` (default) pins\n * to the viewport edge (`fixed`) — Sidebar's original mechanism, byte-\n * identical to pre-#432 output. `\"inset\"` pins to the panel's OWN nearest\n * `relative` ancestor instead (`absolute`) — for a panel nested inside\n * another `fixed`-to-viewport element (e.g. a `SideDock` inside a Sidebar's\n * `SidebarInset`), so the two never race for the same viewport edge (#432).\n * The consumer must give that ancestor `relative` itself; `SideDock` does\n * this via its own `containerPosition` prop.\n */\nexport type CollapsiblePanelContainerPosition = \"viewport\" | \"inset\";\n\n/**\n * State-keyed defaults for a generic panel: the consumer wraps the panel in a\n * `group` element carrying `attrs` and sets `--collapsible-panel-width` on it.\n */\nconst DEFAULT_WIDTH_CLASSNAME = \"w-(--collapsible-panel-width)\";\nconst DEFAULT_SPACER_COLLAPSED_CLASSNAME = \"group-data-[state=collapsed]:w-0\";\nconst DEFAULT_CONTAINER_SLIDE_CLASSNAMES: Record<CollapsiblePanelSide, string> = {\n  left: \"left-0 group-data-[state=collapsed]:left-[calc(var(--collapsible-panel-width)*-1)]\",\n  right: \"right-0 group-data-[state=collapsed]:right-[calc(var(--collapsible-panel-width)*-1)]\",\n};\n\nexport interface UseCollapsiblePanelOptions {\n  /** Which edge the panel lives on. Default `\"left\"`. */\n  side?: CollapsiblePanelSide;\n  /** Controlled open state (`isControlled = open !== undefined`). */\n  open?: boolean;\n  /** Uncontrolled initial open state. Default `true`. */\n  defaultOpen?: boolean;\n  /** Called with the next open state on `setOpen`/`toggle`. */\n  onOpenChange?: (open: boolean) => void;\n  /**\n   * Literal expanded-width utility (e.g. `\"w-(--sidebar-width)\"`). Must be a\n   * literal in the consumer's source so Tailwind generates it.\n   */\n  widthClassName?: string;\n  /**\n   * Literal collapsed-state utility for the gap spacer (e.g.\n   * `\"group-data-[collapsible=offcanvas]:w-0\"`).\n   */\n  spacerCollapsedClassName?: string;\n  /**\n   * Literal off-screen slide utilities for the fixed container, keyed by side\n   * (e.g. `left: \"left-0 group-data-[collapsible=offcanvas]:left-[calc(var(--sidebar-width)*-1)]\"`).\n   */\n  containerSlideClassNames?: Record<CollapsiblePanelSide, string>;\n  /**\n   * `\"viewport\"` (default, byte-identical to pre-#432) or `\"inset\"` — see\n   * `CollapsiblePanelContainerPosition`.\n   */\n  containerPosition?: CollapsiblePanelContainerPosition;\n}\n\n/** Data attributes for the panel's `group` element. */\nexport interface CollapsiblePanelAttrs {\n  \"data-state\": CollapsiblePanelState;\n  \"data-side\": CollapsiblePanelSide;\n}\n\nexport interface UseCollapsiblePanelReturn {\n  /** Resolved open state (controlled prop wins). */\n  open: boolean;\n  /** `\"expanded\"` when open, `\"collapsed\"` when closed. */\n  state: CollapsiblePanelState;\n  side: CollapsiblePanelSide;\n  /** Set the open state (accepts a value or an updater fn). */\n  setOpen: (open: boolean | ((open: boolean) => boolean)) => void;\n  toggle: () => void;\n  /** `data-state`/`data-side` for the group element wrapping both fragments. */\n  attrs: CollapsiblePanelAttrs;\n  /** The gap-spacer fragment: reserves/releases the inline width. */\n  spacerClassName: string;\n  /** The fixed-container fragment: slides the panel off-screen. */\n  containerClassName: string;\n}\n\nexport function useCollapsiblePanel({\n  side = \"left\",\n  open: openProp,\n  defaultOpen = true,\n  onOpenChange,\n  widthClassName = DEFAULT_WIDTH_CLASSNAME,\n  spacerCollapsedClassName = DEFAULT_SPACER_COLLAPSED_CLASSNAME,\n  containerSlideClassNames = DEFAULT_CONTAINER_SLIDE_CLASSNAMES,\n  containerPosition = \"viewport\",\n}: UseCollapsiblePanelOptions = {}): UseCollapsiblePanelReturn {\n  // Controlled/uncontrolled per component-api.md: controlled iff the `open`\n  // prop is provided; the mode never flips mid-life.\n  const [uncontrolledOpen, setUncontrolledOpen] = useState(defaultOpen);\n  const isControlled = openProp !== undefined;\n  const open = isControlled ? openProp : uncontrolledOpen;\n\n  const setOpen = useCallback(\n    (value: boolean | ((open: boolean) => boolean)) => {\n      const next = typeof value === \"function\" ? value(open) : value;\n      if (!isControlled) setUncontrolledOpen(next);\n      onOpenChange?.(next);\n    },\n    [isControlled, onOpenChange, open],\n  );\n\n  const toggle = useCallback(() => setOpen((o) => !o), [setOpen]);\n\n  const state: CollapsiblePanelState = open ? \"expanded\" : \"collapsed\";\n\n  // The two class fragments — the Sidebar collapse mechanism verbatim\n  // (research 09 §A.1): assembly order is part of the contract (it is what\n  // keeps Sidebar's emitted className strings byte-identical).\n  const spacerClassName = useMemo(\n    () =>\n      cn(\n        \"relative\",\n        widthClassName,\n        \"bg-transparent transition-[width] duration-base ease-linear\",\n        spacerCollapsedClassName,\n      ),\n    [spacerCollapsedClassName, widthClassName],\n  );\n  const containerClassName = useMemo(\n    () =>\n      cn(\n        containerPosition === \"inset\"\n          ? \"absolute inset-y-0 z-10 hidden h-full\"\n          : \"fixed inset-y-0 z-10 hidden h-svh\",\n        widthClassName,\n        \"transition-[left,right,width] duration-base ease-linear md:flex\",\n        containerSlideClassNames[side],\n      ),\n    [containerPosition, containerSlideClassNames, side, widthClassName],\n  );\n\n  const attrs = useMemo<CollapsiblePanelAttrs>(\n    () => ({ \"data-state\": state, \"data-side\": side }),\n    [side, state],\n  );\n\n  return useMemo(\n    () => ({ open, state, side, setOpen, toggle, attrs, spacerClassName, containerClassName }),\n    [open, state, side, setOpen, toggle, attrs, spacerClassName, containerClassName],\n  );\n}\n"],"mappings":";;;;;;AA4BA,SAAS,aAAa,SAAS,gBAAgB;AAqB/C,IAAM,0BAA0B;AAChC,IAAM,qCAAqC;AAC3C,IAAM,qCAA2E;AAAA,EAC/E,MAAM;AAAA,EACN,OAAO;AACT;AAwDO,SAAS,oBAAoB;AAAA,EAClC,OAAO;AAAA,EACP,MAAM;AAAA,EACN,cAAc;AAAA,EACd;AAAA,EACA,iBAAiB;AAAA,EACjB,2BAA2B;AAAA,EAC3B,2BAA2B;AAAA,EAC3B,oBAAoB;AACtB,IAAgC,CAAC,GAA8B;AAG7D,QAAM,CAAC,kBAAkB,mBAAmB,IAAI,SAAS,WAAW;AACpE,QAAM,eAAe,aAAa;AAClC,QAAM,OAAO,eAAe,WAAW;AAEvC,QAAM,UAAU;AAAA,IACd,CAAC,UAAkD;AACjD,YAAM,OAAO,OAAO,UAAU,aAAa,MAAM,IAAI,IAAI;AACzD,UAAI,CAAC,aAAc,qBAAoB,IAAI;AAC3C,qBAAe,IAAI;AAAA,IACrB;AAAA,IACA,CAAC,cAAc,cAAc,IAAI;AAAA,EACnC;AAEA,QAAM,SAAS,YAAY,MAAM,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC;AAE9D,QAAM,QAA+B,OAAO,aAAa;AAKzD,QAAM,kBAAkB;AAAA,IACtB,MACE;AAAA,MACE;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AAAA,IACF,CAAC,0BAA0B,cAAc;AAAA,EAC3C;AACA,QAAM,qBAAqB;AAAA,IACzB,MACE;AAAA,MACE,sBAAsB,UAClB,0CACA;AAAA,MACJ;AAAA,MACA;AAAA,MACA,yBAAyB,IAAI;AAAA,IAC/B;AAAA,IACF,CAAC,mBAAmB,0BAA0B,MAAM,cAAc;AAAA,EACpE;AAEA,QAAM,QAAQ;AAAA,IACZ,OAAO,EAAE,cAAc,OAAO,aAAa,KAAK;AAAA,IAChD,CAAC,MAAM,KAAK;AAAA,EACd;AAEA,SAAO;AAAA,IACL,OAAO,EAAE,MAAM,OAAO,MAAM,SAAS,QAAQ,OAAO,iBAAiB,mBAAmB;AAAA,IACxF,CAAC,MAAM,OAAO,MAAM,SAAS,QAAQ,OAAO,iBAAiB,kBAAkB;AAAA,EACjF;AACF;","names":[]}

package/dist/chunk-JWWJ2Z5C.js

@@ -0,0 +1,2 @@
+"use client";
+//# sourceMappingURL=chunk-JWWJ2Z5C.js.map

package/dist/chunk-JWWJ2Z5C.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-K2GLXCTG.js

@@ -0,0 +1,2 @@
+"use client";
+//# sourceMappingURL=chunk-K2GLXCTG.js.map

package/dist/chunk-K2GLXCTG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-K4V2ELUZ.js

@@ -0,0 +1,36 @@
+"use client";
+import {
+  cn
+} from "./chunk-FXWWDMMP.js";
+
+// src/components/checkbox/checkbox.tsx
+import { forwardRef } from "react";
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+import { Check, Minus } from "lucide-react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var Checkbox = forwardRef(function Checkbox2({ className, ...props }, ref) {
+  return /* @__PURE__ */ jsx(
+    CheckboxPrimitive.Root,
+    {
+      ref,
+      "data-slot": "checkbox",
+      className: cn(
+        "peer size-4 shrink-0 rounded-sm border border-input shadow-sm transition-colors duration-fast ease-standard",
+        "focus-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background",
+        "disabled:cursor-not-allowed disabled:opacity-50",
+        "data-[state=checked]:border-primary data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground",
+        className
+      ),
+      ...props,
+      children: /* @__PURE__ */ jsxs(CheckboxPrimitive.Indicator, { className: "group flex items-center justify-center text-current animate-in zoom-in-95 fade-in duration-fast ease-entrance", children: [
+        /* @__PURE__ */ jsx(Check, { className: "size-3.5 group-data-[state=indeterminate]:hidden" }),
+        /* @__PURE__ */ jsx(Minus, { className: "hidden size-3.5 group-data-[state=indeterminate]:block" })
+      ] })
+    }
+  );
+});
+
+export {
+  Checkbox
+};
+//# sourceMappingURL=chunk-K4V2ELUZ.js.map

package/dist/chunk-K4V2ELUZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/checkbox/checkbox.tsx"],"sourcesContent":["import { forwardRef, type ComponentPropsWithoutRef, type ElementRef } from \"react\";\nimport * as CheckboxPrimitive from \"@radix-ui/react-checkbox\";\nimport { Check, Minus } from \"lucide-react\";\nimport { cn } from \"../../lib/cn\";\n\nexport const Checkbox = forwardRef<\n  ElementRef<typeof CheckboxPrimitive.Root>,\n  ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>\n>(function Checkbox({ className, ...props }, ref) {\n  return (\n    <CheckboxPrimitive.Root\n      ref={ref}\n      data-slot=\"checkbox\"\n      className={cn(\n        \"peer size-4 shrink-0 rounded-sm border border-input shadow-sm transition-colors duration-fast ease-standard\",\n        \"focus-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background\",\n        \"disabled:cursor-not-allowed disabled:opacity-50\",\n        \"data-[state=checked]:border-primary data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground\",\n        className,\n      )}\n      {...props}\n    >\n      {/*\n       * `group` + `data-[state]` (Radix sets `data-state` on the Indicator\n       * itself: \"checked\" | \"indeterminate\") swaps the glyph purely via CSS —\n       * `Minus` for indeterminate, `Check` for checked — so the two states\n       * are visually distinct instead of both drawing a checkmark (#348).\n       */}\n      <CheckboxPrimitive.Indicator className=\"group flex items-center justify-center text-current animate-in zoom-in-95 fade-in duration-fast ease-entrance\">\n        <Check className=\"size-3.5 group-data-[state=indeterminate]:hidden\" />\n        <Minus className=\"hidden size-3.5 group-data-[state=indeterminate]:block\" />\n      </CheckboxPrimitive.Indicator>\n    </CheckboxPrimitive.Root>\n  );\n});\n"],"mappings":";;;;;;AAAA,SAAS,kBAAkE;AAC3E,YAAY,uBAAuB;AACnC,SAAS,OAAO,aAAa;AA0BvB,SACE,KADF;AAvBC,IAAM,WAAW,WAGtB,SAASA,UAAS,EAAE,WAAW,GAAG,MAAM,GAAG,KAAK;AAChD,SACE;AAAA,IAAmB;AAAA,IAAlB;AAAA,MACC;AAAA,MACA,aAAU;AAAA,MACV,WAAW;AAAA,QACT;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF;AAAA,MACC,GAAG;AAAA,MAQJ,+BAAmB,6BAAlB,EAA4B,WAAU,iHACrC;AAAA,4BAAC,SAAM,WAAU,oDAAmD;AAAA,QACpE,oBAAC,SAAM,WAAU,0DAAyD;AAAA,SAC5E;AAAA;AAAA,EACF;AAEJ,CAAC;","names":["Checkbox"]}

package/dist/chunk-KAAJL2HA.js

@@ -0,0 +1,327 @@
+"use client";
+
+// src/lib/color-scale.ts
+var SEQUENTIAL_RAMP = [
+  "var(--chart-seq-1)",
+  "var(--chart-seq-2)",
+  "var(--chart-seq-3)",
+  "var(--chart-seq-4)",
+  "var(--chart-seq-5)",
+  "var(--chart-seq-6)",
+  "var(--chart-seq-7)"
+];
+var DIVERGING_RAMP = [
+  "var(--chart-div-neg-2)",
+  "var(--chart-div-neg-1)",
+  "var(--chart-div-mid)",
+  "var(--chart-div-pos-1)",
+  "var(--chart-div-pos-2)"
+];
+var CATEGORICAL_SET = Array.from({ length: 12 }, (_, i) => `var(--chart-${i + 1})`);
+var DEFAULT_STEPS = 5;
+var CONTINUOUS_METHODS = /* @__PURE__ */ new Set([
+  "linear",
+  "median",
+  "quartiles",
+  "quintiles",
+  "deciles",
+  "natural"
+]);
+var STEPPED_METHODS = /* @__PURE__ */ new Set([
+  "equidistant",
+  "rounded",
+  "quantile",
+  "jenks",
+  "custom"
+]);
+var QUANTILE_STOPS = {
+  median: 2,
+  quartiles: 4,
+  quintiles: 5,
+  deciles: 10
+};
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function clamp(value, lo, hi) {
+  return Math.min(hi, Math.max(lo, value));
+}
+function stepCount(steps, fallback) {
+  return isFiniteNumber(steps) && steps >= 1 ? Math.floor(steps) : fallback;
+}
+function spread(ramp, n) {
+  if (n <= 0) return [];
+  const last = ramp.length - 1;
+  if (n === 1) return [ramp[last]];
+  return Array.from({ length: n }, (_, i) => ramp[Math.round(i * last / (n - 1))]);
+}
+function quantileSorted(sorted, p) {
+  const h = (sorted.length - 1) * p;
+  const below = Math.floor(h);
+  const lower = sorted[below];
+  const upper = sorted[Math.min(sorted.length - 1, below + 1)];
+  return lower + (upper - lower) * (h - below);
+}
+function jenksBreaks(values, classes) {
+  const sorted = values.filter(isFiniteNumber).sort((a, b) => a - b);
+  if (sorted.length === 0) return [];
+  const xs = [];
+  const counts = [];
+  for (const value of sorted) {
+    if (xs.length > 0 && xs[xs.length - 1] === value) counts[counts.length - 1] += 1;
+    else {
+      xs.push(value);
+      counts.push(1);
+    }
+  }
+  const d = xs.length;
+  const first = xs[0];
+  const last = xs[d - 1];
+  const k = Math.min(stepCount(classes, 1), d);
+  if (k === 1) return [first, last];
+  const shift = xs[Math.floor(d / 2)];
+  const w = new Float64Array(d + 1);
+  const s1 = new Float64Array(d + 1);
+  const s2 = new Float64Array(d + 1);
+  for (let i = 0; i < d; i++) {
+    const x = xs[i] - shift;
+    const c = counts[i];
+    w[i + 1] = w[i] + c;
+    s1[i + 1] = s1[i] + c * x;
+    s2[i + 1] = s2[i] + c * x * x;
+  }
+  const ssd = (a, b) => {
+    const weight = w[b + 1] - w[a];
+    const sum = s1[b + 1] - s1[a];
+    return Math.max(0, s2[b + 1] - s2[a] - sum * sum / weight);
+  };
+  let previous = Float64Array.from({ length: d }, (_, i) => ssd(0, i));
+  const splits = [];
+  for (let j = 1; j < k; j++) {
+    const prior = previous;
+    const current = new Float64Array(d).fill(Number.POSITIVE_INFINITY);
+    const split = new Int32Array(d);
+    const solve = (lo, hi, optLo, optHi) => {
+      if (lo > hi) return;
+      const mid = lo + hi >> 1;
+      let best = Number.POSITIVE_INFINITY;
+      let bestM = Math.max(optLo, j);
+      for (let m = Math.max(optLo, j); m <= Math.min(mid, optHi); m++) {
+        const cost = prior[m - 1] + ssd(m, mid);
+        if (cost < best) {
+          best = cost;
+          bestM = m;
+        }
+      }
+      current[mid] = best;
+      split[mid] = bestM;
+      solve(lo, mid - 1, optLo, bestM);
+      solve(mid + 1, hi, bestM, optHi);
+    };
+    solve(j, d - 1, j, d - 1);
+    splits.push(split);
+    previous = current;
+  }
+  const uppers = [];
+  let end = d - 1;
+  for (let j = k - 1; j >= 1; j--) {
+    const start = splits[j - 1][end];
+    uppers.push(xs[start - 1]);
+    end = start - 1;
+  }
+  return [first, ...uppers.reverse(), last];
+}
+function interpolate(knots, x) {
+  const head = knots[0];
+  if (x <= head[0]) return head[1];
+  for (let i = 1; i < knots.length; i++) {
+    const [x1, y1] = knots[i];
+    if (x <= x1) {
+      const [x0, y0] = knots[i - 1];
+      return x1 === x0 ? y0 : y0 + (y1 - y0) * (x - x0) / (x1 - x0);
+    }
+  }
+  return knots[knots.length - 1][1];
+}
+function uniqueBreaks(breaks) {
+  const out = [];
+  for (const b of breaks) if (out.length === 0 || b > out[out.length - 1]) out.push(b);
+  return out.length === 1 ? [out[0], out[0]] : out;
+}
+function roundedBreaks(lo, hi, n) {
+  const width = (hi - lo) / n;
+  const exponent = Math.floor(Math.log10(width));
+  const round = (x) => exponent >= 0 ? Math.round(x / 10 ** exponent) * 10 ** exponent : Math.round(x * 10 ** -exponent) / 10 ** -exponent;
+  return [lo, ...Array.from({ length: n - 1 }, (_, i) => round(lo + width * (i + 1))), hi];
+}
+function stepColors(bounds, ramp, center) {
+  if (center === null) return spread(ramp, bounds.length);
+  const middle = (ramp.length - 1) / 2;
+  const side = bounds.map(
+    ([from, to]) => from === to && from === center ? 0 : to <= center ? -1 : from >= center ? 1 : 0
+  );
+  const lower = spread(ramp.slice(0, middle).reverse(), side.filter((s) => s < 0).length).reverse();
+  const upper = spread(ramp.slice(middle + 1), side.filter((s) => s > 0).length);
+  let l = 0;
+  let u = 0;
+  return side.map(
+    (s) => s < 0 ? lower[l++] : s > 0 ? upper[u++] : ramp[middle]
+  );
+}
+function stepIndex(steps, value) {
+  for (let i = 0; i < steps.length; i++) if (value <= steps[i].to) return i;
+  return steps.length - 1;
+}
+function categoricalScale(values, spec, method) {
+  const order = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const usable = typeof value === "string" && value !== "" || isFiniteNumber(value);
+    if (usable && !order.has(value)) order.set(value, order.size);
+  }
+  const categories = [...order.keys()].map((value, i) => ({
+    value,
+    color: CATEGORICAL_SET[i % CATEGORICAL_SET.length]
+  }));
+  const indexOf = (value) => value === null || value === void 0 ? -1 : order.get(value) ?? -1;
+  return {
+    type: spec.type,
+    method,
+    palette: "categorical",
+    domain: null,
+    center: null,
+    steps: [],
+    stops: [],
+    categories,
+    colorOf: (value) => categories[indexOf(value)]?.color ?? null,
+    indexOf,
+    positionOf: () => null
+  };
+}
+function colorScaleFor(values, spec) {
+  const continuous = spec.type === "continuous";
+  let method = spec.method !== void 0 && (continuous ? CONTINUOUS_METHODS : STEPPED_METHODS).has(spec.method) ? spec.method : continuous ? "linear" : "equidistant";
+  const domain = spec.domain?.every(isFiniteNumber) ? spec.domain : void 0;
+  const palette = spec.palette ?? (domain?.length === 3 ? "diverging" : "sequential");
+  if (palette === "categorical") return categoricalScale(values, spec, method);
+  const data = values.filter(isFiniteNumber);
+  let lo = Number.POSITIVE_INFINITY;
+  let hi = Number.NEGATIVE_INFINITY;
+  for (const v of domain ? [domain[0], domain[domain.length - 1]] : data) {
+    if (v < lo) lo = v;
+    if (v > hi) hi = v;
+  }
+  const thresholds = !continuous && method === "custom" ? [...new Set((spec.breaks ?? []).filter(isFiniteNumber))].sort((a, b) => a - b) : [];
+  if (method === "custom" && thresholds.length === 0) method = "equidistant";
+  if (thresholds.length > 0) {
+    lo = Math.min(lo, thresholds[0]);
+    hi = Math.max(hi, thresholds.at(-1));
+  }
+  const noData = () => ({
+    type: spec.type,
+    method,
+    palette,
+    domain: null,
+    center: null,
+    steps: [],
+    stops: [],
+    categories: [],
+    colorOf: () => null,
+    indexOf: () => -1,
+    positionOf: () => null
+  });
+  if (!Number.isFinite(lo) || !Number.isFinite(hi)) return noData();
+  const center = domain?.length === 3 ? domain[1] : palette === "diverging" ? lo < 0 && hi > 0 ? 0 : (lo + hi) / 2 : null;
+  const ramp = palette === "diverging" ? DIVERGING_RAMP : SEQUENTIAL_RAMP;
+  const sorted = data.map((v) => clamp(v, lo, hi)).sort((a, b) => a - b);
+  const needsData = method === "quantile" || method === "jenks" || continuous && method !== "linear";
+  if (needsData && sorted.length === 0) method = continuous ? "linear" : "equidistant";
+  let steps;
+  let stops = [];
+  let positionOf;
+  if (lo === hi) {
+    const color = stepColors([[lo, hi]], ramp, center)[0];
+    steps = [{ from: lo, to: hi, color }];
+    if (continuous) stops = [{ value: lo, color }];
+    const position = ramp.indexOf(color) / (ramp.length - 1);
+    positionOf = () => position;
+  } else if (continuous) {
+    let cuts;
+    const quantiles = QUANTILE_STOPS[method];
+    if (quantiles !== void 0) {
+      cuts = Array.from(
+        { length: quantiles + 1 },
+        (_, i) => i === 0 ? lo : i === quantiles ? hi : quantileSorted(sorted, i / quantiles)
+      );
+    } else if (method === "natural") {
+      const breaks = jenksBreaks(sorted, stepCount(spec.steps, DEFAULT_STEPS));
+      cuts = breaks.length > 2 ? [lo, ...breaks.slice(1, -1), hi] : [lo, hi];
+    } else {
+      cuts = [lo, hi];
+    }
+    let knots = cuts.map((v, i) => [v, i / (cuts.length - 1)]);
+    if (center !== null) {
+      const pc = interpolate(knots, clamp(center, lo, hi));
+      const bend = (p) => pc <= 0 ? 0.5 + p / 2 : pc >= 1 ? p / 2 : p <= pc ? 0.5 * p / pc : 0.5 + 0.5 * (p - pc) / (1 - pc);
+      knots = knots.map(([v, p]) => [v, bend(p)]);
+      if (center > lo && center < hi) {
+        knots.push([center, 0.5]);
+        knots.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+      }
+    }
+    const inverse = knots.map(([v, p]) => [p, v]);
+    const last = ramp.length - 1;
+    const valueAt = (position) => interpolate(inverse, position);
+    steps = ramp.map((color, j) => ({
+      from: j === 0 ? lo : valueAt((j - 0.5) / last),
+      to: j === last ? hi : valueAt((j + 0.5) / last),
+      color
+    }));
+    stops = ramp.map((color, j) => ({ value: valueAt(j / last), color }));
+    positionOf = (value) => interpolate(knots, value);
+  } else {
+    const n = Math.min(stepCount(spec.steps, DEFAULT_STEPS), ramp.length);
+    let breaks;
+    if (method === "custom") breaks = [lo, ...thresholds, hi];
+    else if (method === "quantile")
+      breaks = Array.from(
+        { length: n + 1 },
+        (_, i) => i === 0 ? lo : i === n ? hi : quantileSorted(sorted, i / n)
+      );
+    else if (method === "jenks") {
+      const natural = jenksBreaks(sorted, n);
+      breaks = [lo, ...natural.slice(1, -1), hi];
+    } else if (method === "rounded") breaks = roundedBreaks(lo, hi, n);
+    else
+      breaks = Array.from({ length: n + 1 }, (_, i) => i === n ? hi : lo + (hi - lo) * i / n);
+    const unique = uniqueBreaks(breaks);
+    const bounds = unique.slice(1).map((to, i) => [unique[i], to]);
+    const colors = stepColors(bounds, ramp, center);
+    steps = bounds.map(([from, to], i) => ({ from, to, color: colors[i] }));
+    positionOf = (value) => {
+      const i = stepIndex(steps, value);
+      const { from, to } = steps[i];
+      const within = to === from ? 0.5 : (value - from) / (to - from);
+      return (i + clamp(within, 0, 1)) / steps.length;
+    };
+  }
+  const indexOf = (value) => isFiniteNumber(value) ? stepIndex(steps, clamp(value, lo, hi)) : -1;
+  return {
+    type: spec.type,
+    method,
+    palette,
+    domain: [lo, hi],
+    center,
+    steps,
+    stops,
+    categories: [],
+    colorOf: (value) => steps[indexOf(value)]?.color ?? null,
+    indexOf,
+    positionOf: (value) => isFiniteNumber(value) ? positionOf(clamp(value, lo, hi)) : null
+  };
+}
+
+export {
+  jenksBreaks,
+  colorScaleFor
+};
+//# sourceMappingURL=chunk-KAAJL2HA.js.map