@mkbabb/glass-ui 5.0.0 → 7.0.0

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

@@ -1,72 +0,0 @@
-import { type Ref } from "vue";
-/**
- * The three barbell silhouette elements the engine projects per frame. NOT
- * `morph.children[i]` index-reaching (the fragile KISS-violating path) — three EXPLICIT
- * refs the consumer renders + binds.
- */
-export interface GooBarbellRefs {
-    /** The trailing round body (the OUTGOING droplet). */
-    bodyARef: Ref<HTMLElement | null>;
-    /** The leading round body (the INCOMING droplet). */
-    bodyBRef: Ref<HTMLElement | null>;
-    /** The welling concave-throat neck between the two bodies. */
-    neckRef: Ref<HTMLElement | null>;
-}
-export interface UseGooMorphParams {
-    /**
-     * The barbell silhouette refs — two round bodies + a welling concave neck. The engine
-     * writes their three transforms each frame (the merge needs ≥2 masses; the neck is the
-     * bridge). NO single-element `morphRef` — the barbell IS the morph.
-     */
-    barbellRefs: GooBarbellRefs;
-    /** The geometry origin + the `--goo-t` transition host (the rail/track root). */
-    hostRef: Ref<HTMLElement | null>;
-    /** Travel axis. `false` → horizontal (translateX), `true` → vertical (translateY). */
-    vertical: Ref<boolean>;
-    /**
-     * Live center reader: the on-axis center (px, relative to the host content box)
-     * of slot `i`, on the travel axis. MEASURED off the live DOM (windowFit-correct,
-     * both axes) — never a hardcoded pitch.
-     */
-    centerOf: (i: number) => number | null;
-    /**
-     * The resting slot pitch (px) on the travel axis. The barbell body diameter is the
-     * golden-minor `D = restSize()/φ` (a BLOB, not a plate) — so the consumer passes the
-     * slot STEP, not a pre-shrunk body size.
-     */
-    restSize: () => number;
-    /**
-     * The token prefix for the flow/duration/max-stretch reads. Default `"pager-worm"`
-     * (the dot-pip register). The carousel passes `"carousel-goo"`; the deck `"deck-goo"`
-     * — each reads its OWN `--{prefix}-flow`/`-duration`/`-max-stretch` so a card-scale
-     * barbell dwells/swells at its own scale, the dot at its own. ONE engine, per-consumer
-     * tokens (the no-new-spring fence — they all resolve `--spring-*`-derived `linear()`).
-     */
-    tokenPrefix?: string;
-    /**
-     * The neck-gap fraction — how near the two bodies draw at the midpoint (sep's floor:
-     * 1 at the slots → `neckGap` at mid). Lower = the bodies near closer → a tighter,
-     * gooier waist. Default 0.78 (carousel). Pager 0.7, deck 0.85. (= `--{prefix}-neck-gap`
-     * if the consumer prefers a token; the param is the engine default.)
-     */
-    neckGap?: number;
-}
-export interface UseGooMorphReturn {
-    /**
-     * Travel the barbell from `from` to `to` (slot indices). Sets the `--goo-t`
-     * transition target (the spring glides it) and runs a short rAF that projects the
-     * interpolated scalar onto the three-element barbell each frame. PRM → instant snap to
-     * ONE resting body, no squish.
-     */
-    travel(from: number, to: number): void;
-    /** Snap the barbell to ONE resting body on `index` immediately (first paint / resize / PRM). */
-    snap(index: number): void;
-    /**
-     * Drag-driven continuous drive: set `--goo-t` DIRECTLY to a fractional slot position
-     * (the live drag scrollProgress, e.g. embla's `scrollProgress()*lastIndex`) with NO
-     * transition, and project the barbell for it. The neck wells with the live drag; call
-     * `travel()` on the snap to glide the release. PRM → snap.
-     */
-    drive(fractionalIndex: number): void;
-}
-export declare function useGooMorph(params: UseGooMorphParams): UseGooMorphReturn;

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

