@yewdiel21/motion-kit 0.0.0-stage → 0.9.0

package/dist/index.d.ts

@@ -0,0 +1,440 @@
+export { D as DialogInstance, a as DialogLabels, b as DialogOptions, c as DialogPlacement, d as DialogVariant, M as MenuInstance, e as MenuOptions, R as RevealHandle, f as RevealOptions, g as RevealSpeed, T as TIMING, h as createDialog, i as createMenu, r as revealFrom } from './reveal-WFUWDrei.js';
+export { H as CardDockInstance, I as CardDockOptions, J as CascadeInstance, K as CascadeOptions, L as ContrastInstance, N as ContrastOptions, O as CounterInstance, P as CounterOptions, C as CurvedCarouselInstance, Q as CurvedCarouselOptions, R as DepthGridInstance, S as DepthGridOptions, U as DockPillInstance, V as DockPillOptions, W as DragRulerInstance, X as DragRulerOptions, Y as FillTextInstance, Z as FillTextOptions, _ as FitTextInstance, $ as FitTextOptions, a0 as FlowInOptions, a1 as FlowInstance, a2 as FlowOptions, a3 as FlowOutOptions, a4 as FrameZoomInstance, a5 as FrameZoomOptions, a6 as InfiniteReelInstance, a7 as InfiniteReelOptions, a8 as LettersInstance, a9 as LettersOptions, M as MK_HEAD_SCRIPT, aa as MarqueeInstance, ab as MarqueeOptions, ac as MaskTextInstance, ad as MaskTextOptions, ae as ParallaxInstance, af as ParallaxOptions, ag as PileInstance, ah as PileLayer, ai as PileOptions, aj as PopInstance, ak as PopOptions, al as RadialMenuInstance, am as RadialMenuOptions, an as ReflowInstance, ao as ReflowOptions, ap as ReorderDetail, aq as RepelBentoInstance, ar as RepelBentoOptions, as as RevealInstance, at as RevealRecipeOptions, au as RotatorInstance, av as RotatorOptions, aw as SlotTextInstance, ax as SlotTextOptions, ay as SnapStripInstance, az as SnapStripOptions, aA as SortableInstance, aB as SortableLabels, aC as SortableOptions, aD as SpringCardsInstance, aE as SpringCardsOptions, aF as StretchFooterInstance, aG as StretchFooterOptions, aH as TabsInstance, aI as TabsOptions, aJ as TextRollInstance, aK as TextRollOptions, A as TicketMenuInstance, T as TicketMenuOptions, aL as WordsInstance, aM as WordsOptions, x as createCardDock, p as createCascade, v as createContrast, j as createCounter, aN as createCurvedCarousel, t as createDepthGrid, G as createDockPill, F as createDragRuler, z as createFillText, f as createFitText, d as createFlow, u as createFrameZoom, B as createInfiniteReel, r as createLetters, w as createMarquee, o as createMaskText, s as createParallax, a as createPile, e as createPop, h as createRadialMenu, l as createReflow, D as createRepelBento, k as createReveal, E as createRotator, m as createSlotText, y as createSnapStrip, n as createSortable, c as createSpringCards, g as createStretchFooter, i as createTabs, q as createTextRoll, aO as createTicketMenu, b as createWords, aP as entrances, aQ as flowIn, aR as flowOut, aS as moveItem, aT as pileLayers, aU as pileStyle, aV as reduced, aW as stepChange } from './reduced-BM4Ls0g5.js';
+export { A as ANIMATIONS, a as AnimateOptions, b as AnimationName, C as CapturedLayout, c as ConfettiHandle, d as ConfettiOptions, E as ExitName, L as LeaveOptions, e as animate, f as captureLayout, g as confetti, l as leave, r as reflowLayout } from './confetti-BSX1CLLV.js';
+import { C as Cleanup, I as Instance } from './types-BkS_raL8.js';
+export { C as ChatInstance, e as ChatLabels, f as ChatOptions, b as ChatRole, d as CursorInstance, g as CursorOptions, h as CursorVariant, I as IslandInstance, i as IslandOptions, j as NAV_STYLES, N as NavInstance, k as NavOptions, c as NavStyle, l as NavigateDetail, P as PENDING_ID, m as TOAST_LIMIT, T as ThemePickerInstance, n as ThemePickerOptions, o as ToastAction, p as ToastItem, q as ToastOptions, r as ToastTone, a as ToasterInstance, s as ToasterLabels, u as ToasterOptions, v as capturePending, w as chatMessage, x as clearToasts, y as createChat, z as createCursor, A as createIsland, B as createNav, D as createThemePicker, E as createToaster, F as dismissToast, G as getToasts, H as morphPendingToReply, J as removeToast, K as revealShell, L as subscribeToasts, t as toast, M as toastTimers } from './store-Bqy_obnD.js';
+export { C as ChatBackgroundInstance, a as ChatBackgroundOptions, b as StepDetail, S as StepsInstance, c as StepsOptions, d as chatBackgroundOf, e as createChatBackground, f as createSteps } from './engine-CUr9QijM.js';
+export { CustomEase } from 'gsap/CustomEase';
+export { Flip } from 'gsap/Flip';
+export { ScrollTrigger } from 'gsap/ScrollTrigger';
+export { SplitText } from 'gsap/SplitText';
+export { gsap } from 'gsap';
+
+/** Spencer's elastic overshoot; close to the `--mk-ease-elastic` CSS curve. */
+declare const ELASTIC = "elastic.out(1, 0.45)";
+/** Custom eases registered by `registerMotion()` (Stepbro curves). Use the names as GSAP `ease` values. */
+declare const EASE: {
+    readonly signature: "mk-signature";
+    readonly flow: "mk-flow";
+    /** A closing surface's fade (`.56,.27,0,1`). Kept from v0.1; same curve as `fadeAway`. */
+    readonly close: "mk-close";
+    readonly fadeAway: "mk-fade-away";
+    /** A closing surface's blur (`.37,.35,0,1`). */
+    readonly blurAway: "mk-blur-away";
+    readonly chatScroll: "mk-chat-scroll";
+    /** Items travelling to a new place in a list (spring ratio .52). */
+    readonly layoutReflow: "mk-layout-reflow";
+    /** A dragged item landing in its slot (spring ratio .62). */
+    readonly sortableLand: "mk-sortable-land";
+    readonly slot: "mk-slot";
+    readonly slotResize: "mk-slot-resize";
+    readonly liquidSize: "mk-liquid-size";
+    readonly swatch: "mk-swatch";
+    readonly swatchLight: "mk-swatch-light";
+    readonly sheet: "mk-sheet";
+    readonly inOut: "mk-in-out";
+};
+/** Register plugins and eases once. Safe to call from every recipe and during SSR (no-op). */
+declare function registerMotion(): void;
+
+/** Stepbro's curve paths (CustomEase SVG syntax). */
+declare const PATHS: {
+    /** The signature: a strong deceleration that is not a plain ease-out. */
+    readonly signature: "M0,0 C0.308,0.19 0.107,0.633 0.288,0.866 0.382,0.987 0.656,1 1,1";
+    /** Lists and steps entering (`flowSoft`, also `numberSoft`). */
+    readonly flow: "M0,0 C0.25,0.1 0.25,1 1,1";
+    /** A conversation scrolling to its newest message. */
+    readonly chatScroll: "M0,0 C0.308,0.19 0.318,0.567 0.5,0.8 0.593,0.921 0.656,1 1,1";
+};
+/**
+ * A damped spring sampled as an ease path (Stepbro's `FA`): `ratio` below 1
+ * overshoots and settles, `velocity` is the starting speed.
+ */
+declare function springPath(ratio: number, velocity?: number, steps?: number): string;
+/**
+ * Stepbro's own linear() sampling of the signature curve (its backdrop tint),
+ * for CSS and the Web Animations API.
+ */
+declare const SIGNATURE_LINEAR = "linear(0 0%, .017 2.5%, .037 5%, .061 7.5%, .091 10%, .13 12.5%, .184 15%, .275 17.5%, .562 20%, .733 22.5%, .803 25%, .848 27.5%, .88 30%, .902 32.5%, .942 40%, .97 50%, .985 60%, .993 70%, .998 80%, 1 90%, 1 100%)";
+
+/**
+ * Stepbro's per-property motion channels (ported from Kayro's spring-channels):
+ * each value moves toward its target either on a spring (stiffness, damping, an
+ * initial kick) or on an eased duration, all stepped on GSAP's ticker. Used by
+ * surfaces that grow out of a control (liquid dialog, toasts) and floating windows.
+ */
+type Channel = {
+    type: 'spring';
+    stiffness: number;
+    damping: number;
+    mass?: number;
+    velocity?: number;
+    direction?: number;
+} | {
+    type: 'ease';
+    duration: number;
+    ease: (progress: number) => number;
+};
+interface ChannelState {
+    current: number;
+    origin: number;
+    target: number;
+    velocity: number;
+    elapsed: number;
+    active: boolean;
+    config: Channel | null;
+}
+declare const easeOut: (t: number) => number;
+declare const easeOutCubic: (t: number) => number;
+declare const easeInCubic: (t: number) => number;
+/** A cubic-bezier as a function of progress (Stepbro's `cr.bezier`). */
+declare function bezier(x1: number, y1: number, x2: number, y2: number): (progress: number) => number;
+declare const spring: (stiffness: number, damping: number, extra?: {
+    mass?: number;
+    velocity?: number;
+    direction?: number;
+}) => Channel;
+declare const eased: (duration: number, ease: (progress: number) => number) => Channel;
+declare const createChannelState: (value: number) => ChannelState;
+/** Advance one channel by `seconds`. Pure: exported for tests and custom loops. */
+declare function stepChannel(channel: ChannelState, seconds: number): void;
+/** Animate named values toward targets, each on its own channel, calling `onChange` per frame. */
+declare function channels<K extends string>(start: Record<K, number>, onChange: (name: K, value: number) => void): {
+    state: Record<K, ChannelState>;
+    /** Start moving; resolves when every channel has settled (or `stop()` is called). */
+    animate(targets: Partial<Record<K, number>>, configs: Partial<Record<K, Channel>>): Promise<void>;
+    stop(): void;
+};
+/** A damped spring as an ease function of progress (Stepbro's `Vw`). */
+declare function springEase(ratio: number, velocity?: number): (progress: number) => number;
+
+/**
+ * Split text for animation and put it back afterwards. Words become inline-block
+ * spans (so they can move); spaces stay plain text so lines still wrap. Elements
+ * matched by `exclude` (tables, code) are left whole.
+ */
+interface Split {
+    parts: HTMLElement[];
+    revert(): void;
+}
+interface SplitWordsOptions {
+    exclude?: string[];
+    className?: string;
+}
+declare function splitWords(el: HTMLElement, { exclude, className }?: SplitWordsOptions): Split;
+/** User-perceived characters (emoji with modifiers stay whole), at most `limit`. */
+declare function splitGraphemes(text: string, limit?: number): string[];
+
+/** requestAnimationFrame with a timer fallback (tests, old WebViews). Returns a cancel function. */
+declare function requestFrame(fn: (time: number) => void): () => void;
+/** Resolves on the next frame, after the framework has painted a DOM change. */
+declare const nextFrame: () => Promise<void>;
+
+/**
+ * Remove inline properties GSAP wrote, without asking GSAP. `gsap.set(el,
+ * { clearProps: 'transform' })` measures the element first, and an element
+ * that is not rendered (a closed <dialog>, display: none) is moved to the end of
+ * the document and back to be measured — which reorders text around it and
+ * disconnects custom elements inside. This only edits the style attribute and
+ * drops GSAP's cache so the next tween starts from scratch.
+ */
+declare function clearStyles(targets: Iterable<Element>, properties: string[]): void;
+/** What the surface morphs write. */
+declare const MORPH_STYLES: string[];
+
+interface MotionSpring {
+    /** Progress 0…1 over `duration` → position (overshoots when bouncy). */
+    ease: (progress: number) => number;
+    /** Seconds until it stays within 0.1 % of the target. */
+    duration: number;
+}
+declare function motionSpring(stiffness: number, damping: number, mass?: number): MotionSpring;
+/** Seconds a Motion spring takes to settle. */
+declare const springDuration: (stiffness: number, damping: number, mass?: number) => number;
+/** The spring as a CSS linear() easing (pair it with springDuration). */
+declare function springLinear(stiffness: number, damping: number, mass?: number, points?: number): string;
+
+interface ScrollTrackOptions {
+    /** "<top|center|bottom|n%> <top|center|bottom|n%>" — default "top bottom" (the element enters). */
+    start?: string;
+    /** Default "bottom top" (the element has left). */
+    end?: string;
+    /** Share of the distance covered each 60 fps frame (default 1: follow the page exactly). */
+    lerp?: number;
+    onUpdate?: (value: number) => void;
+}
+interface ScrollTrack {
+    readonly value: number;
+    readonly target: number;
+    /** Raw progress now, from the element's box. */
+    measure(): number;
+    /** Measure and ease one frame (dt = 1 at 60 Hz). */
+    update(dt?: number): void;
+    /** Jump to a value (manual control). */
+    set(value: number): void;
+    destroy(): void;
+}
+declare function trackScroll(el: Element, { start, end, lerp, onUpdate }?: ScrollTrackOptions): ScrollTrack;
+
+/** Navigation menu options: grow from 90 % out of 4 px blur, last first, after 0.1 s. */
+declare const flowInMenu: (targets: gsap.TweenTarget) => gsap.core.Tween | null;
+/** Theme picker swatches: pop in from half size, 10 ms apart. */
+declare const flowInPalette: (targets: gsap.TweenTarget) => gsap.core.Tween | null;
+/** Form cards (`[data-flow-item]`): grow from 90 % out of 8 px blur. */
+declare const flowInForm: (targets: gsap.TweenTarget) => gsap.core.Tween | null;
+/** Landing pieces: grow from 85 % out of 24 px blur, after 0.15 s. */
+declare const flowInLanding: (targets: gsap.TweenTarget) => gsap.core.Tween | null;
+/** Long-form content (`[data-flow]`, markdown blocks): style 2, 0.6 s, 60 ms apart. */
+declare const flowInContent: (root: Element) => gsap.core.Tween | null;
+
+declare function toggleDetails(details: HTMLDetailsElement, open: boolean, { duration }?: {
+    duration?: number;
+}): gsap.core.Timeline | null;
+/**
+ * Animate every disclosure under `root` with one listener. Controls inside a
+ * summary keep their clicks; `data-mk-motion="none"` opts a disclosure out.
+ * Returns the function that removes the listener.
+ */
+declare function installDetailsMotion(root?: Document | HTMLElement): () => void;
+
+interface IndicatorOptions {
+    immediate?: boolean;
+    duration?: number;
+    /** Scroll container to centre the target in (when it overflows). */
+    scroller?: HTMLElement | null;
+    orientation?: 'horizontal' | 'vertical';
+}
+declare function slideIndicator(indicator: HTMLElement, target: HTMLElement | null, options?: IndicatorOptions): gsap.core.Tween | null;
+
+type NumberFormat = (value: number) => string;
+interface CountOptions {
+    /** Start value. Default: the last value counted on this element, else the number in its text. */
+    from?: number;
+    duration?: number;
+    format?: NumberFormat;
+}
+/** Tween a plain number (no DOM): `onUpdate` gets each value. Reduced motion jumps to `to`. */
+declare function tweenNumber(from: number, to: number, onUpdate: (value: number) => void, { duration }?: {
+    duration?: number;
+}): gsap.core.Tween | null;
+declare function countTo(el: HTMLElement, to: number, { from, duration, format }?: CountOptions): gsap.core.Tween | null;
+/** Count with requestAnimationFrame and ease-out cubic. Returns a cancel function. */
+declare function revealCounter(el: HTMLElement, to: number, { from, duration, format }?: CountOptions): () => void;
+
+interface EnterMessagesOptions {
+    /** Text inside each bubble whose words rise. */
+    textSelector?: string;
+}
+declare function enterMessages(bubbles: HTMLElement[], { textSelector }?: EnterMessagesOptions): gsap.core.Timeline | null;
+/** A message box grows or shrinks to its text (0.18 s, power2.out), from `min` px. */
+declare function fitComposer(field: HTMLTextAreaElement, min?: number): gsap.core.Tween | null;
+/** Scroll a conversation to its newest message (0.35 s, Stepbro's chat scroll curve). */
+declare function scrollToLatest(scroller: HTMLElement): gsap.core.Tween | null;
+
+/** Called every frame with dt = 1 at 60 Hz. */
+type Tick = (dt: number) => void;
+/** One shared ticker callback for every recipe (spencergabor.com's single rAF loop). */
+declare function subscribe(fn: Tick): () => void;
+/** Run `fn` every frame only while `el` is near the viewport. */
+declare function whileVisible(el: Element, fn: Tick, rootMargin?: string): () => void;
+
+interface Vec {
+    x: number;
+    y: number;
+}
+interface Spring {
+    current: Vec;
+    target: Vec;
+    velocity: Vec;
+    update(dt?: number): void;
+}
+/** Spencer Gabor's spring (stiffness .05, friction .8), normalised so dt = 1 is one 60 Hz frame. */
+declare function createSpring(stiffness?: number, friction?: number): Spring;
+
+declare const clamp: (v: number, min: number, max: number) => number;
+declare const lerp: (a: number, b: number, t: number) => number;
+/** Spencer's frame-rate independent smoothing: lerp by 1 - e^(-lambda·dt). */
+declare const damp: (a: number, b: number, lambda: number, dt: number) => number;
+declare const wrap: (v: number, length: number) => number;
+declare function mapRange(v: number, inMin: number, inMax: number, outMin: number, outMax: number, clamped?: boolean): number;
+
+/** Live pointer position (viewport px) plus movement accumulated since the last frame. */
+declare const pointer: {
+    x: number;
+    y: number;
+    active: boolean;
+};
+/** Start tracking (reference-counted). Call the returned function when the recipe is destroyed. */
+declare function bindPointer(): () => void;
+/**
+ * Pointer movement since the previous animation frame. Every caller in the same
+ * frame gets the same value (two recipes on a page both feel the pointer); the
+ * next frame starts again from what moved since.
+ */
+declare function takeMovement(): {
+    mx: number;
+    my: number;
+};
+
+interface Scope {
+    /** Register any cleanup; returns it for convenience. */
+    add(fn: Cleanup): Cleanup;
+    /** addEventListener that is removed on dispose. */
+    on<K extends keyof HTMLElementEventMap>(target: EventTarget, type: K | (string & {}), listener: (event: HTMLElementEventMap[K]) => void, options?: AddEventListenerOptions | boolean): void;
+    /** Disconnects the observer on dispose and returns it. */
+    observe<O extends {
+        disconnect(): void;
+    }>(observer: O): O;
+    /** setTimeout that is cleared on dispose. */
+    timeout(fn: () => void, ms: number): void;
+    /** Set (or remove, with null) an attribute; dispose puts the original value back. */
+    attr(el: Element, name: string, value: string | null): void;
+    /** Run every cleanup once, newest first. */
+    dispose(): void;
+    readonly disposed: boolean;
+}
+/** Collects the side effects of one recipe instance so `destroy()` can undo all of them. */
+declare function createScope(): Scope;
+
+type DetailsInstance = Instance;
+declare function createDetails(root: HTMLElement | null): DetailsInstance;
+
+/** A computed colour with no alpha: `transparent`, `rgba(…, 0)` or `color(… / 0)`. */
+declare const transparentColor: (color: string) => boolean;
+type DialogLike = HTMLElement & Partial<Pick<HTMLDialogElement, 'showModal' | 'show' | 'close'>>;
+/** Open a <dialog> modally (or not). Falls back to the `open` attribute. */
+declare function openModal(dialog: DialogLike, modal?: boolean): void;
+declare function closeModal(dialog: DialogLike): void;
+/**
+ * Fade a modal <dialog>'s ::backdrop in (Stepbro's tint: 0.5 s on the signature
+ * curve) or out (linear). Resolves at once without the Web Animations API.
+ */
+declare function fadeBackdrop(dialog: HTMLElement, direction: 'in' | 'out'): Promise<void>;
+/**
+ * An inert visual copy of `surface`, fixed over the place it occupies now and not
+ * yet in the document (null when it has no size). A picture, not a second form:
+ * no ids, labels, names or roles to collide with the page.
+ */
+/** A fixed copy of a modal's backdrop (tint and blur), for a closing ghost to fade with. Not appended. */
+declare function backdropVeil(surface: HTMLElement): HTMLElement;
+declare function ghostOf(surface: HTMLElement): HTMLElement | null;
+
+/** Whether a surface is opening or closing right now. */
+declare const isMorphing: (surface: HTMLElement) => boolean;
+/** Stop a surface's morph now and put the surface and its content back to rest. */
+declare function stopMorph(surface: HTMLElement): void;
+/** Show a hidden opener again; with `fade` it comes back while its surface closes (0.3 s after 0.2 s). */
+declare function showOrigin(origin: HTMLElement | null | undefined, { fade }?: {
+    fade?: boolean;
+}): void;
+/** Show the opener's shared pieces again (a surface closed without its animation). */
+declare function releaseShared(origin: HTMLElement | null | undefined): void;
+/** The opener's pieces travel into the surface; they stay hidden at home until it closes. */
+declare function shareInto(origin: HTMLElement, surface: HTMLElement, duration?: number): void;
+/** The surface's pieces travel back home and show there again. */
+declare function shareBack(surface: HTMLElement, origin: HTMLElement, duration?: number): void;
+interface MorphOpenOptions {
+    duration?: number;
+    /** Keep a compact opener hidden while the surface is open; call showOrigin when it closes. */
+    hideOrigin?: boolean;
+    /** What enters inside the surface (selector); by default its children. */
+    content?: string;
+    /** Delay between content parts: an option list cascades instead of growing as one. */
+    stagger?: number;
+    liquid?: boolean;
+}
+/**
+ * Open `surface` out of `origin`. Returns the timeline (null when reduced).
+ * Shape travels from the opener (0.7 s, signature) and takes the surface's
+ * colour over the first 0.3 s; the content grows from the opener's box out of
+ * an 8 px blur on the same curve. Without an opener on screen: scale .92 → 1, 0.35 s.
+ */
+declare function morphOpen(surface: HTMLElement, origin: HTMLElement | null, options?: MorphOpenOptions): gsap.core.Timeline | null;
+interface MorphCloseOptions {
+    duration?: number;
+    content?: string;
+    liquid?: boolean;
+}
+/**
+ * Fold `surface` back into `origin`, then call `onComplete` (which hides it).
+ * Without an opener on screen it closes in place: 90 % scale, 32 px blur.
+ */
+declare function morphClose(surface: HTMLElement, origin: HTMLElement | null, onComplete: () => void, options?: MorphCloseOptions): gsap.core.Timeline | null;
+/**
+ * Close a modal at once (focus returns, the page takes input) while an inert
+ * copy folds back into the opener over a fading veil. `inPlace` (after a drag)
+ * closes it where it was dropped instead of folding into the opener.
+ */
+declare function morphCloseWithGhost(surface: HTMLElement, origin: HTMLElement | null, { inPlace, liquid }?: {
+    inPlace?: boolean;
+    liquid?: boolean;
+}): void;
+
+/** Open `surface` out of `origin` the liquid way. Returns a function that stops it and settles the surface. */
+declare function liquidOpen(surface: HTMLElement, origin: HTMLElement, parts: HTMLElement[]): () => void;
+/** Close `surface` back into `origin` the liquid way, then call `onComplete`. */
+declare function liquidClose(surface: HTMLElement, origin: HTMLElement, parts: HTMLElement[], onComplete: () => void): void;
+
+declare function sheetOpen(surface: HTMLElement): gsap.core.Tween | null;
+/** Drop a copy of the (still open) sheet off the bottom of the screen. */
+declare function sheetClose(surface: HTMLElement, { inPlace }?: {
+    inPlace?: boolean;
+}): gsap.core.Tween | null;
+declare function pushUnderlay(elements: HTMLElement[]): void;
+declare function releaseUnderlay(elements: HTMLElement[], animated?: boolean): void;
+
+interface DragDismissOptions {
+    /** Whether a gesture may start now (not while opening, saving or floating). */
+    canDrag?: () => boolean;
+    onDismiss: () => void;
+}
+/** Let `surface` be dragged away. Returns the function that detaches it. */
+declare function attachDragDismiss(surface: HTMLElement, { canDrag, onDismiss }: DragDismissOptions): () => void;
+
+declare const floatingAvailable: () => boolean;
+interface Rect {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+/** A window kept inside the viewport, at least 320 × 240. */
+declare function clampRect(rect: Rect, viewport?: {
+    width: number;
+    height: number;
+}): Rect;
+/** Where a floating window was left, if this device remembers it. */
+declare function savedFloat(key: string): Rect | null;
+declare function forgetFloat(key: string): void;
+/** Lift a surface into a window at `rect` (its shadow eases in, 0.45 s). */
+declare function liftWindow(surface: HTMLElement, rect: Rect): void;
+/** Put a floating surface back in its place, travelling from where it floated. */
+declare function dockWindow(surface: HTMLElement, from: Rect): void;
+interface FloatingOptions {
+    key: string;
+    handle: HTMLElement;
+    corners?: HTMLElement[];
+    isFloating: () => boolean;
+    float: () => void;
+    dock: () => void;
+}
+/** Move a floating surface by its handle and resize it from its corners. Returns the detach function. */
+declare function attachFloating(surface: HTMLElement, { key, handle, corners, isFloating, float, dock }: FloatingOptions): () => void;
+
+interface Viewport {
+    width: number;
+    height: number;
+}
+declare function anchorSurface(surface: HTMLElement, origin: DOMRect | null | undefined, viewport?: Viewport): void;
+/** Remove the inline place anchorSurface wrote. */
+declare function clearAnchor(surface: HTMLElement): void;
+
+interface AudioEnergy {
+    stop(): void;
+}
+declare function audioEnergy(stream: MediaStream, onEnergy: (energy: number) => void, { fftSize, smoothing }?: {
+    fftSize?: number;
+    smoothing?: number;
+}): AudioEnergy;
+
+export { type AudioEnergy, type Channel, type ChannelState, Cleanup, type CountOptions, type DetailsInstance, type DragDismissOptions, EASE, ELASTIC, type EnterMessagesOptions, type FloatingOptions, type IndicatorOptions, Instance, MORPH_STYLES, type MorphCloseOptions, type MorphOpenOptions, type MotionSpring, type NumberFormat, PATHS, type Rect, SIGNATURE_LINEAR, type Scope, type ScrollTrack, type ScrollTrackOptions, type Split, type SplitWordsOptions, type Spring, type Tick, type Vec, type Viewport, anchorSurface, attachDragDismiss, attachFloating, audioEnergy, backdropVeil, bezier, bindPointer, channels, clamp, clampRect, clearAnchor, clearStyles, closeModal, countTo, createChannelState, createDetails, createScope, createSpring, damp, dockWindow, easeInCubic, easeOut, easeOutCubic, eased, enterMessages, fadeBackdrop, fitComposer, floatingAvailable, flowInContent, flowInForm, flowInLanding, flowInMenu, flowInPalette, forgetFloat, ghostOf, installDetailsMotion, isMorphing, lerp, liftWindow, liquidClose, liquidOpen, mapRange, morphClose, morphCloseWithGhost, morphOpen, motionSpring, nextFrame, openModal, pointer, pushUnderlay, registerMotion, releaseShared, releaseUnderlay, requestFrame, revealCounter, savedFloat, scrollToLatest, shareBack, shareInto, sheetClose, sheetOpen, showOrigin, slideIndicator, splitGraphemes, splitWords, spring, springDuration, springEase, springLinear, springPath, stepChannel, stopMorph, subscribe, takeMovement, toggleDetails, trackScroll, transparentColor, tweenNumber, whileVisible, wrap };