@mkbabb/glass-ui 3.10.0 → 3.10.1

package/dist/components/custom/underline/GlassUnderline.vue.d.ts

@@ -0,0 +1,84 @@
+import type { TimingFunction } from "@mkbabb/keyframes.js";
+import type { GlassUnderlinePaths } from "./types";
+type __VLS_Props = {
+    /**
+     * Which clock drives the draw. `load` (default) — the draw is a
+     * `NumericAnimation` the parent's load `Sequence` fires once via `play()`.
+     * `scroll` — native `view()` keyframes, bidirectional, no JS. `static` —
+     * set drawn, no clock.
+     */
+    clock?: "load" | "scroll" | "static";
+    /**
+     * The render variant. `pen` is the only PROVEN, filter-free render.
+     * pencil | crayon | boil are UNPROVEN headroom — the API seam for a future
+     * wave, NOT shipped here (they render pen today).
+     */
+    variant?: "pen" | "pencil" | "crayon" | "boil";
+    /** The stroke colour. Defaults to `var(--primary)` (re-resolves under .dark). */
+    color?: string;
+    /** The load-clock draw duration (ms). Default 700. */
+    drawMs?: number;
+    /**
+     * The load-clock easing. Default `easeOutCubic` — doctrine-compliant (DEC-6):
+     * ink is an irreversible additive reveal, so an overshooting spring would lay
+     * ink past the end then retract it (the "never overshoot past gone" logic).
+     * The value.js `TimingFunction` type (already a peer) serves a consumer's own
+     * decelerating register (e.g. an expo).
+     */
+    easing?: TimingFunction;
+    /**
+     * The scroll-clock timeline name (DEC-5). Default the element's own `view()`.
+     * Bound as `--gu-timeline`; the CSS reads `animation-timeline:
+     * var(--gu-timeline, view())`. A consumer (`--beat-tl`, a named scroll
+     * timeline) passes its own.
+     */
+    timeline?: string;
+    /**
+     * The declarative third clock (DEC-2). A thin overlay ON the load clock:
+     * `undefined` (default) = source parity (seeds undrawn, parent fires
+     * `play()`); bound: rising edge → play() (under PRM → snap()), falling edge
+     * → reset to undrawn so re-activation REPLAYS, mount with `true` → plays.
+     * Only meaningful with `clock="load"` (the other clocks rest drawn).
+     */
+    active?: boolean;
+    /**
+     * The geometry escape (DEC-7). The FULL geometry tuple
+     * `{ stroke, ghost?, viewBox?, len? }` — a bare `d`-string escape silently
+     * breaks the dash model when the consumer geometry's viewBox/length differ.
+     * Defaults to the canonical pen + ghost.
+     */
+    paths?: GlassUnderlinePaths;
+};
+/**
+ * CLOCK A — draw the underline ONCE. The awaitable a parent's load `Sequence` fires
+ * as a causal link. Resolves a Promise so the Sequence can `await` it; under PRM it
+ * snaps to drawn in one paint and resolves immediately. A no-op for scroll/static.
+ */
+declare function play(): Promise<void>;
+/** Snap to terminal (drawn) — the PRM / interrupt path. */
+declare function snap(): void;
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+    play: typeof play;
+    snap: typeof snap;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    active: boolean;
+    variant: "pen" | "pencil" | "crayon" | "boil";
+    color: string;
+    clock: "load" | "scroll" | "static";
+    drawMs: number;
+    easing: TimingFunction;
+    timeline: string;
+    paths: GlassUnderlinePaths;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/custom/underline/index.d.ts

@@ -0,0 +1,2 @@
+export { default as GlassUnderline } from "./GlassUnderline.vue";
+export type { GlassUnderlineClock, GlassUnderlineVariant, GlassUnderlinePaths, GlassUnderlineProps, GlassUnderlineExpose, } from "./types";

package/dist/components/custom/underline/types.d.ts