@@ -1,41 +0,0 @@
-export type TaskPriority = "user-blocking" | "user-visible" | "background";
-export interface PostTaskOptions {
-    /** Scheduling priority. Defaults to the platform default ('user-visible'). */
-    priority?: TaskPriority;
-    /** Abort the task before it runs (rejects the returned promise). */
-    signal?: AbortSignal;
-    /** Delay in ms before the task becomes eligible to run. */
-    delay?: number;
-}
-/**
- * Schedule `callback` at an explicit priority, resolving with its result.
- * Native `scheduler.postTask` when available; otherwise a `MessageChannel`
- * macrotask (honouring `delay` via `setTimeout`, and `signal` via a plain
- * `AbortSignal` check) that cannot order by priority but still runs off the
- * current task.
- *
- * @example
- *   await postTaskSafe(() => recomputeHistory(), { priority: "background" });
- */
-export declare function postTaskSafe<T>(callback: () => T, options?: PostTaskOptions): Promise<T>;
-export interface UsePrioritizedTaskReturn {
-    /**
-     * Schedule a unit of work. The controller's `signal` is merged in (its own
-     * `abort()` cancels every task it scheduled), and an explicit `options.signal`
-     * still applies on the fallback path.
-     */
-    postTask: <T>(callback: () => T, options?: PostTaskOptions) => Promise<T>;
-    /** Abort every task scheduled through this controller. */
-    abort: (reason?: unknown) => void;
-}
-/**
- * Composable wrapper over {@link postTaskSafe} that owns a `TaskController`
- * (when supported) so a single `abort()` cancels every task it scheduled — the
- * controller a consumer constructs once and tears down on unmount. When
- * `TaskController` is absent the controller is a no-op shell and per-task
- * `options.signal` is the only cancellation channel.
- *
- * Pure-native (no `vue` import) — owns no reactive state and no lifecycle, so it
- * has no cleanup obligation beyond the `abort()` the consumer calls itself.
- */
-export declare function usePrioritizedTask(priority?: TaskPriority): UsePrioritizedTaskReturn;

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

@@ -1,52 +0,0 @@
-interface StaggerRevealConfig {
-    /** Delay between each target becoming `revealed`. Default 60ms. */
-    staggerMs?: number;
-    /** When true (default), a target stays revealed after first entering the viewport. */
-    once?: boolean;
-    /** IntersectionObserver rootMargin. Default `0px`. */
-    rootMargin?: string;
-    /** IntersectionObserver threshold. Default 0.15. */
-    threshold?: number;
-}
-/**
- * Sequence entrance animations for a list/grid. Each registered target
- * gets a staggered `revealed` flag once it crosses the viewport threshold.
- * Consumers bind the flag to a Tailwind class (e.g. `opacity-100 translate-y-0`)
- * and let CSS transitions handle the visual entry.
- *
- * AQ.W5: on an engine with native `view()` timelines, no `IntersectionObserver`
- * is constructed — prefer the `[data-scroll-reveal]` CSS recipe
- * (scroll-driven.css). This composable is the feature-detected fallback (the
- * sole writer when the native feature is absent); under native, `register()`
- * reveals immediately so the terminal state is correct and the CSS animates.
- */
-export declare function useStaggerReveal(options?: StaggerRevealConfig): {
-    targets: import("vue").Ref<HTMLElement[], HTMLElement[]>;
-    register: (el: HTMLElement | null, index?: number) => void;
-    revealed: Record<number, boolean>;
-};
-/**
- * The `[data-scroll-reveal-once]` latch — BC.W-MOTION-PRESETS.
- *
- * The `scroll-driven.css` `[data-scroll-reveal]` recipe rides a native `view()`
- * timeline that RE-FIRES its entrance every time a child re-enters the entry range
- * — wrong for a virtualized/teleporting list (a row scrolls out + back and re-plays
- * the fade-lift). A `view()` timeline cannot latch "play once" (the CSS limit), so
- * the `[data-scroll-reveal-once]` opt-in plays the entrance ONCE: this directive
- * adds `data-revealed=""` to each child on its FIRST cross and `unobserve`s it (the
- * SAME `once: true` discipline `useStaggerReveal` runs above — `if (once)
- * observer?.unobserve(el)`); the CSS plays the one-shot `gl-reveal-once` keyframe
- * keyed off `[data-revealed]`, NOT the live `view()` range. NO second observer
- * engine — the same `IntersectionObserver` the composable speaks for the `once`
- * case, packaged as a Vue directive a consumer binds on the scroller.
- *
- * On an engine without `IntersectionObserver` (SSR/old) it reveals immediately so
- * the terminal state is correct (the CSS animation simply never plays). Under PRM
- * the scroll-driven.css `@media` outer gate drops the entrance and the row paints
- * in-place (a flourish — the reveal carve, not a legibility cue).
- */
-export declare const vScrollRevealOnce: {
-    mounted(scroller: HTMLElement): void;
-    unmounted(scroller: HTMLElement): void;
-};
-export {};

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

