@yewdiel21/motion-kit 0.0.0-stage → 0.9.0

package/dist/reveal-WFUWDrei.d.ts

@@ -0,0 +1,416 @@
+import { I as Instance } from './types-BkS_raL8.js';
+
+type DialogVariant = 'morph' | 'liquid' | 'sheet';
+type DialogPlacement = 'center' | 'anchor' | 'side';
+interface DialogLabels {
+    close?: string;
+    float?: string;
+    dock?: string;
+}
+interface DialogOptions {
+    /** morph (Stepbro, default), liquid (Stepbro), or sheet: rises from the bottom and pushes [data-mk-underlay] back (Dousan). */
+    variant?: DialogVariant;
+    placement?: DialogPlacement;
+    /** Tinted backdrop; false leaves it transparent (menus). */
+    backdrop?: boolean;
+    closeOnBackdrop?: boolean;
+    /** Drag (or wheel) down to dismiss. */
+    drag?: boolean;
+    /** A key turns on the floating window (desktop) and remembers its place. */
+    float?: string | false;
+    autoResize?: boolean;
+    /** `[data-mk-open="<id>"]` buttons open it: true uses the dialog's id; a string names another id; false: none. */
+    triggers?: boolean | string;
+    /** Modal (default) or a non-modal dialog. */
+    modal?: boolean;
+    labels?: DialogLabels;
+    /** Grow the content with the surface (default). Menus turn it off and cascade their items instead. */
+    animateContent?: boolean;
+    onOpen?: () => void;
+    /** After it closed, whatever closed it. */
+    onClose?: () => void;
+}
+interface DialogInstance extends Instance {
+    /** `origin`: the control it grows from; omitted, the focused control; null, none (scale-in). */
+    open(origin?: HTMLElement | null): void;
+    close(): void;
+    toggle(origin?: HTMLElement | null): void;
+    float(): void;
+    dock(): void;
+    readonly isOpen: boolean;
+    readonly isFloating: boolean;
+    readonly element: HTMLElement;
+}
+declare function createDialog(dialog: HTMLElement | null, options?: DialogOptions): DialogInstance;
+
+interface MenuOptions extends Omit<DialogOptions, 'placement' | 'backdrop' | 'drag' | 'autoResize' | 'animateContent'> {
+    ticket?: boolean;
+    /** Close after an option is chosen (default). */
+    closeOnSelect?: boolean;
+    onSelect?: (value: string, item: HTMLElement) => void;
+}
+interface MenuInstance extends DialogInstance {
+    readonly items: HTMLElement[];
+}
+declare function createMenu(dialog: HTMLElement | null, options?: MenuOptions): MenuInstance;
+
+/**
+ * Every Stepbro duration in one place (seconds, like GSAP, unless the name says
+ * ms). Recipes and components take their defaults from here, so a timing is
+ * changed once. Sources: Stepbro replication kit, tasks/especificacion-replicacion.json
+ * and money/replication-catalog.json.
+ */
+declare const TIMING: Readonly<{
+    flow: 0.5;
+    flowStagger: 0.05;
+    stepChange: 0.5;
+    reveal: Readonly<{
+        readonly fast: readonly [0.5, 0.25];
+        readonly normal: readonly [0.7, 0.35];
+        readonly slow: readonly [1.05, 0.5];
+        readonly slower: readonly [1.6, 0.75];
+    }>;
+    details: 0.32;
+    chevron: 0.25;
+    indicator: 0.45;
+    number: 0.6;
+    numberPricing: 0.7;
+    revealCounter: 0.9;
+    layoutTravel: 0.62;
+    /** New items in a reflow enter in this share of the travel time. */
+    layoutEnterFactor: 0.6;
+    menu: Readonly<{
+        duration: 0.35;
+        stagger: 0.04;
+        delay: 0.1;
+    }>;
+    palette: Readonly<{
+        duration: 0.1;
+        stagger: 0.01;
+    }>;
+    form: Readonly<{
+        duration: 0.35;
+        stagger: 0.04;
+    }>;
+    landing: Readonly<{
+        duration: 0.4;
+        stagger: 0.05;
+        delay: 0.15;
+    }>;
+    content: Readonly<{
+        duration: 0.6;
+        stagger: 0.06;
+    }>;
+    bubble: 0.7;
+    bubbleStagger: 0.06;
+    word: 0.25;
+    wordStagger: 0.05;
+    chatScroll: 0.35;
+    composer: 0.18;
+    slot: Readonly<{
+        durationMs: 300;
+        staggerMs: 45;
+        exitOffsetMs: 50;
+        colorFadeMs: 280;
+        maxTilt: 5;
+        minResizeMs: 140;
+    }>;
+    swatch: 0.5;
+    swatchLight: 3.5;
+    swatchBackground: 4.5;
+    /** ModalHost (modal-origin, modal-close-origin, modal-fallback, modal-auto-resize). */
+    dialog: Readonly<{
+        /** The surface travels from its opener. */
+        open: 0.7;
+        /** The opener's colour hands over to the surface's. */
+        surfaceColor: 0.3;
+        /** Back into the opener. */
+        close: 0.5;
+        /** While closing, the content heads for the opener on a 2 s path cut at `close`. */
+        contentReturn: 2;
+        originHide: 0.08;
+        originShow: 0.3;
+        originShowDelay: 0.2;
+        /** No opener on screen: scale .92 → 1. */
+        fallback: 0.35;
+        autoResize: 0.45;
+        /** Backdrop tint on the signature curve. */
+        backdrop: 0.5;
+        /** Items of a list that opens from its control. */
+        list: 0.25;
+    }>;
+    /** modal-liquid (spring channels; springs are stiffness/damping, not times). */
+    liquid: Readonly<{
+        size: 0.3;
+        radius: 0.7;
+        content: 0.3;
+        color: 0.4;
+        colorDelay: 0.15;
+        ghost: 0.25;
+        ghostDelay: 0.05;
+        closeSize: 0.25;
+        closeContent: 0.3;
+        originRestore: 0.3;
+        originRestoreDelay: 0.2;
+        safetyMs: 1100;
+    }>;
+    /** modal-drag: the spring back when a drag is not far enough. */
+    drag: Readonly<{
+        restore: 0.5;
+        radiusRestore: 0.3;
+    }>;
+    /** modal-float. */
+    float: Readonly<{
+        shadow: 0.45;
+        glideDecay: 0.18;
+        sizeSmoothing: 0.08;
+    }>;
+    /** chat-loader-delay, chat-confirmation-bar. */
+    chat: Readonly<{
+        pendingDelayMs: 500;
+        confirmWordStagger: 0.1;
+    }>;
+    /** onboarding-busy-background, step-change, onboarding-reveal-counter. */
+    onboarding: Readonly<{
+        busy: 0.8;
+        idle: 0.6;
+        step: 0.5;
+        counter: 0.9;
+    }>;
+    /** task-drag: lift, land (FA .62), crossfade (66 % of the land), neighbours shifting (FA .52). */
+    sortable: Readonly<{
+        lift: 0.18;
+        land: 0.42;
+        landFade: number;
+        shift: 0.62;
+    }>;
+    /** toast-deck, toast-morph, toast-character-reveal. */
+    toast: Readonly<{
+        relayout: 0.6;
+        expand: 0.55;
+        expandStagger: 0.06;
+        enter: 0.5;
+        exit: 0.3;
+        collapseDelayMs: 150;
+        morphSize: 0.32;
+        morphRadius: 0.7;
+        morphContent: 0.32;
+        morphColor: 0.4;
+        morphColorDelay: 0.15;
+        morphShadow: 0.6;
+        morphShadowDelay: 0.05;
+        safetyMs: 1100;
+        chars: 0.4;
+        charsDelay: 0.225;
+        charsStagger: 0.02;
+    }>;
+    /** Dousan's glass (CSS): surface/shadow transitions, ring and shine. */
+    glass: Readonly<{
+        hover: 0.4;
+        ring: 0.5;
+    }>;
+    /** Stepbro's utility animations (css/effects/anim.css), by name. */
+    effects: Readonly<{
+        out: 0.5;
+        'out-left': 0.5;
+        'out-bottom': 0.5;
+        collapse: 0.25;
+        highlight: 1;
+        shake: 0.5;
+        'shake-strong': 0.4;
+        fade: 0.3;
+        wipe: 0.7;
+        'progress-in': 1;
+    }>;
+    /** Dousan's success confetti, per 60 fps frame. */
+    confetti: Readonly<{
+        count: 45;
+        speed: readonly [2, 8];
+        lift: 2;
+        radius: readonly [3, 7];
+        decay: readonly [0.015, 0.03];
+        gravity: 0.15;
+        drag: 0.98;
+        spin: 2.5;
+    }>;
+    /** Dousan's project sheet. */
+    sheet: Readonly<{
+        open: 0.72;
+        close: 0.72;
+        underlayScale: 0.98;
+        underlayOpacity: 0.4;
+    }>;
+    /** Dousan's springs as Motion declares them: [stiffness, damping]. */
+    springs: Readonly<{
+        press: readonly [400, 10];
+        success: readonly [260, 18];
+        underlay: readonly [300, 30];
+        letters: readonly [300, 10];
+        cursorFollow: readonly [800, 35];
+        cursorAppear: readonly [500, 30];
+        bentoEnter: readonly [60, 15];
+        bentoRepel: readonly [300, 25];
+        dockPill: readonly [380, 30];
+    }>;
+    /** OFFFICE's masked type (Siena's case titles start at 120 %). */
+    maskText: Readonly<{
+        duration: 1.2;
+        delay: 0.1;
+        stagger: 0.02;
+        exitStagger: 0.002;
+        y: 100;
+        threshold: 0.8;
+    }>;
+    /** Siena's reveal group (rules, fades, rises). */
+    cascade: Readonly<{
+        duration: 1.2;
+        step: 0.03;
+        rise: 200;
+        threshold: 0.3;
+    }>;
+    /** Siena's slot title: each letter turns 8–14 times inside a 2 s expo.out envelope. */
+    textRoll: Readonly<{
+        duration: 2;
+        stagger: 0.04;
+        turns: readonly [8, 14];
+        interval: 6000;
+        quietMs: 1000;
+    }>;
+    /** Dousan's hero letters: scale on hover, pastel blink. */
+    letters: Readonly<{
+        scale: 1.3;
+        y: -5;
+        step: 0.03;
+        blink: 0.6;
+        blinkStart: 0.6;
+        blinkRepeatDelay: 0.1;
+        blinkDelays: readonly [0.1, 0.6, 0.2, 1, 0.4, 1.2, 0.15, 0.8, 0.3];
+    }>;
+    /** Siena's image parallax. */
+    parallax: Readonly<{
+        travel: 10;
+        scale: 1.2;
+        strongScale: 1.3;
+        lerp: 1;
+    }>;
+    /** Siena's About grid gathering from depth. */
+    depthGrid: Readonly<{
+        perspective: 600;
+        distance: 900;
+        depth: -3000;
+        rotate: -160;
+        opacity: 0.05;
+        scale: 0.4;
+        stagger: 0.15;
+        lerp: 1;
+    }>;
+    /** Siena's video mask: the frame and the picture inside scale in opposite directions. */
+    frameZoom: Readonly<{
+        outer: readonly [80, 20];
+        inner: readonly [130, 20];
+        phoneOuter: readonly [95, 5];
+        phoneInner: readonly [105, 5];
+        open: 1;
+        lerp: 1;
+    }>;
+    /** Siena's marquee: seconds per item, at most 14 counted. */
+    marquee: Readonly<{
+        perItem: 2;
+        maxItems: 14;
+    }>;
+    /** Dousan's glass chip and Siena's dot cursor. */
+    cursor: Readonly<{
+        gutter: 10;
+        circle: 96;
+        dotLerp: 0.2;
+        light: 180;
+    }>;
+    /** iyo.ai's floating navbar: enters from −300 % over 1.8 s; rows follow 0.15 s + 0.025 s each. */
+    island: Readonly<{
+        entrance: 1.8;
+        offset: -300;
+        delay: 0.15;
+        step: 0.025;
+        focus: 150;
+    }>;
+    /** iyo.ai's product dock: spread for 1.6 s on load; tablet range re-checked 250 ms after a resize. */
+    cardDock: Readonly<{
+        intro: 1600;
+        resizeDebounce: 250;
+    }>;
+    /** iyo.ai's phone cards: 5 s a card, 2 s wait after a touch, 0.5 s after it shows. */
+    snapStrip: Readonly<{
+        interval: 5000;
+        resume: 2000;
+        delay: 500;
+    }>;
+    /** iyo.ai's fill-text: letters from .2, 0.5 s each, 0.1 s apart, top 90 % → centre 40 %. */
+    fillText: Readonly<{
+        from: 0.2;
+        duration: 0.5;
+        stagger: 0.1;
+        start: "top 90%";
+        end: "center 40%";
+    }>;
+    /** iyo.ai's particle hero (adapted): fade in 1 s after 0.3 s, morph cycles, pointer push. */
+    particleHero: Readonly<{
+        fadeIn: 1;
+        fadeDelay: 0.3;
+        size: 128;
+        pointSize: 1.7;
+        maxDpr: 1.5;
+        stillSteps: 110;
+    }>;
+    ticketMenu: Readonly<{
+        open: 0.9;
+        content: 1.1;
+        stagger: 0.02;
+        from: 150;
+    }>;
+    infiniteReel: Readonly<{
+        friction: 0.95;
+        wheel: 0.05;
+        dragThreshold: 5;
+    }>;
+    repelBento: Readonly<{
+        offset: 0.6;
+        stagger: 0.006;
+        strength: 5000;
+        distance: 30;
+        breakpoint: 1024;
+    }>;
+    rotator: Readonly<{
+        interval: 8000;
+        duration: 0.25;
+        y: 5;
+    }>;
+    dragRuler: Readonly<{
+        min: 0;
+        max: 8;
+        step: 0.1;
+        pixelsPerUnit: 60;
+    }>;
+}>;
+
+type RevealSpeed = keyof typeof TIMING.reveal;
+interface RevealOptions {
+    /** Element (its centre) or viewport point. Default: the last pointer position, else the centre. */
+    origin?: Element | {
+        x: number;
+        y: number;
+    } | null;
+    speed?: RevealSpeed;
+    delay?: number;
+    overshoot?: number;
+    /** Veil colour. Default: the first opaque background up the tree, else var(--mk-bg). */
+    fill?: string;
+}
+interface RevealHandle {
+    timeline: gsap.core.Timeline;
+    finished: Promise<void>;
+    /** Stop now and remove the veil. */
+    cancel(): void;
+}
+declare function revealFrom(target: HTMLElement, options?: RevealOptions): RevealHandle | null;
+
+export { type DialogInstance as D, type MenuInstance as M, type RevealHandle as R, TIMING as T, type DialogLabels as a, type DialogOptions as b, type DialogPlacement as c, type DialogVariant as d, type MenuOptions as e, type RevealOptions as f, type RevealSpeed as g, createDialog as h, createMenu as i, revealFrom as r };