@@ -0,0 +1,56 @@
+import type { TimingFunction } from "@mkbabb/keyframes.js";
+/** Which clock drives the draw. */
+export type GlassUnderlineClock = "load" | "scroll" | "static";
+/**
+ * The render variant. `pen` is the only PROVEN, filter-free render (the masthead
+ * invariant). pencil | crayon | boil are UNPROVEN headroom — the API seam for a
+ * future wave, NOT shipped (they render pen today).
+ */
+export type GlassUnderlineVariant = "pen" | "pencil" | "crayon" | "boil";
+/**
+ * The geometry escape tuple (DEC-7). Carries the FULL geometry so an escaped path
+ * stays dash-coherent — a bare `d`-string escape silently breaks the dash model when
+ * the consumer geometry's viewBox/length differ from the canonical
+ * (`0 0 100 10` + `len` 120).
+ */
+export interface GlassUnderlinePaths {
+    /** The primary pen stroke `d`. */
+    readonly stroke: string;
+    /** The faint ghost overdraw `d`. Omit for a single-path (no overdraw) render. */
+    readonly ghost?: string;
+    /** The SVG viewBox. Default `0 0 100 10`. */
+    readonly viewBox?: string;
+    /** The dasharray length (the over-long fixed dash). Default `120`. */
+    readonly len?: number;
+}
+/** GlassUnderline props (the public prop surface). */
+export interface GlassUnderlineProps {
+    /** Which clock drives the draw. Default `load`. */
+    clock?: GlassUnderlineClock;
+    /** The render variant. Default `pen` (the only proven render). */
+    variant?: GlassUnderlineVariant;
+    /** The stroke colour. Default `var(--primary)` (re-resolves under `.dark`). */
+    color?: string;
+    /** The load-clock draw duration (ms). Default `700`. */
+    drawMs?: number;
+    /** The load-clock easing (value.js `TimingFunction`). Default `easeOutCubic`. */
+    easing?: TimingFunction;
+    /** The scroll-clock timeline name. Default the element's own `view()`. */
+    timeline?: string;
+    /**
+     * The declarative third clock — a thin overlay ON the load clock. `undefined`
+     * (default) = source parity (parent fires `play()`); rising edge → play, falling
+     * edge → reset-to-undrawn (re-rise REPLAYS), mount-`true` → plays. Only
+     * meaningful with `clock="load"`.
+     */
+    active?: boolean;
+    /** The geometry escape tuple. Defaults to the canonical pen + ghost. */
+    paths?: GlassUnderlinePaths;
+}
+/** The imperative handle exposed via `defineExpose` / a template ref. */
+export interface GlassUnderlineExpose {
+    /** Draw the load-clock underline once (the awaitable a Sequence chains). */
+    play: () => Promise<void>;
+    /** Snap to terminal (drawn) — the PRM / interrupt path. */
+    snap: () => void;
+}

package/dist/components/ui/drawer/Drawer.vue.d.ts