@@ -1,81 +0,0 @@
-/** Options for `startViewTransition`. `types` (Chrome 140+, absent on Firefox
- *  144) tag the active transition so `:active-view-transition-type(<t>)` CSS can
- *  author DIRECTION-specific curves. Feature-detected — when the engine lacks the
- *  object-with-`types` overload the call degrades to the plain-callback form
- *  (one symmetric curve), which is functionally identical (the swap still runs). */
-export interface ViewTransitionOptions {
-    types?: string[];
-    /**
-     * BA.W-ATLAS-RECONCILE A-4b — take the JS-level INSTANT path under
-     * `prefers-reduced-motion: reduce` (run `mutate` directly, NO snapshot
-     * captured). The HEAD default pushes PRM to CSS only (`view-transition.css`
-     * sets `animation: none` on the VT pseudos) — but that STILL captures a
-     * snapshot. For the navigation case a reduced-motion user wants the swap to
-     * happen with no transition machinery at all; `navigate()` sets this true.
-     * Defaults to `false` so the existing sync-VT consumers (muster J.W5 row
-     * re-rank) keep their exact CSS-handled PRM behaviour. @default false
-     */
-    instantUnderReducedMotion?: boolean;
-}
-export interface ViewTransitionResult {
-    /**
-     * Resolves when the transition's `finished` promise settles (or
-     * immediately in the fallback path). Use to route focus per the a11y
-     * MANDATORY: `await startViewTransition(mutate).finished; el.focus()`.
-     * Never rejects — a skipped/aborted transition settles cleanly.
-     */
-    finished: Promise<void>;
-    /** True when the native API ran; false when the instant fallback ran. */
-    transitioned: boolean;
-}
-/**
- * True when `document.startViewTransition` is available — the feature-detected
- * predicate consumers gate optional VT-only styling on.
- */
-export declare function supportsViewTransitions(): boolean;
-/**
- * Wrap a synchronous DOM mutation in `document.startViewTransition` with an
- * instant fallback. `mutate` performs the DOM/state change and is called
- * synchronously in BOTH paths (native and fallback), so the post-mutation DOM
- * is identical regardless of support.
- *
- * @param mutate the synchronous DOM/state change to animate between.
- * @param options optional `{ types }` — directional transition types tagged on
- *   the active transition for `:active-view-transition-type(<t>)` CSS curves
- *   (Chrome 140+; feature-detected, degrades to one symmetric curve elsewhere).
- * @returns `{ finished, transitioned }` — await `finished` to route focus.
- *
- * @example
- *   const { finished } = startViewTransition(() => { rows.value = reranked });
- *   await finished;            // animation done
- *   firstRow.value?.focus();   // consumer routes focus (the a11y MANDATORY)
- *
- * @example
- *   // directional intent — snappier exit on collapse, softer entry on expand
- *   startViewTransition(() => mutate(), { types: ["dock-expand"] });
- */
-export declare function startViewTransition(mutate: () => void | Promise<void>, options?: ViewTransitionOptions): ViewTransitionResult;
-/** Options for `navigate` — the directional transition `types` (Chrome 140+,
- *  feature-detected; tag `["forward"]`/`["back"]` off the navigation direction). */
-export type NavigateOptions = ViewTransitionOptions;
-/**
- * Run a (possibly ASYNC) navigation callback wrapped in a View Transition, with
- * the reduced-motion + unsupported instant-paths. The navigation ALWAYS runs
- * (awaited); the morph is conditional on support + motion preference. Returns the
- * same `{ finished, transitioned }` contract — `await navigate(go).finished` then
- * route focus (the a11y MANDATORY).
- *
- * @example  the card → masthead route morph
- *   // both the card title + masthead title carry
- *   //   view-transition-class: gl-shared-element; view-transition-name: dash-title
- *   await navigate(() => router.push(`/${slug}`), { types: ["forward"] }).finished;
- *   mastheadTitle.value?.focus();
- */
-export declare function navigate(nav: () => void | Promise<void>, options?: NavigateOptions): ViewTransitionResult;
-/**
- * True when the route-transition morph can run (native VT available). A consumer
- * gates VT-only navigation styling on this (alias of `supportsViewTransitions`
- * named for the navigation call site). Under reduced motion the `navigate` helper
- * still takes the instant path even when this is `true`.
- */
-export declare function supportsRouteTransitions(): boolean;

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

