@astralarium/repo-ui 0.0.0-stage → 0.2.0

package/dist/router/tab-bar.js

@@ -0,0 +1,98 @@
+"use client";
+
+/**
+ * A `<nav>` of tabs. Each tab carries `data-slot="tab"`; the current tab
+ * carries `data-status="active"` and `aria-current`: `"page"` on a link,
+ * `"true"` on a button. Everything visual comes from the app.
+ */
+import { c as _c } from "react/compiler-runtime";
+import { useFormat } from "@astralarium/localizable";
+import { Link } from "@tanstack/react-router";
+import messages from "./tab-bar.messages.json" with { type: "json" };
+/** A link tab's default `activeOptions`: current on its exact path,
+ *  search aside. */
+import { jsx as _jsx } from "react/jsx-runtime";
+const TAB_ACTIVE_OPTIONS = {
+  exact: true,
+  includeSearch: false
+};
+/** A tab bar: router `Link`s current on their exact path, search aside,
+ *  unless the link sets `activeOptions`; buttons current while `active`.
+ *  Named "Tabs" unless `aria-label` says otherwise. */
+export function TabBar(t0) {
+  const $ = _c(15);
+  let props;
+  let tabClassName;
+  let tabs;
+  if ($[0] !== t0) {
+    ({
+      tabs,
+      tabClassName,
+      ...props
+    } = t0);
+    $[0] = t0;
+    $[1] = props;
+    $[2] = tabClassName;
+    $[3] = tabs;
+  } else {
+    props = $[1];
+    tabClassName = $[2];
+    tabs = $[3];
+  }
+  const format = useFormat();
+  let t1;
+  if ($[4] !== format) {
+    t1 = format(messages.barName);
+    $[4] = format;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  let t2;
+  if ($[6] !== tabClassName || $[7] !== tabs) {
+    let t3;
+    if ($[9] !== tabClassName) {
+      t3 = tab => tab.link ? /*#__PURE__*/_jsx(Link, {
+        ...tab.link,
+        activeOptions: tab.link.activeOptions ?? TAB_ACTIVE_OPTIONS,
+        className: tabClassName,
+        "data-slot": "tab",
+        children: tab.label
+      }, tab.name) : /*#__PURE__*/_jsx("button", {
+        type: "button",
+        onClick: () => tab.onClick?.(tab),
+        className: tabClassName,
+        "aria-current": tab.active ? "true" : undefined,
+        "data-slot": "tab",
+        "data-status": tab.active ? "active" : undefined,
+        children: tab.label
+      }, tab.name);
+      $[9] = tabClassName;
+      $[10] = t3;
+    } else {
+      t3 = $[10];
+    }
+    t2 = tabs.map(t3);
+    $[6] = tabClassName;
+    $[7] = tabs;
+    $[8] = t2;
+  } else {
+    t2 = $[8];
+  }
+  let t3;
+  if ($[11] !== props || $[12] !== t1 || $[13] !== t2) {
+    t3 = /*#__PURE__*/_jsx("nav", {
+      "aria-label": t1,
+      "data-slot": "tab-bar",
+      ...props,
+      children: t2
+    });
+    $[11] = props;
+    $[12] = t1;
+    $[13] = t2;
+    $[14] = t3;
+  } else {
+    t3 = $[14];
+  }
+  return t3;
+}

package/dist/router/tab-bar.messages.d.json.ts

@@ -0,0 +1,7 @@
+// Generated by l10n-types.
+import type { Message } from "@astralarium/localizable";
+
+declare const messages: {
+  barName: Message<Record<never, never>>;
+};
+export = messages;

package/dist/router/tab-bar.messages.json

@@ -0,0 +1,6 @@
+{
+  "barName": {
+    "id": "@astralarium/repo-ui/router/tab-bar.messages#barName",
+    "defaultMessage": "Tabs"
+  }
+}

package/dist/router/tabs.d.ts

@@ -0,0 +1,21 @@
+import { type LinkOptions } from "@tanstack/react-router";
+import type { ReactNode } from "react";
+/** A tab: a router link, or a button. */
+export interface Tab {
+    /** Identifies the tab; `buildTabs` selects by it. */
+    name: string;
+    label: ReactNode;
+    /** Destination of a link tab; current on its exact path, search
+     *  aside, unless `activeOptions` says otherwise. */
+    link?: LinkOptions;
+    /** Press of a button tab. */
+    onClick?: (tab: Tab) => unknown;
+    /** The selected tab: current among button tabs. */
+    active?: boolean;
+}
+/** Binds fixed tabs to a selection: `tabsOf(tab, setTab, onChange)` marks
+ *  tab `tab` active and selects a pressed tab. */
+export declare function buildTabs(tabs: readonly Omit<Tab, "onClick" | "active">[]): (tab: string, setTab: (name: string) => unknown, onChange?: () => unknown) => Tab[];
+/** Selects a tab outside a `TabBar`, e.g. from a dropdown: navigates to a
+ *  link tab, presses a button tab. */
+export declare function useSelectTab(): (tab: Tab) => void;

package/dist/router/tabs.js

@@ -0,0 +1,37 @@
+import { c as _c } from "react/compiler-runtime";
+import { useNavigate } from "@tanstack/react-router";
+/** Binds fixed tabs to a selection: `tabsOf(tab, setTab, onChange)` marks
+ *  tab `tab` active and selects a pressed tab. */
+export function buildTabs(tabs) {
+  return function tabsOf(tab, setTab, onChange) {
+    return tabs.map(x => ({
+      ...x,
+      active: x.name === tab,
+      onClick: () => {
+        setTab(x.name);
+        onChange?.();
+      }
+    }));
+  };
+}
+/** Selects a tab outside a `TabBar`, e.g. from a dropdown: navigates to a
+ *  link tab, presses a button tab. */
+export function useSelectTab() {
+  const $ = _c(2);
+  const navigate = useNavigate();
+  let t0;
+  if ($[0] !== navigate) {
+    t0 = tab => {
+      if (tab.link) {
+        navigate(tab.link);
+      } else {
+        tab.onClick?.(tab);
+      }
+    };
+    $[0] = navigate;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  return t0;
+}

package/dist/router/use-search-param.d.ts

@@ -0,0 +1,5 @@
+/** String-valued search param `name`, written back after `ms` idle
+ *  (`useDebounce`), replacing the history entry and keeping the hash;
+ *  empty text removes it. Other values read as JSON and write back as
+ *  strings. */
+export declare function useSearchParam(name: string, ms?: number): [string, (text: string) => void];

package/dist/router/use-search-param.js

@@ -0,0 +1,46 @@
+import { c as _c } from "react/compiler-runtime";
+import { useNavigate, useSearch } from "@tanstack/react-router";
+import { useDebounce } from "../use-debounce.js";
+/** A search param's value as text; empty when absent. */
+function searchText(value) {
+  if (value === undefined || value === null) return "";
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+/** String-valued search param `name`, written back after `ms` idle
+ *  (`useDebounce`), replacing the history entry and keeping the hash;
+ *  empty text removes it. Other values read as JSON and write back as
+ *  strings. */
+export function useSearchParam(name, ms) {
+  const $ = _c(5);
+  let t0;
+  if ($[0] !== name) {
+    t0 = {
+      strict: false,
+      select: search => searchText(search[name])
+    };
+    $[0] = name;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const value = useSearch(t0);
+  const navigate = useNavigate();
+  let t1;
+  if ($[2] !== name || $[3] !== navigate) {
+    t1 = text => navigate({
+      to: ".",
+      search: prev => ({
+        ...prev,
+        [name]: text || undefined
+      }),
+      hash: true,
+      replace: true
+    });
+    $[2] = name;
+    $[3] = navigate;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  return useDebounce(value, t1, ms);
+}

package/dist/slider/index.d.ts

@@ -0,0 +1,8 @@
+/** Sliders and scrubbers over Base UI: parts, state and timeline scrubbing. */
+export * from "./scrubber.tsx";
+export type { ScrubberStep, ScrubberTick } from "./scrubber-state.ts";
+export * from "./slider.tsx";
+export * from "./slider-parts.ts";
+export { type SliderContextValue, type SliderFill, type SliderSpan, type SliderTickLight, useSlider, useSliderTick, } from "./slider-state.ts";
+export * from "./timeline-scrubber.tsx";
+export { type TimelineMark, timelineNames } from "./timeline-scrubber-state.ts";

package/dist/slider/index.js

@@ -0,0 +1,7 @@
+/** Sliders and scrubbers over Base UI: parts, state and timeline scrubbing. */
+export * from "./scrubber.js";
+export * from "./slider.js";
+export * from "./slider-parts.js";
+export { useSlider, useSliderTick } from "./slider-state.js";
+export * from "./timeline-scrubber.js";
+export { timelineNames } from "./timeline-scrubber-state.js";

package/dist/slider/scrubber-state.d.ts

@@ -0,0 +1,118 @@
+/** Scrubber rules: tick groups, landing, stepping, lighting, reach,
+ *  and the split fill. */
+import type { Slider as SliderPrimitive } from "@base-ui/react/slider";
+import type { ReactNode } from "react";
+import type { SliderSpan } from "./slider-state.ts";
+/** A position along a scrubber's track: a snap and step target. Named
+ *  or glyphed, a mark, always drawn; bare, a stop, drawn faintly near
+ *  the pointer. */
+export interface ScrubberTick {
+    value: number;
+    /** Tooltip and spoken text; names sharing a value list together. */
+    name?: string;
+    /** Drawn at the tick; the lowest-ranked glyph at a value draws. Its
+     *  mark carries the thumb's reach along the fill as `data-reach`:
+     *  `ahead` short of the mark, `held` on it or within the hold window
+     *  past it, `past` beyond. */
+    glyph?: ReactNode;
+    /** Lower draws over higher at a shared value; ties keep order. */
+    rank?: number;
+}
+/** The ticks at one value. */
+export interface ScrubberTickGroup {
+    value: number;
+    /** The named or glyphed ticks, most prominent first; none for a
+     *  stop. */
+    marks: readonly ScrubberTick[];
+    /** The marks' names, most prominent first. */
+    names: readonly string[];
+}
+/** `ticks` grouped by value, ascending. */
+export declare function groupTicks(ticks: readonly ScrubberTick[]): ScrubberTickGroup[];
+/** The names of the `groups` at `value`, most prominent first. */
+export declare function tickNames(groups: readonly ScrubberTickGroup[], value: number): readonly string[];
+/** The names of the latest of `groups` at or before `value`, most
+ *  prominent first. */
+export declare function latestNames(groups: readonly ScrubberTickGroup[], value: number): readonly string[];
+/** A key step: `by` toward `max` (1) or `min` (-1), resolved for
+ *  orientation and direction; `large` with Shift or PageUp/PageDown. */
+export interface ScrubberStep {
+    by: -1 | 1;
+    large: boolean;
+}
+/** Where a step from `from` lands: the adjacent tick; a large step's
+ *  the adjacent mark, or tick where none is a mark. Undefined past the
+ *  outermost. */
+export declare function stepTick(groups: readonly ScrubberTickGroup[], from: number, { by, large }: ScrubberStep): number | undefined;
+/** The ticks and range landings snap within. */
+export interface ScrubberGrid {
+    groups: readonly ScrubberTickGroup[];
+    min: number;
+    max: number;
+    /** How near a tick a landing snaps to it. */
+    snapWindow: number;
+}
+/** Where `at` lands, within the range: snapping, the tick nearest it
+ *  within the snap window. */
+export declare function landAt({ groups, min, max, snapWindow }: ScrubberGrid, at: number, snaps: boolean): number;
+/** A value change, as the scrubber reads it. */
+export interface ScrubberChange {
+    /** Base UI's value; for a thumb key while playing, the end it heads
+     *  for. */
+    next: number;
+    reason: SliderPrimitive.Root.ChangeEventReason;
+    /** A step's way: `next`'s side of Base UI's value, or a thumb key's
+     *  (`keyWay`). */
+    by: -1 | 1;
+    /** The key pressed, on a keyboard change. */
+    key?: string;
+    /** Shift held, where the event carries modifiers. */
+    shiftKey?: boolean;
+}
+/** What a change does: lands at `land`, or steps by `step`, landing at
+ *  `land` unless a step handler takes the step. */
+export type ScrubberMove = {
+    land: number;
+} | {
+    step: ScrubberStep;
+    land: number | undefined;
+};
+/** Which way a thumb key heads, resolved for orientation and direction:
+ *  Home and End toward their ends; null for other keys. */
+export declare function keyWay(key: string, rtl: boolean): -1 | 1 | null;
+/** What `change` does to the scrubber at `current`: presses and drags
+ *  land snapped (`snapping`, unless the event says whether Shift is
+ *  held), arrows, Page keys, and input changes step their way, Home and
+ *  End land on the ends. */
+export declare function resolveChange(grid: ScrubberGrid, { next, reason, by, key, shiftKey }: ScrubberChange, { current, snapping }: {
+    current: number;
+    snapping: boolean;
+}): ScrubberMove;
+/** The tick an off-tick `target` shows: the latest at or before it;
+ *  null on a tick, before the first, or with no target. */
+export declare function hintedTick(groups: readonly ScrubberTickGroup[], target: number | null): number | null;
+/** A stop drawn near the pointer. */
+export interface NearStop {
+    value: number;
+    /** 1 for the nearest, falling with each stop farther. */
+    fade: number;
+}
+/** The `count` of `stops` nearest `pointer`, fading with distance. */
+export declare function nearStops(stops: readonly number[], pointer: number, count: number): NearStop[];
+/** How far `at` has come along `marks`: one per mark it stands on, two
+ *  per mark behind it. Changes exactly as `at` reaches or leaves a
+ *  mark. */
+export declare function crossings(marks: readonly number[], at: number): number;
+/** Where the thumb stands by a mark (`data-reach`). */
+export type ScrubberReach = "ahead" | "held" | "past";
+/** The thumb at `value` by the mark at `at`, along the way `fill`
+ *  grows: `held` on it or up to `hold` past it. */
+export declare function tickReach(value: number, at: number, hold: number, fill: "start" | "end"): ScrubberReach;
+/** A range segment: a run of the fill and how a press changes it. */
+export interface RangeSegment {
+    change: "kept" | "shrink" | "grow";
+    span: SliderSpan;
+}
+/** The fill over `shown`, split by what a press leaving `predicted`
+ *  keeps, shrinks, and grows. */
+export declare function rangeSegments(shown: SliderSpan, predicted: SliderSpan | null): RangeSegment[];

package/dist/slider/scrubber-state.js

@@ -0,0 +1,179 @@
+import { adjacent, nearest } from "../sorted.js";
+/** Whether `tick` draws as a mark. */
+function isMark(tick) {
+  return tick.name !== undefined || tick.glyph !== undefined;
+}
+/** `ticks` grouped by value, ascending. */
+export function groupTicks(ticks) {
+  const at = new Map();
+  for (const tick of ticks) {
+    at.set(tick.value, [...(at.get(tick.value) ?? []), tick]);
+  }
+  return [...at].sort(([a], [b]) => a - b).map(([value, here]) => {
+    const marks = here.filter(isMark).sort((a, b) => (a.rank ?? 0) - (b.rank ?? 0));
+    return {
+      value,
+      marks,
+      names: marks.flatMap(mark => mark.name === undefined ? [] : [mark.name])
+    };
+  });
+}
+/** The names of the `groups` at `value`, most prominent first. */
+export function tickNames(groups, value) {
+  return groups.find(group => group.value === value)?.names ?? [];
+}
+/** The latest of `groups` at or before `value`; undefined before the
+ *  first. */
+function latestTick(groups, value) {
+  return groups.findLast(group => group.value <= value);
+}
+/** The names of the latest of `groups` at or before `value`, most
+ *  prominent first. */
+export function latestNames(groups, value) {
+  return latestTick(groups, value)?.names ?? [];
+}
+/** Where a step from `from` lands: the adjacent tick; a large step's
+ *  the adjacent mark, or tick where none is a mark. Undefined past the
+ *  outermost. */
+export function stepTick(groups, from, {
+  by,
+  large
+}) {
+  const marks = groups.filter(group => group.marks.length > 0);
+  const over = (large && marks.length > 0 ? marks : groups).map(group => group.value);
+  return adjacent(over, from, by);
+}
+/** Where `at` lands, within the range: snapping, the tick nearest it
+ *  within the snap window. */
+export function landAt({
+  groups,
+  min,
+  max,
+  snapWindow
+}, at, snaps) {
+  const ticks = groups.map(group => group.value);
+  return Math.min(max, Math.max(min, snaps ? nearest(ticks, at, snapWindow) : at));
+}
+/** A step from `current` by `step`: to the adjacent tick; without
+ *  ticks, to `next`. */
+function stepMove({
+  groups
+}, current, next, step) {
+  return {
+    step,
+    land: groups.length === 0 ? next : stepTick(groups, current, step)
+  };
+}
+/** Which way a thumb key heads, resolved for orientation and direction:
+ *  Home and End toward their ends; null for other keys. */
+export function keyWay(key, rtl) {
+  switch (key) {
+    case "ArrowUp":
+    case "PageUp":
+    case "End":
+      return 1;
+    case "ArrowDown":
+    case "PageDown":
+    case "Home":
+      return -1;
+    case "ArrowRight":
+      return rtl ? -1 : 1;
+    case "ArrowLeft":
+      return rtl ? 1 : -1;
+    default:
+      return null;
+  }
+}
+/** What `change` does to the scrubber at `current`: presses and drags
+ *  land snapped (`snapping`, unless the event says whether Shift is
+ *  held), arrows, Page keys, and input changes step their way, Home and
+ *  End land on the ends. */
+export function resolveChange(grid, {
+  next,
+  reason,
+  by,
+  key,
+  shiftKey
+}, {
+  current,
+  snapping
+}) {
+  switch (reason) {
+    case "track-press":
+    case "drag":
+      return {
+        land: landAt(grid, next, shiftKey === undefined ? snapping : !shiftKey)
+      };
+    // Assistive tech adjusts the thumb a step at a time.
+    case "input-change":
+      return stepMove(grid, current, next, {
+        by,
+        large: false
+      });
+    case "keyboard":
+      if (key === "Home" || key === "End") return {
+        land: next
+      };
+      return stepMove(grid, current, next, {
+        by,
+        large: shiftKey === true || key === "PageUp" || key === "PageDown"
+      });
+    case "none":
+      return {
+        land: next
+      };
+    default:
+      return reason;
+  }
+}
+/** The tick an off-tick `target` shows: the latest at or before it;
+ *  null on a tick, before the first, or with no target. */
+export function hintedTick(groups, target) {
+  if (target === null) return null;
+  const tick = latestTick(groups, target);
+  return tick === undefined || tick.value === target ? null : tick.value;
+}
+/** The `count` of `stops` nearest `pointer`, fading with distance. */
+export function nearStops(stops, pointer, count) {
+  return [...stops].sort((a, b) => Math.abs(a - pointer) - Math.abs(b - pointer)).slice(0, count).map((value, rank) => ({
+    value,
+    fade: 1 - rank / count
+  }));
+}
+/** How far `at` has come along `marks`: one per mark it stands on, two
+ *  per mark behind it. Changes exactly as `at` reaches or leaves a
+ *  mark. */
+export function crossings(marks, at) {
+  let count = 0;
+  for (const mark of marks) count += mark < at ? 2 : mark === at ? 1 : 0;
+  return count;
+}
+/** The thumb at `value` by the mark at `at`, along the way `fill`
+ *  grows: `held` on it or up to `hold` past it. */
+export function tickReach(value, at, hold, fill) {
+  const past = fill === "start" ? value - at : at - value;
+  return past < 0 ? "ahead" : past <= hold ? "held" : "past";
+}
+/** `a`'s runs outside `b`. */
+function spanMinus([a0, a1], [b0, b1]) {
+  return [[a0, Math.min(a1, b0)], [Math.max(a0, b1), a1]].filter(([lo, hi]) => hi > lo);
+}
+/** The fill over `shown`, split by what a press leaving `predicted`
+ *  keeps, shrinks, and grows. */
+export function rangeSegments(shown, predicted) {
+  if (predicted === null) return [{
+    change: "kept",
+    span: shown
+  }];
+  const kept = [Math.max(shown[0], predicted[0]), Math.min(shown[1], predicted[1])];
+  return [...(kept[1] > kept[0] ? [{
+    change: "kept",
+    span: kept
+  }] : []), ...spanMinus(shown, predicted).map(span => ({
+    change: "shrink",
+    span
+  })), ...spanMinus(predicted, shown).map(span => ({
+    change: "grow",
+    span
+  }))];
+}

package/dist/slider/scrubber.d.ts

@@ -0,0 +1,77 @@
+import type { Slider as SliderPrimitive } from "@base-ui/react/slider";
+import { type ScrubberStep, type ScrubberTick } from "./scrubber-state.ts";
+import type { SliderRootProps, SliderThumbProps } from "./slider.tsx";
+import { type SliderParts } from "./slider-parts.ts";
+/** What moved the value: Base UI's reasons, `track-press` as the
+ *  scrubber lands a press, `keyboard` as it lands a thumb key while
+ *  playing, or `modifier` as Shift toggles snapping mid-drag. */
+export type ScrubberChangeDetails = Exclude<SliderPrimitive.Root.ChangeEventDetails, {
+    reason: "track-press";
+}> | {
+    reason: "track-press";
+    event: PointerEvent;
+} | {
+    reason: "keyboard";
+    event: KeyboardEvent;
+} | {
+    reason: "modifier";
+    event: KeyboardEvent;
+};
+/** Where a thumb key steps from the playhead: between the ticks, or
+ *  through the step handler. */
+type ScrubberStepping = {
+    playhead?: null;
+    /** Landings snap to these; arrows step between them. */
+    ticks?: readonly ScrubberTick[];
+    /** Arrows, Page keys, and input changes (assistive tech adjusting
+     *  the thumb) step through this in place of the ticks: it lands
+     *  the step itself. Home and End land on the ends regardless. */
+    onStep?: (step: ScrubberStep) => void;
+} | {
+    /** The shown value, read every frame while set (playback): the
+     *  thumb and fill glide with it (`SliderRoot` `glide`); `value`
+     *  stays the spoken one. Thumb keys, input changes, and presses
+     *  move from it. */
+    playhead: (() => number) | null;
+    ticks: readonly ScrubberTick[];
+    onStep?: (step: ScrubberStep) => void;
+} | {
+    playhead: (() => number) | null;
+    ticks?: readonly ScrubberTick[];
+    onStep: (step: ScrubberStep) => void;
+};
+/** `Scrubber` props: a single-thumb slider's, over ticks. */
+export type ScrubberProps = Omit<SliderRootProps<number>, "value" | "defaultValue" | "onValueChange" | "onValueCommitted" | "children" | "fill" | "minStepsBetweenValues" | "thumbCollisionBehavior"> & {
+    value: number;
+    /** Lands at `value`: presses, drags, input changes, and steps. */
+    onValueChange: (value: number, details: ScrubberChangeDetails) => void;
+    /** How near a tick a landing snaps to it, as a share of the range; 0
+     *  lands on ticks alone. A mark holds the thumb as far past it
+     *  (`data-reach`); playing, the thumb passes marks. */
+    snapShare?: number;
+    /** A value shown ahead of a pick elsewhere: the thumb there,
+     *  tentative (`data-tentative`), its tick lit. */
+    tentative?: number | null;
+    /** The pointer previews its press: the fill it keeps, shrinks, and
+     *  grows, and the tick it lands on. */
+    pointerPreview?: boolean;
+    /** The run the range fills. */
+    fill?: "start" | "end";
+    /** The spoken value at `value`, given the names of the latest tick at
+     *  or before it; by default the names of the ticks at `value` as a
+     *  conjunction in the messages locale, else the formatted value. */
+    valueText?: (value: number, names: readonly string[]) => string;
+    /** The thumb's props (accessible name); its ref, style, and focus
+     *  handlers merge with the scrubber's own. */
+    thumb?: Omit<SliderThumbProps, "index" | "getAriaValueText">;
+    /** The parts drawn; the unstyled ones by default. */
+    parts?: SliderParts;
+} & ScrubberStepping;
+/** A single-thumb slider over ticks: landings snap to them, arrows
+ *  step between them, marks draw always, stops near the pointer. The
+ *  pointer previews its press; Shift lands at the pointer. State shows
+ *  as `data-tentative` on the root, `data-change` on the fill's
+ *  segments (`kept`, `shrink`, `grow`), `data-light` and `data-reach`
+ *  on ticks, and `data-hover` on the thumb. */
+export declare function Scrubber({ value, onValueChange, ticks, snapShare, tentative, playhead, pointerPreview, fill, onStep, valueText, thumb, parts, onDraggingChange, min, max, disabled, onKeyDownCapture, ...props }: ScrubberProps): import("react/jsx-runtime").JSX.Element;
+export {};