package/dist/store-Bqy_obnD.d.ts

@@ -0,0 +1,195 @@
+import { I as Instance } from './types-BkS_raL8.js';
+import { Flip } from 'gsap/Flip';
+import { R as RevealHandle } from './reveal-WFUWDrei.js';
+
+interface ThemePickerOptions {
+    /** Theme ids to show, in order. Default: every theme Stepbro shows (or all with showHidden). */
+    themes?: string[];
+    showHidden?: boolean;
+    labels?: {
+        group?: string;
+    };
+    onChange?: (id: string) => void;
+}
+interface ThemePickerInstance extends Instance {
+    select(id: string): void;
+}
+declare function createThemePicker(root: HTMLElement | null, options?: ThemePickerOptions): ThemePickerInstance;
+
+interface ToasterLabels {
+    dismiss?: string;
+}
+interface ToasterOptions {
+    labels?: ToasterLabels;
+}
+type ToasterInstance = Instance;
+/** Render the toast list into `host` (a fixed layer at the top of the screen). */
+declare function createToaster(host: HTMLElement | null, options?: ToasterOptions): ToasterInstance;
+
+type ChatRole = 'user' | 'assistant' | 'system';
+interface ChatLabels {
+    thinking?: string;
+}
+interface ChatOptions {
+    /** Animate the messages already there when the chat starts (default: no, history stays still). */
+    animateExisting?: boolean;
+    /** Clear the input after sending (default). */
+    clearOnSend?: boolean;
+    labels?: ChatLabels;
+    onSend?: (text: string) => void;
+}
+interface ChatInstance extends Instance {
+    /** Append a plain-text message (vanilla convenience); it enters on its own. */
+    add(role: ChatRole, text: string): HTMLElement;
+    /** Show the thinking placeholder after 500 ms (a fast answer never shows it). */
+    pending(): void;
+    /** Add the answer: it morphs out of the placeholder if that was showing, else it enters. */
+    reply(message: HTMLElement | string): HTMLElement;
+    /** A confirmation bar flows in and its words rise. */
+    confirm(bar: HTMLElement): void;
+    setRecording(on: boolean): void;
+    scrollToLatest(): void;
+    /** Mark a message as already shown (a framework animates it itself). */
+    adopt(message: Element): void;
+    readonly messages: HTMLElement;
+}
+/** data-flip-id of the thinking placeholder; a framework's own placeholder must carry it. */
+declare const PENDING_ID = "mk-chat-pending";
+/** The thinking placeholder's geometry, taken before the DOM changes (for frameworks). */
+declare const capturePending: (placeholder: Element | null) => Flip.FlipState | null;
+/** Morph a captured placeholder into the reply (after the DOM shows the reply). */
+declare function morphPendingToReply(state: ReturnType<typeof Flip.getState> | null, reply: HTMLElement, scroller?: HTMLElement | null): gsap.core.Timeline | null;
+/** A message bubble element (plain text). */
+declare function chatMessage(role: ChatRole, text: string): HTMLDivElement;
+declare function createChat(root: HTMLElement | null, options?: ChatOptions): ChatInstance;
+
+declare const NAV_STYLES: readonly ["clasica", "bonita", "dock", "guapa", "tasks", "melon", "tunnel"];
+type NavStyle = (typeof NAV_STYLES)[number];
+interface NavOptions {
+    /** Default: the saved one (storageKey), else the mk-nav--<style> class in the markup, else 'bonita' (Money's default). */
+    style?: NavStyle;
+    /** The accent variant (Stepbro's variant-1): the current page in primary-container. */
+    accent?: boolean;
+    /** Reveal the shell from the first button when the nav starts (off by default). */
+    reveal?: boolean;
+    /** Remember the chosen style in localStorage under this key. */
+    storageKey?: string;
+    labels?: {
+        nav?: string;
+    };
+    onSelect?: (index: number, value: string | undefined, item: HTMLElement) => void;
+}
+interface NavInstance extends Instance {
+    /** Mark a page as current, by index or value (silent: no event). */
+    select(target: number | string): void;
+    setStyle(style: NavStyle): void;
+    setAccent(on: boolean): void;
+    readonly index: number;
+    readonly style: NavStyle;
+    readonly items: HTMLElement[];
+}
+interface NavigateDetail {
+    index: number;
+    value: string | undefined;
+    item: HTMLElement;
+    /** The click: call its preventDefault() to stop a link (single-page apps). */
+    originalEvent: MouseEvent;
+}
+/** Stepbro's nav entrance: the app shell is uncovered from the nav's first button. */
+declare function revealShell(nav: HTMLElement): RevealHandle | null;
+declare function createNav(root: HTMLElement | null, options?: NavOptions): NavInstance;
+
+type CursorVariant = 'chip' | 'dot';
+interface CursorOptions {
+    variant?: CursorVariant;
+    /** Where it works. chip: the document; dot: the host's parent. */
+    zone?: Element | null;
+    /** dot: the word when nothing under the pointer gives one. */
+    text?: string;
+    /** dot: arrows shown while pressed. */
+    arrows?: 'x' | 'y' | 'none';
+}
+interface CursorInstance extends Instance {
+    readonly visible: boolean;
+    readonly label: string;
+    readonly position: {
+        x: number;
+        y: number;
+    };
+    readonly tone: 'light' | 'dark';
+    /** One frame (dt = 1 at 60 Hz); the shared ticker calls it. */
+    update(dt?: number): void;
+}
+declare function createCursor(host: HTMLElement | null, options?: CursorOptions): CursorInstance;
+
+interface IslandOptions {
+    /** Drop in from above on load (true), wait for ready() ('manual') or not at all. */
+    entrance?: boolean | 'manual';
+    /** Close when the page scrolls after a wheel or touch (iyo). */
+    closeOnScroll?: boolean;
+    /** Close when a link inside a panel is followed. */
+    closeOnNavigate?: boolean;
+    /** Focus the first control of the panel that opens. */
+    focusOnOpen?: boolean;
+    /** The open panel's name, or null when it closes. */
+    onChange?: (active: string | null) => void;
+}
+interface IslandInstance extends Instance {
+    open(name?: string): void;
+    close(returnFocus?: boolean): void;
+    toggle(name?: string): void;
+    /** Play the entrance (entrance: 'manual'). */
+    ready(): void;
+    readonly active: string | null;
+}
+declare function createIsland(root: HTMLElement | null, options?: IslandOptions): IslandInstance;
+
+type ToastTone = 'success' | 'error' | 'info' | 'neutral';
+interface ToastAction {
+    label: string;
+    onClick: () => void;
+}
+interface ToastOptions {
+    /** The control the toast grows out of. */
+    origin?: HTMLElement | null;
+    /** ms on screen; 0 keeps it until dismissed. */
+    duration?: number;
+    tone?: ToastTone;
+    action?: ToastAction;
+    /** Show the tone's icon (default). */
+    icon?: boolean;
+}
+interface ToastItem {
+    id: number;
+    message: string;
+    origin: HTMLElement | null;
+    duration: number;
+    tone: ToastTone;
+    action: ToastAction | null;
+    icon: boolean;
+    closing: boolean;
+}
+/** At most this many live toasts; older ones leave to make room. */
+declare const TOAST_LIMIT = 5;
+declare const getToasts: () => ToastItem[];
+declare function subscribeToasts(listener: () => void): () => void;
+declare function show(message: string, { origin, duration, tone, action, icon }?: ToastOptions): number;
+/** Start the closing animation of a toast. */
+declare function dismissToast(id: number): void;
+/** Take a toast out of the list (after its exit animation). */
+declare function removeToast(id: number): void;
+/** Remove every toast at once (no animation). */
+declare function clearToasts(): void;
+/** Show a toast: `toast('Copiado', { origin: button })`. Returns its id. */
+declare const toast: typeof show & {
+    dismiss: typeof dismissToast;
+    clear: typeof clearToasts;
+};
+declare const toastTimers: {
+    start(id: number, duration: number): void;
+    pause(id: number): void;
+    resume(id: number): void;
+    clear(id: number): void;
+};
+
+export { createIsland as A, createNav as B, type ChatInstance as C, createThemePicker as D, createToaster as E, dismissToast as F, getToasts as G, morphPendingToReply as H, type IslandInstance as I, removeToast as J, revealShell as K, subscribeToasts as L, toastTimers as M, type NavInstance as N, PENDING_ID as P, type ThemePickerInstance as T, type ToasterInstance as a, type ChatRole as b, type NavStyle as c, type CursorInstance as d, type ChatLabels as e, type ChatOptions as f, type CursorOptions as g, type CursorVariant as h, type IslandOptions as i, NAV_STYLES as j, type NavOptions as k, type NavigateDetail as l, TOAST_LIMIT as m, type ThemePickerOptions as n, type ToastAction as o, type ToastItem as p, type ToastOptions as q, type ToastTone as r, type ToasterLabels as s, toast as t, type ToasterOptions as u, capturePending as v, chatMessage as w, clearToasts as x, createChat as y, createCursor as z };