@@ -1,4 +0,0 @@
-export { useVirtualSectionWindow, clearSessionHeightCache, } from "./useVirtualSectionWindow";
-export { useWindowedStore } from "./useWindowedStore";
-export { buildSectionLayout, findSectionOffset, resolveActiveSection, resolveSectionWindow, } from "./virtualSectionLayout";
-export type { FlatSection, SectionLayout, SectionWindowRange, ForcedSectionWindowRange, } from "./virtualSectionLayout";

package/dist/composables/virtual/useVirtualSectionWindow.d.ts

@@ -1,72 +0,0 @@
-import { type MaybeRefOrGetter, type Ref } from "vue";
-import type { FlatSection } from "./virtualSectionLayout";
-/**
- * Lineage: a glass-ui primitive at v0.9.4, retired at v1.0 (MIGRATION.md §3.2),
- * carried on as a verbatim transposed copy in the words app, and HOME again at
- * BC (the live words consumer + the dock-search results list overturn the
- * no-consumer retirement verdict). Byte-faithful to the proven words copy save
- * the recorded refinements: the container/content ResizeObservers route through
- * the house `useResizeObserver` leaf (cleanup discipline) instead of raw
- * `new ResizeObserver`, and `findSectionOffset` is the binary-search variant.
- */
-interface VirtualWindowConfig<T extends FlatSection = FlatSection> {
-    /** The flat list of section items to virtualize. */
-    items: MaybeRefOrGetter<readonly T[]>;
-    /**
-     * The element whose scroll position drives the window.
-     * `null` = use `window` / document scroll.
-     */
-    scrollContainer: Ref<HTMLElement | null>;
-    /**
-     * The wrapper element around the virtualized content.
-     * When provided, scroll offset is computed relative to this element's
-     * position in the page, so content above it (headers, images, etc.)
-     * is correctly excluded from the layout calculation.
-     */
-    contentEl?: Ref<HTMLElement | null>;
-    /** Overscan before the viewport in pixels. Default: viewport height. */
-    overscanBeforePx?: number;
-    /** Overscan after the viewport in pixels. Default: 2x viewport height. */
-    overscanAfterPx?: number;
-    /** Number of items to warm before a target when using `ensureTargetWindow`. Default: 2. */
-    warmTargetBefore?: number;
-    /** Number of items to warm after a target when using `ensureTargetWindow`. Default: 3. */
-    warmTargetAfter?: number;
-}
-/**
- * Evict every cached measured section height. The documented escape for a
- * consumer that wants to drop the module-global `SESSION_HEIGHT_CACHE` (a
- * font-size change, a layout reflow that invalidates prior measurements).
- */
-export declare function clearSessionHeightCache(): void;
-/**
- * Scroll-based virtual windowing composable for section lists.
- *
- * Renders only the items visible in (or near) the scroll viewport,
- * using spacer divs to maintain correct scroll height. Supports:
- *
- * - Measured heights: call `measureSection(id, el)` from a template ref
- *   to replace estimated heights with real DOM measurements.
- * - Warm targeting: call `ensureTargetWindow(id)` to force an item into
- *   the render window before scrolling to it (auto-releases after 320ms).
- * - Active tracking: `activeId` / `activeRootId` report which section
- *   is currently at the 20% viewport mark. NOTE — this is the windowing-LOCAL
- *   render-active reader; a ToC/sidebar consumer reads `useScrollTracker`'s
- *   `activeId` (the deepest-visible reader) for the binding highlight. The two
- *   serve distinct concerns and are deliberately NOT one function
- *   (BC.W-VIRTUAL-WINDOW active-section reconcile).
- * - Content offset: provide `contentEl` to correctly handle non-virtualized
- *   content (headers, banners) above the virtual list.
- */
-export declare function useVirtualSectionWindow<T extends FlatSection>(options: VirtualWindowConfig<T>): {
-    visibleItems: import("vue").ComputedRef<T[]>;
-    topSpacerPx: import("vue").ComputedRef<number>;
-    bottomSpacerPx: import("vue").ComputedRef<number>;
-    measureSection: (id: string, el: HTMLElement | null) => void;
-    ensureTargetWindow: (id: string) => void;
-    getOffsetFor: (id: string) => number | null;
-    activeId: import("vue").ComputedRef<any>;
-    activeRootId: import("vue").ComputedRef<any>;
-    recalculate: () => void;
-};
-export {};