@@ -39,6 +39,7 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     "onUpdate:activeSnapPoint"?: ((val: string | number) => any) | undefined;
 }>, {
     mode: DrawerMode;
+    open: boolean;
     modal: boolean;
     shouldScaleBackground: boolean;
     snapPoints: (number | string)[];

package/dist/components/ui/dropdown-menu/DropdownMenuSubContent.vue.d.ts

@@ -3,9 +3,9 @@ import { type DropdownMenuSubContentProps } from 'reka-ui';
 type __VLS_Props = DropdownMenuSubContentProps & {
     class?: HTMLAttributes['class'];
 };
-declare var __VLS_8: {};
+declare var __VLS_14: {};
 type __VLS_Slots = {} & {
-    default?: (props: typeof __VLS_8) => any;
+    default?: (props: typeof __VLS_14) => any;
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     escapeKeyDown: (event: KeyboardEvent) => any;

package/dist/components/ui/slider/index.d.ts

@@ -10,31 +10,34 @@ export { default as Slider } from './Slider.vue';
  * (`--slider-track-height`, `--slider-thumb-size`) the SFC defaults read.
  *
  * Exactly two canonical recipes ship:
- *   standard — the CONTINUOUS ROUNDED CYLINDER: a THICK glass capsule track with
- *              the round knob INSCRIBED inside it (knob diameter = track height −
- *              2×inset, inset 2px) so the whole reads as ONE continuous piece — a
- *              ball-bearing seated in the cylinder, never a floating disc on a
- *              wire. The fill is the W52 liquid-glass material (backdrop + edge
- *              rim, tinted to `--primary`) pulled along the capsule; the knob
- *              rides ON it with zero protrusion (`thumbAlignment: 'contain'`).
- *              The reka SliderThumb stays mounted (a11y/keyboard/focus) and
- *              carries a faint specular grip. Halo-on-state + the iOS press
- *              spring. This is the general-purpose glass scrubber and the default.
+ *   standard — the CONTINUOUS GLASS CYLINDER with NO VISIBLE THUMB AT ALL (the
+ *              user's binding bar, USER-AUDIT-2026-06-10 §B3): you pull the TRACK
+ *              itself. A THICK glass capsule track; the filled `.slider-range`
+ *              glass cylinder (the W52 liquid-glass material — backdrop + edge rim,
+ *              tinted to `--primary`) is pulled along it, and its leading EDGE IS
+ *              the handle — the only affordance is the fill edge + the cursor/touch
+ *              response. The reka `<SliderThumb>` STAYS MOUNTED (a11y/keyboard/drag/
+ *              value-follow native on it) but paints INVISIBLE: width 0, opacity 0,
+ *              transparent — no distinct disc/cap/ring over the continuous
+ *              cylinder. Keyboard focus rings the TRACK (the W-PRIM-POLISH focus
+ *              register), not the invisible thumb; hover/held lift the track FILL's
+ *              edge rim; the iOS press spring gives the whole fill a felt squish.
+ *              This is the general-purpose glass scrubber and the default.
  *   spectrum — the value.js gradient-track color slider: a tall capsule whose
  *              background is a consumer-supplied `--slider-track-bg`
  *              linear-gradient (the LCH/hue ramp), a transparent range, and a
- *              SQUIRCLE thumb the HEIGHT of the track (the iOS color-picker
- *              idiom — `corner-shape: superellipse()` via `--corner-shape-thumb`,
+ *              THIN VISIBLE squircle thumb the HEIGHT of the track (the iOS/value.js
+ *              color-picker idiom — a slim vertical bar, `w-3`-thin per the value.js
+ *              reference; `corner-shape: superellipse()` via `--corner-shape-thumb`,
  *              @supports-gated over a generous proportional round fallback that
  *              reads squircle-adjacent cross-engine). This is the aurora/blob
- *              color-picking surface. The spectrum already obeys the containment
- *              law the standard cylinder now matches (thumb inscribed, protrusion 0).
+ *              color-picking surface — its thumb IS visible (it is the handle).
  *
- * Sizes — the standard cylinder inscribes the knob: track height = thumb + 4px
- * (a 2px inset reveal each side), thumb diameter ≤ track height at every rung:
- *   sm — 12px track / 8px thumb
- *   md — 20px track / 16px thumb (default)
- *   lg — 28px track / 24px thumb
+ * Sizes — the standard cylinder is the thick glass capsule (the invisible thumb's
+ * value-follow inset still rides the size token for the 44px coarse hit-halo):
+ *   sm — 12px track
+ *   md — 20px track (default)
+ *   lg — 28px track
  */
 export declare const sliderVariants: (props?: ({
     variant?: "standard" | "spectrum" | null | undefined;

package/dist/components/ui/toast/use-toast.d.ts

@@ -19,7 +19,7 @@ type ToasterToast = Toast & {
     description?: string;
     action?: Component | VNode;
     open?: boolean;
-    onOpenChange?: (open: boolean) => void;
+    'onUpdate:open'?: (open: boolean) => void;
 };
 type ToastOptions = Omit<ToasterToast, 'id'>;
 declare function toast(props: ToastOptions): {
@@ -160,7 +160,7 @@ declare function useToast(): {
          | undefined;
         duration?: number | undefined;
         open?: boolean | undefined;
-        onOpenChange?: ((open: boolean) => void) | undefined;
+        'onUpdate:open'?: ((open: boolean) => void) | undefined;
     }[]>;
     toast: typeof toast;
     dismiss: (toastId?: string) => void;

package/dist/composables/color/index.d.ts

@@ -109,6 +109,18 @@ export interface DeriveBlobPaletteOptions {
     hueSpread?: number;
     /** Midpoint chroma-bump (keeps a vivid pair off the grey midpoint). Default ~0.03. */
     chromaBump?: number;
+    /**
+     * AY.W-COHERE E1 — the OKLCh-chroma CEILING on every derived stop (OKLCh C
+     * units). When set, each stop's chroma is clamped to AT MOST this value AFTER
+     * the midpoint bump and BEFORE the gamut-map — so the seed→palette derivation
+     * can never amplify a vivid seed into the neon register the shader's
+     * SSS/iridescence then over-drives. This is a CHROMA CAP, not a hue re-map: a
+     * blue seed stays blue, just bounded to the non-neon chroma. `undefined` (the
+     * default) leaves the derivation byte-identical to HEAD. The blob substrate
+     * caps the MOOD/seed path into the warm-register band the FourierField comet +
+     * the constellation focal share (the set-cohesion accent identity).
+     */
+    chromaCeiling?: number;
 }
 /**
  * Seed ONE color into a harmonious, gamut-safe 2-4-stop OKLCh palette for the blob

package/dist/composables/glass/useSpecularTracking.d.ts

@@ -21,13 +21,22 @@ import { ref, type CSSProperties } from "vue";
  *
  * PRM-aware: under `prefers-reduced-motion: reduce` the seam DOES NOT write the
  * position (the CSS half pins the catch-light static at the centred `50%`
- * fallback). The write is style-only — no reflow, no re-render — and inert until
- * the user actually moves the pointer over a wired host.
+ * fallback). The PRM signal is read from a SINGLE cached `matchMedia` listener
+ * minted once at composable setup (NOT a fresh `matchMedia` per pointer event) —
+ * the AV.W7 `useWebGLCanvas` substrate pattern.
+ *
+ * AY.W-A11Y-PERF O-3 — the pointer write is rAF-COALESCED: `onPointerMove` only
+ * stashes the raw event + schedules ONE `requestAnimationFrame`; the rAF callback
+ * does the single `getBoundingClientRect()` + style write, so a 120–1000 Hz pointer
+ * collapses to ONE batched layout read + ONE style write per animation frame (under
+ * W54 maximal-glass every blurred-surface repaint is amortized to the frame, not the
+ * event). The composable cancels the pending rAF + removes the matchMedia listener on
+ * scope dispose (cleanup discipline).
  */
 export interface UseSpecularTracking {
     /** Bind to the host element's `:style`. Carries the `--mouse-x/--mouse-y` write. */
     specularStyle: ReturnType<typeof ref<CSSProperties>>;
-    /** Bind to the host's `@pointermove`. Writes the cursor position (PRM-gated). */
+    /** Bind to the host's `@pointermove`. Schedules the rAF-coalesced position write (PRM-gated). */
     onPointerMove: (event: PointerEvent) => void;
 }
 export declare function useSpecularTracking(): UseSpecularTracking;

package/dist/composables/motion/core/index.d.ts

@@ -7,6 +7,5 @@ export * from "../useIntersectionPause";
 export * from "../useYieldToMain";
 export * from "../usePrioritizedTask";
 export * from "../useViewTransition";
-export * from "../useRouteTransition";
 export * from "../vReveal";
 export * from "../useTextHighlight";

package/dist/composables/motion/curves.d.ts

@@ -0,0 +1,48 @@
+import { type easeInQuad } from "@mkbabb/value.js";
+import { type Easing, type TimingFunction } from "@mkbabb/keyframes.js";
+/** A value.js easing callable `(t: number) => number` (the family's shape). */
+export type CurveFn = typeof easeInQuad;
+/** The kind of a `MOTION_CURVES` row — a spring `linear()` or a cubic-bezier. */
+export type MotionCurveKind = "spring" | "bezier";
+/**
+ * One row of the CSS↔JS curve table. CANONICAL rows carry their own JS twin;
+ * ALIAS rows resolve through a `canonical` target (no duplicated twin).
+ */
+export interface MotionCurve {
+    /** The CSS token name, including the leading `--`. */
+    readonly token: `--${string}`;
+    /** `spring` (a solved `linear()` token) or `bezier` (a cubic-bezier token). */
+    readonly kind: MotionCurveKind;
+    /**
+     * The JS twin — a callable `Easing` (springs, via `springTimingFunction`) or a
+     * `TimingFunction` (`(t) => number`, beziers via `CSSCubicBezier`). For ALIAS
+     * rows this is the canonical row's twin (resolve-through, not a copy).
+     */
+    readonly js: Easing | TimingFunction;
+    /**
+     * For an ALIAS row: the canonical `--token` this resolves through. `undefined`
+     * on a canonical row.
+     */
+    readonly canonical?: `--${string}`;
+    /** The register doc (springs lift it from the shared preset table). */
+    readonly note: string;
+}
+/**
+ * The CSS↔JS curve table, keyed by CSS token name. Covers EVERY `--ease-*` /
+ * `--spring-*` token declared in `tokens.css §2` + `theme.css` (CURVE-TABLE-BOUND
+ * gate §3.2). Spring rows carry a keyframes.js `Easing`; bezier rows a value.js
+ * `TimingFunction`; alias rows resolve through their `canonical` target.
+ *
+ * @example
+ *   import { MOTION_CURVES } from "@mkbabb/glass-ui/motion";
+ *   const easing = MOTION_CURVES["--spring-snappy"].js; // the iOS-control twin
+ *   new NumericAnimation(frames, { timingFunction: easing });
+ */
+export declare const MOTION_CURVES: Readonly<Record<string, MotionCurve>>;
+/** The canonical (non-alias) curve rows, in declaration order. */
+export declare const MOTION_CURVES_CANONICAL: readonly MotionCurve[];
+/** Look up a curve's JS twin by CSS token name (throws on an unknown token). */
+export declare function motionCurve(token: string): MotionCurve;
+export { linear, easeInQuad, easeOutQuad, easeInOutQuad, easeInCubic, easeOutCubic, easeInOutCubic, easeInSine, easeOutSine, easeInOutSine, easeInCirc, easeOutCirc, easeInOutCirc, easeInExpo, easeOutExpo, easeInOutExpo, easeInBounce, CSSCubicBezier, } from "@mkbabb/value.js";
+export { SPRING_PRESETS, springPreset } from "./springPresets";
+export type { SpringPresetRow, SpringPresetName } from "./springPresets";

package/dist/composables/motion/index.d.ts

@@ -6,3 +6,5 @@ export * from "./useNumericTransition";
 export * from "./useAnimatedNumber";
 export * from "./useAnimatedNumberMap";
 export * from "./useCountup";
+export * from "./suite";
+export { SPRING_PRESETS, springPreset, type SpringPresetRow, type SpringPresetName, } from "./springPresets";

package/dist/composables/motion/springPresets.d.ts

@@ -0,0 +1,33 @@
+/** A glass-ui named-spring preset name. */
+export type SpringPresetName = "smooth" | "snappy" | "bouncy" | "gentle" | "dock";
+/** One named-spring row: the analytic (response, dampingFraction) pair + its register doc. */
+export interface SpringPresetRow {
+    /** The token suffix — `--spring-<name>` (CSS) and the `MOTION_CURVES` key. */
+    readonly name: SpringPresetName;
+    /** Response time in seconds (the spring's `response` solver input). */
+    readonly response: number;
+    /** Damping fraction ζ (1 = critical; <1 overshoots). */
+    readonly dampingFraction: number;
+    /** The register this curve serves (the doc-table derives from this one string). */
+    readonly comment: string;
+}
+/**
+ * iOS-canonical (response, dampingFraction) pairs per AL-X4 §3. The names match
+ * the `--spring-*` CSS tokens AND the speedtest CSS consumers that read
+ * `var(--spring-smooth)` etc. directly, so they MUST stay stable across retunes —
+ * only the `(response, ζ)` pair and the emitted curves change.
+ *
+ * GOVERNED iOS-SPRING VOCABULARY (AX.W05) — the SINGLE source of the register
+ * vocabulary. Each row's `comment` names the surface-class that rides it:
+ *
+ *   SETTLE  → smooth  — patient entrances, fades, scale-ins (no overshoot read).
+ *   CONTROL → snappy  — crisp position morphs: tab underline glide, progress fill,
+ *                       the continuous-marker pop, the generic crisp settle.
+ *   PLAYFUL → bouncy  — deliberate emphatic one-shots ONLY: the bouncy toggle press,
+ *                       dialog/success entrances, the VT default. Largest overshoot.
+ *   GENTLE  → gentle  — critically-damped slow settles (the patient end of the ladder).
+ *   DOCK    → dock    — the dock expand/collapse morph AND everything inside it.
+ */
+export declare const SPRING_PRESETS: readonly SpringPresetRow[];
+/** Lookup one preset row by name (used by `MOTION_CURVES` spring rows). */
+export declare function springPreset(name: SpringPresetName): SpringPresetRow;

package/dist/composables/motion/suite.d.ts

@@ -0,0 +1,2 @@
+export { NumericAnimation, SpringProgress, SmoothProgress, Sequence, Timeline, ManualTimeline, RAFPlayback, ScrollTimeline, createNativeTimeline, flip, flipShared, ElementMorph, drag, Draggable, decay, decayRest, stagger, springTimingFunction, springLinearStops, toEasing, resolveEasing, AnimationOptionError, UnknownEasingError, loadAnimationEngine, } from "@mkbabb/keyframes.js";
+export type { Easing, TimingFunction, TimingFunctionNames, SpringProgressOptions, SpringFrameCallback, SpringSubscriber, SpringLinearStopsOptions, SpringTimingFunctionOptions, SmoothProgressOptions, NumericAnimationOptions, NumericFrameCallback, SequenceEntry, SequenceOptions, SequencePosition, TimelineOptions, NativeTimelineSpec, RAFPlaybackOptions, Tickable, FlipOptions, ElementMorphOptions, MorphRect, DragOptions, DragAxis, DragSubscriber, DecayOptions, DecaySample, StaggerFn, StaggerOptions, StaggerOrigin, AnimationEngine, AnimationOptions, AnimationFrame, AnimateOptions, InputAnimationOptions, ResolvedKeyframes, Vars, } from "@mkbabb/keyframes.js";

package/dist/composables/motion/useSpringMount.d.ts

@@ -1,6 +1,6 @@
 import { type Ref } from "vue";
 import { type SpringRef } from "./useSpring";
-/** Named iOS spring presets (mirrors X1 §2.3 / tokens.css §2). */
+/** Named iOS spring presets the mount register exposes (the dock register is not a mount enter). */
 export type SpringPreset = "smooth" | "snappy" | "bouncy" | "gentle";
 export interface UseSpringMountOptions {
     /**

package/dist/configurator.js

@@ -1,2 +1,2 @@
-import { a as e, i as t, n, o as r, r as i, s as a, t as o } from "./useConfiguratorState-DxAqksK6.js";
+import { a as e, i as t, n, o as r, r as i, s as a, t as o } from "./useConfiguratorState-BdQXh9ie.js";
 export { e as CONFIGURATOR_DENSITY_KEY, t as Configurator, i as ConfiguratorLayer, n as ConfiguratorRow, r as provideConfiguratorDensity, o as useConfiguratorState, a as useOptionalConfiguratorDensity };

package/dist/confirm-dialog.js

@@ -1,6 +1,6 @@
 import { t as e } from "./createLucideIcon-B6uNAU9G.js";
-import { n as t } from "./button-DN39cGqL.js";
-import { t as n } from "./_plugin-vue_export-helper-ok8pgSl5.js";
+import { n as t } from "./button-DyiWFAOE.js";
+import { t as n } from "./_plugin-vue_export-helper-DWghtRt7.js";
 import { Transition as r, createBlock as i, createCommentVNode as a, createElementBlock as o, createElementVNode as s, createTextVNode as c, createVNode as l, defineComponent as u, mergeModels as d, openBlock as f, renderSlot as p, toDisplayString as m, unref as h, useModel as g, withCtx as _, withKeys as v, withModifiers as y } from "vue";
 var b = e("loader-circle", [["path", {
 	d: "M21 12a9 9 0 1 1-6.219-8.56",