package/dist/theme/generate.d.ts

@@ -0,0 +1,18 @@
+import { T as ThemeState } from '../theme-BFMoCzi6.js';
+import { ThemePalettes } from './index.js';
+export { themeCss } from './index.js';
+
+type ThemeVariant = 'tonal-spot' | 'vibrant' | 'expressive' | 'neutral' | 'content' | 'fidelity' | 'monochrome';
+interface GenerateOptions {
+    variant?: ThemeVariant;
+    /** -1 (reduced) … 0 (standard) … 1 (high). */
+    contrast?: number;
+}
+declare function generateTheme(seed: string, { variant, contrast }?: GenerateOptions): ThemePalettes;
+
+/** Generate a theme from `seed`, inject it as a <style>, register and select it. */
+declare function applyTheme(seed: string, { id, ...options }?: GenerateOptions & {
+    id?: string;
+}): ThemeState;
+
+export { type GenerateOptions, type ThemeVariant, applyTheme, generateTheme };

package/dist/theme/generate.js

@@ -0,0 +1,64 @@
+import {
+  themeCss
+} from "../chunk-ABNRDDO7.js";
+import {
+  ROLES,
+  registerTheme,
+  setTheme
+} from "../chunk-J27KH2A2.js";
+import "../chunk-TGV27ZWM.js";
+
+// src/theme/generate.ts
+import {
+  Hct,
+  MaterialDynamicColors,
+  SchemeContent,
+  SchemeExpressive,
+  SchemeFidelity,
+  SchemeMonochrome,
+  SchemeNeutral,
+  SchemeTonalSpot,
+  SchemeVibrant,
+  argbFromHex,
+  hexFromArgb
+} from "@material/material-color-utilities";
+var SCHEMES = {
+  "tonal-spot": SchemeTonalSpot,
+  vibrant: SchemeVibrant,
+  expressive: SchemeExpressive,
+  neutral: SchemeNeutral,
+  content: SchemeContent,
+  fidelity: SchemeFidelity,
+  monochrome: SchemeMonochrome
+};
+var camel = (role) => role.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+function generateTheme(seed, { variant = "tonal-spot", contrast = 0 } = {}) {
+  if (!/^#?[0-9a-f]{6}$/i.test(seed)) throw new Error(`generateTheme: seed must be a #rrggbb colour (got "${seed}")`);
+  const Scheme = SCHEMES[variant];
+  if (!Scheme) throw new Error(`generateTheme: unknown variant "${variant}"`);
+  const source = Hct.fromInt(argbFromHex(seed.startsWith("#") ? seed : `#${seed}`));
+  const palette = (dark) => {
+    const scheme = new Scheme(source, dark, contrast);
+    const colors = MaterialDynamicColors;
+    return Object.fromEntries(ROLES.map((role) => [role, hexFromArgb(colors[camel(role)].getArgb(scheme))]));
+  };
+  return { light: palette(false), dark: palette(true) };
+}
+function applyTheme(seed, { id = "custom", ...options } = {}) {
+  const css = themeCss(id, generateTheme(seed, options));
+  let style = document.querySelector(`style[data-mk-theme-style="${id}"]`);
+  if (!style) {
+    style = document.createElement("style");
+    style.dataset.mkThemeStyle = id;
+    document.head.append(style);
+  }
+  style.textContent = css;
+  registerTheme(id);
+  return setTheme(id);
+}
+export {
+  applyTheme,
+  generateTheme,
+  themeCss
+};
+//# sourceMappingURL=generate.js.map