package/dist/composables/virtual/useWindowedStore.d.ts

@@ -1,43 +0,0 @@
-import { type Ref, type ShallowRef } from "vue";
-/**
- * Lineage: a glass-ui primitive at v0.9.4, retired at v1.0 (MIGRATION.md §3.3),
- * carried on as a verbatim transposed copy in the words app, and HOME again at
- * BC (the words wordlist store is the live consumer the no-consumer retirement
- * verdict missed). Byte-faithful to the proven words copy — the
- * generation-counter stale-append rejection is the load-bearing concurrency
- * primitive, preserved verbatim.
- */
-interface ResidentWindowConfig {
-    /** Maximum items to keep in memory. Default: 200. */
-    maxResident?: number;
-}
-interface ResidentWindowState<T> {
-    /** Currently loaded items (a sliding window of the full list). */
-    items: ShallowRef<T[]>;
-    /** Logical offset of `items[0]` in the full list. */
-    windowStart: Ref<number>;
-    /** Generation counter -- increments on each reset. Used to reject stale appends. */
-    generation: Ref<number>;
-    /** Append or replace items. `replace=true` resets window; `replace=false` appends with eviction from front. */
-    set(newItems: T[], replace?: boolean): void;
-    /** Prepend items before the current window. Evicts from the end if over `maxResident`. */
-    prepend(newItems: T[], newWindowStart: number): void;
-    /** Clear all items and reset window. */
-    clear(): void;
-    /**
-     * Append items only if the generation matches (i.e., no reset happened since the fetch started).
-     * Returns `true` if the append was accepted, `false` if rejected (stale).
-     */
-    appendIfCurrent(newItems: T[], expectedGeneration: number): boolean;
-}
-/**
- * Sliding-window store primitive for paginated / infinite-scroll data.
- *
- * Supports both forward (append) and backward (prepend) loading.
- * When items exceed `maxResident`, trims from the opposite end.
- *
- * Uses a generation counter to reject stale appends after a backward reset,
- * preventing race conditions between concurrent page fetches.
- */
-export declare function useWindowedStore<T>(options?: ResidentWindowConfig): ResidentWindowState<T>;
-export {};

package/dist/composables/virtual/virtualSectionLayout.d.ts

@@ -1,103 +0,0 @@
-/**
- * Pure layout computation functions for virtual section scrolling.
- *
- * These are stateless — they take data in, return layout info out.
- * No Vue reactivity, no DOM access.
- *
- * Lineage: this engine was a glass-ui primitive at v0.9.4, retired at v1.0
- * (MIGRATION.md §3.4 — "0 production consumers, demo-only"), and lived on as
- * a verbatim transposed copy in the words app. The retirement is REVERSED at
- * BC: the live words consumer + the dock-search results list overturn the
- * no-consumer verdict, so the windowing engine comes HOME. Byte-faithful to
- * the proven words copy except the one functional refinement recorded below
- * (`findSectionOffset` binary search) and the shared-hierarchy type-reconcile.
- */
-import type { SectionHierarchy } from "../sidebar/types";
-/**
- * A flattened section item with hierarchy metadata for virtual scrolling.
- *
- * The four hierarchy fields (`depth`/`rootId`/`parentId`/`rootIndex`) come
- * from the shared `SectionHierarchy` base (`composables/sidebar/types`) — the
- * same fields the sidebar's `TreeIndexEntry` carries, declared ONCE. The
- * producer (`flattenPaperSections` in latex-paper, the dock-search result
- * flattener) builds these in the consumer; glass-ui owns only the contract.
- */
-export interface FlatSection extends SectionHierarchy {
-    id: string;
-    index: number;
-    estimatedHeight: number;
-}
-/** A single entry in a computed section layout with resolved position. */
-interface VirtualLayoutEntry<T extends FlatSection = FlatSection> {
-    item: T;
-    height: number;
-    top: number;
-    bottom: number;
-}
-/** Complete layout for a list of sections — entries plus total height. */
-export interface SectionLayout<T extends FlatSection = FlatSection> {
-    entries: VirtualLayoutEntry<T>[];
-    totalHeight: number;
-    /**
-     * Entry slots sorted ascending by `item.id`, so `findSectionOffset` can
-     * binary-search an arbitrary string id in O(log n) (the words copy
-     * linear-scanned `entries` — `virtualSectionLayout.ts:244-252`). Built
-     * once in `buildSectionLayout`; the `top` is read straight off the matched
-     * entry, so the offset answer is byte-identical to the linear scan.
-     */
-    byId: VirtualLayoutEntry<T>[];
-}
-/** The visible window range with spacer sizes for virtual scrolling. */
-export interface SectionWindowRange {
-    startIndex: number;
-    endIndex: number;
-    topSpacerPx: number;
-    bottomSpacerPx: number;
-}
-/** A forced index range that must be included in the visible window. */
-export interface ForcedSectionWindowRange {
-    startIndex: number;
-    endIndex: number;
-}
-/**
- * Build a layout from a flat list of sections using a height resolver.
- *
- * Each entry gets an absolute `top` and `bottom` offset in pixels,
- * computed sequentially from index 0. Heights are rounded and clamped >= 1.
- */
-export declare function buildSectionLayout<T extends FlatSection>(items: readonly T[], getHeight: (item: T) => number): SectionLayout<T>;
-/**
- * Resolve which section indices are visible given scroll state.
- *
- * Uses binary search for O(log n) lookup. Overscan extends the window
- * before and after the viewport. An optional `forcedRange` guarantees
- * certain indices are always included (used for warm-up targeting).
- */
-export declare function resolveSectionWindow<T extends FlatSection>(layout: SectionLayout<T>, scrollTopPx: number, viewportHeightPx: number, overscanBeforePx: number, overscanAfterPx: number, forcedRange?: ForcedSectionWindowRange | null): SectionWindowRange;
-/**
- * Find the section that is "active" at a given scroll offset.
- *
- * Returns the last section whose top edge is at or before `activeOffsetPx`.
- *
- * NOTE — this is the windowing-LOCAL render-active reader (the section at the
- * 20%-viewport mark, used to label the current render window). It is NOT the
- * ToC's binding active-section reader: a sidebar/ToC consumer reads
- * `useScrollTracker.activeId` (the deepest-visible reader) for the highlight.
- * The two serve distinct concerns and are deliberately NOT one function
- * (BC.W-VIRTUAL-WINDOW active-section reconcile).
- */
-export declare function resolveActiveSection<T extends FlatSection>(layout: SectionLayout<T>, activeOffsetPx: number): T | null;
-/**
- * Find the pixel offset of a section by its `id`.
- * Returns `null` if the section is not in the layout.
- *
- * REFINEMENT (BC.W-VIRTUAL-WINDOW): the words copy linear-scans `entries`
- * matching on `id` (O(n), `virtualSectionLayout.ts:244-252`). Here we binary
- * search `layout.byId` — the entries sorted ascending by `item.id` in
- * `buildSectionLayout` — which is a total order over the string ids, so the
- * search is correct + O(log n). The `top` is read straight off the matched
- * entry, so the answer is byte-identical to the linear scan (the fixture pins
- * this over a 1000-item layout).
- */
-export declare function findSectionOffset<T extends FlatSection>(layout: SectionLayout<T>, id: string): number | null;
-export {};

package/dist/controls.d.ts

@@ -1 +0,0 @@
-export * from "./components/controls";

package/dist/controls.js

@@ -1,91 +0,0 @@
-import { t as e } from "./class-names-5jotTFzp.js";
-import { t } from "./_plugin-vue_export-helper-C1je1s0u.js";
-import { t as n } from "./useGlobalDark-DjKMEQE2.js";
-import { computed as r, createBlock as i, createElementVNode as a, defineComponent as o, mergeProps as s, openBlock as c, ref as l, resolveDynamicComponent as u, useAttrs as d, watchEffect as f, withCtx as p } from "vue";
-//#endregion
-//#region src/components/controls/DarkModeToggle.vue
-var m = /* @__PURE__ */ t(/* @__PURE__ */ o({
-	inheritAttrs: !1,
-	__name: "DarkModeToggle",
-	props: {
-		passive: {
-			type: Boolean,
-			default: !1
-		},
-		size: { default: "md" },
-		disableTransitions: {
-			type: Boolean,
-			default: !1
-		},
-		eclipse: {
-			type: Boolean,
-			default: !1
-		}
-	},
-	setup(t) {
-		let o = t, m = d(), h = l(!1), g = typeof matchMedia < "u" && matchMedia("(prefers-reduced-motion: reduce)").matches, _ = null, v = !1;
-		function y() {
-			_ !== null && (clearTimeout(_), _ = null);
-		}
-		function b() {
-			!o.eclipse || o.passive || (v = !1, y(), _ = setTimeout(() => {
-				v = !0, _ = null, g || (h.value = !0, window.setTimeout(() => h.value = !1, 1700)), T();
-			}, 460));
-		}
-		function x() {
-			y();
-		}
-		function S(e) {
-			if (o.eclipse && v) {
-				e.preventDefault(), e.stopPropagation(), v = !1;
-				return;
-			}
-			o.passive || T();
-		}
-		let C = r(() => e("dark-mode-toggle-button", "relative isolate inline-flex shrink-0 items-center justify-center", "cursor-pointer border-0 bg-transparent", "rounded-pill", "opacity-80", "focus-ring", m.class)), { isDark: w, toggleDark: T, setDisableTransitions: E } = n(), D = r(() => {
-			let { class: e, ...t } = m;
-			return o.passive ? t : {
-				type: "button",
-				"aria-label": w.value ? "Switch to light mode" : "Switch to dark mode",
-				"aria-pressed": w.value ? "true" : "false",
-				...t
-			};
-		});
-		return f(() => {
-			E(o.disableTransitions);
-		}), (e, n) => (c(), i(u(t.passive ? "div" : "button"), s({
-			class: C.value,
-			"data-size": o.size,
-			"data-eclipsing": t.eclipse && h.value ? "true" : void 0
-		}, D.value, {
-			onClick: S,
-			onPointerdown: b,
-			onPointerup: x,
-			onPointerleave: x,
-			onPointercancel: x
-		}), {
-			default: p(() => [...n[0] ||= [a("svg", {
-				xmlns: "http://www.w3.org/2000/svg",
-				viewBox: "0 0 472.39 472.39",
-				class: "block h-full w-full fill-foreground"
-			}, [a("g", {
-				class: "toggle-sun",
-				"data-allow-motion": ""
-			}, [a("path", { d: "M403.21,167V69.18H305.38L236.2,0,167,69.18H69.18V167L0,236.2l69.18,69.18v97.83H167l69.18,69.18,69.18-69.18h97.83V305.38l69.18-69.18Zm-167,198.17a129,129,0,1,1,129-129A129,129,0,0,1,236.2,365.19Z" })]), a("g", {
-				class: "toggle-circle",
-				"data-allow-motion": ""
-			}, [a("circle", {
-				cx: "236.2",
-				cy: "236.2",
-				r: "90"
-			})])], -1)]]),
-			_: 1
-		}, 16, [
-			"class",
-			"data-size",
-			"data-eclipsing"
-		]));
-	}
-}), [["__scopeId", "data-v-8e7fc1f3"]]);
-//#endregion
-export { m as DarkModeToggle };