asciify-engine 4.13.0 → 4.14.1

package/dist/kit.d.cts

@@ -1,4 +1,5 @@
 import { GlyphField, GlyphFieldOptions } from './field.cjs';
+import { C as CHARACTER_SETS } from './characters-BgG9AZQl.cjs';
 
 /** Options every kit component takes. */
 interface KitOptions {
@@ -8,14 +9,26 @@ interface KitOptions {
     look?: GlyphFieldOptions;
     /** `true` or `false` overrides the visitor's `prefers-reduced-motion`; leave it unset to follow it. */
     reducedMotion?: boolean;
+    /**
+     * Mount the field only once the element comes within half a viewport of the screen, and release it (freeing its WebGL context)
+     * beyond one. The handle keeps working while released. `false` mounts at once, wherever the element is. Default true.
+     */
+    lazy?: boolean;
+    /** A still image under the field: shown until the first GPU frame, while the field is released, and in its place without WebGL. */
+    poster?: string;
+    /** `false` keeps this field's own characters when `setGlobalLook` re-skins the page. Default true. */
+    globalLook?: boolean;
 }
 /** The handle every kit component returns. Component handles add their own methods. */
 interface KitHandle<O> {
     /** False when WebGL2 is missing (or the field failed): the HTML is left as it was and drawing methods do nothing. */
     readonly supported: boolean;
-    /** The underlying GPU field, for anything the kit does not cover. `null` in the fallback. */
+    /**
+     * The underlying GPU field, for anything the kit does not cover. `null` in the fallback. It stays the same object while the
+     * field is released off screen; `update`, `setSource`, `play` and `pause` made meanwhile apply when it mounts again.
+     */
     readonly field: GlyphField | null;
-    /** Merges options; the next frame draws with them. */
+    /** Merges options (`look` key by key); the next frame draws with them. */
     update(options: Partial<O>): void;
     /** Resumes motion after `pause()`. */
     play(): void;
@@ -50,6 +63,10 @@ interface PaintFrame {
 }
 interface SurfaceConfig {
     host: HTMLElement;
+    /** The component's options, for `lazy`, `poster` and `globalLook`. Pass the same object to `handle()`. */
+    kit?: {
+        current: KitOptions;
+    };
     /** The field look; ink comes from `ink`, so leave it out here. */
     look: () => GlyphFieldOptions;
     /** CSS colour or custom property for the field ink, given whether the ground is dark. */
@@ -69,8 +86,12 @@ interface SurfaceConfig {
     onTheme?: () => void;
 }
 interface Surface {
+    /** The same object across release and remount. */
     readonly field: GlyphField;
+    /** The current canvas. A remount swaps in a copy of it, with its attributes and inline styles, in the same place. */
     readonly canvas: HTMLCanvasElement;
+    /** True while the field holds a WebGL context. */
+    readonly live: boolean;
     /** Starts the frame loop if it is not running. */
     kick(): void;
     /** Re-reads the look and ink, then kicks. */
@@ -86,7 +107,9 @@ interface Surface {
 declare function resolveColor(token: string | undefined, from: Element, fallback?: string): string | null;
 /**
  * Mounts a field over or inside `host` and feeds it a canvas painted each frame. Returns null without WebGL2 or when
- * mounting fails, having changed nothing, so the caller can keep its HTML as the fallback.
+ * mounting fails, having changed nothing (but a `poster`), so the caller can keep its HTML as the fallback. The field mounts near
+ * the viewport and is released far from it (see `KitOptions.lazy`); every frame paints the component's current state, so a remount
+ * picks up where the component is.
  */
 declare function mountSurface(config: SurfaceConfig): Surface | null;
 
@@ -128,7 +151,7 @@ declare function beam(element: HTMLElement, options?: BeamOptions): BeamHandle;
 interface DecodeOptions extends KitOptions {
     /** Text to draw instead of the element's own, centred and as large as fits; `\n` breaks lines. By default the element's text is drawn exactly where the browser lays it out. */
     text?: string;
-    /** Total length in ms: the first 30% is drift alone, then the words resolve left to right. Default 900. */
+    /** Total length in ms: the first 30% is drift alone, then the words resolve left to right. Default 800. */
     duration?: number;
     /** `visible` decodes when the element scrolls into view; `manual` waits for `replay()`. Default `visible`. */
     trigger?: 'visible' | 'manual';
@@ -154,6 +177,8 @@ interface OdometerOptions extends KitOptions {
     stagger?: number;
     /** Glyphs the columns roll through. Default `#%*+=-:`. */
     glyphs?: string;
+    /** `text`: crisp text at rest, characters only while a column rolls. `glyph`: the whole figure is drawn in characters. Default `text`. */
+    face?: 'text' | 'glyph';
 }
 interface OdometerHandle extends KitHandle<OdometerOptions> {
     /** Shows a new value; only the changed digits roll, leftmost first. */
@@ -171,12 +196,14 @@ interface ButtonLoadingOptions extends KitOptions {
     text?: string;
     /** The element holding the label text. Default: the button itself. Pass it when the button also holds an icon. */
     label?: HTMLElement;
-    /** Put a check before the success label. Default true. */
+    /** Put a check (a crisp SVG) before the success label. Default true. */
     check?: boolean;
     /** Shake the button on failure (skipped under reduced motion). Default true. */
     shake?: boolean;
     /** A live region to announce each state in. Optional. */
     announce?: HTMLElement;
+    /** An icon-only button's icon. Default: the first `svg` when the button has no text. One breathing cell stands in for it while loading, and a check while it shows success. */
+    icon?: Element | null;
 }
 type ButtonState = 'idle' | 'loading' | 'success' | 'error';
 interface ButtonLoadingHandle extends KitHandle<ButtonLoadingOptions> {
@@ -193,6 +220,7 @@ interface ButtonLoadingHandle extends KitHandle<ButtonLoadingOptions> {
 /**
  * A button whose label cycles through characters while its request runs, then decodes into the result.
  * The width never changes: it grows to the widest label it has shown and holds there until `destroy()`.
+ * An icon-only button keeps its icon: while loading one cell over it breathes through the glyphs, and success swaps in a check.
  */
 declare function buttonLoading(button: HTMLElement, options?: ButtonLoadingOptions): ButtonLoadingHandle;
 
@@ -362,6 +390,10 @@ interface WordmarkOptions extends KitOptions {
     font?: string;
     /** Default 600. */
     fontWeight?: number;
+    /** Height of the 1800 px wide canvas the word is set on. A shorter one sets the word larger in a wide element. Default 520. */
+    artHeight?: number;
+    /** The canvas's accessible name when the word is not the element's own text. Default the word. */
+    label?: string;
 }
 interface WordmarkHandle extends KitHandle<WordmarkOptions> {
     /** Sets the word again, as large as fits. */
@@ -550,6 +582,8 @@ interface LikeBurstOptions extends KitOptions {
     limit?: HTMLElement | null;
     /** CSS pixels the field reaches past the button on every side. Default 40; set at mount. */
     outset?: number;
+    /** `under` (default) draws between the button's background and its content, so the count and label stay crisp over the sparks; `over` draws above everything. Set at mount. */
+    layer?: 'over' | 'under';
     /** Called after a click toggles the button. */
     onChange?: (pressed: boolean) => void;
 }
@@ -574,6 +608,8 @@ interface BlockChartOptions extends KitOptions {
     max?: number;
     /** How long each bar grows, in ms. Default 520. */
     duration?: number;
+    /** Grow the bars in the first time the chart comes into view. `false` draws them in place at once, as in a view that is swapped in. Default true. */
+    intro?: boolean;
     /** Ms between bars growing. Default 45 for up to 7 bars, else 9. */
     stagger?: number;
     /** Formats values for the screen reader table. Default `toLocaleString()`. */
@@ -628,6 +664,8 @@ interface SwipeDeckOptions extends KitOptions {
     radius?: number;
     /** CSS pixels the field reaches past the deck for the stack and the fling. Default 56; set at mount. */
     outset?: number;
+    /** The element that receives `--ascii-lean`, such as the row holding your pass and keep buttons. Default the deck. */
+    leanTarget?: HTMLElement | null;
     /** Called after a card leaves: `dir` is 1 for right (keep), -1 for left (pass). */
     onSwipe?: (dir: 1 | -1, index: number, card: HTMLElement) => void;
 }
@@ -656,6 +694,8 @@ interface CodeInputHandle extends KitHandle<CodeInputOptions> {
     verify(ok: boolean): void;
     /** Empties the code and returns to idle. */
     clear(): void;
+    /** Enters a whole code, as a paste or an autofill would: the characters resolve one after another. */
+    fill(code: string): void;
     readonly value: string;
     readonly state: CodeState;
 }
@@ -687,6 +727,8 @@ interface ToastStackOptions extends KitOptions {
     render?: (toast: Toast, id: number) => HTMLElement;
     /** Accessible name of the list. Default `Notifications`. */
     label?: string;
+    /** At rest a comet of characters runs round the newest toast's edge every few seconds, outside its text. Default true. */
+    glint?: boolean;
 }
 interface ToastStackHandle extends KitHandle<ToastStackOptions> {
     /** Adds a toast at the front, gathering out of scattered characters. Returns its id. */
@@ -721,6 +763,8 @@ interface ThinkingOptions extends KitOptions {
     stagger?: number;
     /** A dotted rule under the finished answer. Default true. */
     rule?: boolean;
+    /** Called on each state change; `seconds` is how long it thought, once known. For a status you render yourself. */
+    onState?: (state: ThinkingState, seconds: number) => void;
 }
 interface ThinkingHandle extends KitHandle<ThinkingOptions> {
     /** Clears the answer and thinks again, as for Regenerate. */
@@ -772,7 +816,7 @@ interface CompareOptions extends KitOptions {
     image: string | HTMLImageElement;
     /** Share of the frame showing the photo, from the left, 0–100. Default 50. */
     position?: number;
-    /** The handle's accessible name. Default `Photo and ASCII split`. */
+    /** The handle's accessible name. Default `Photo and ASCII split`, or your own handle's `aria-label`. */
     label?: string;
     /** Called as the split moves. */
     onChange?: (position: number) => void;
@@ -839,6 +883,8 @@ interface DropzoneOptions extends KitOptions {
     develop?: number;
     /** File name for `download()`. Default `<name>-ascii.png`. */
     filename?: string;
+    /** Called on every state change (`empty`, `developing`, `done`) with the image's name, or '' when empty. */
+    onState?: (state: DropState, name: string) => void;
 }
 interface DropzoneHandle extends KitHandle<DropzoneOptions> {
     /** Shows an image (a URL, Blob or File), developing it in characters. */
@@ -904,4 +950,221 @@ interface PullRefreshHandle extends KitHandle<PullRefreshOptions> {
  */
 declare function pullRefresh(element: HTMLElement, options: PullRefreshOptions): PullRefreshHandle;
 
-export { type AccordionHandle, type AccordionImage, type AccordionOptions, type ArtPanelHandle, type ArtPanelOptions, type AsciiVideoHandle, type AsciiVideoOptions, BEAM_PALETTES, type BeamHandle, type BeamMode, type BeamOptions, type BeamPalette, type BlockChartHandle, type BlockChartOptions, type Box, type ButtonLoadingHandle, type ButtonLoadingOptions, type ButtonState, type CodeInputHandle, type CodeInputOptions, type CodeState, type CommandPaletteHandle, type CommandPaletteOptions, type CompareHandle, type CompareOptions, type DecodeHandle, type DecodeOptions, type DisintegrateOptions, type DropState, type DroppedImage, type DropzoneHandle, type DropzoneOptions, type FieldBackgroundHandle, type FieldBackgroundOptions, type FieldPreset, type GenerateState, type ImageGenerateHandle, type ImageGenerateOptions, type ImageStream, type ImageUpdate, type KitHandle, type KitOptions, type LikeBurstHandle, type LikeBurstOptions, type LikeMark, type OdometerHandle, type OdometerOptions, type OrbState, PILL_TONES, type PageDissolveHandle, type PageDissolveOptions, type PaintFrame, type PillHandle, type PillOptions, type PillTone, type PricingGlowHandle, type PricingGlowOptions, type PullRefreshHandle, type PullRefreshOptions, type PullState, type SkeletonBlock, type SkeletonHandle, type SkeletonOptions, type SlideToConfirmHandle, type SlideToConfirmOptions, type StatusOrbHandle, type StatusOrbOptions, type StreamState, type StreamTextHandle, type StreamTextOptions, type Surface, type SurfaceConfig, type SwipeDeckHandle, type SwipeDeckOptions, type TabsHandle, type TabsOptions, type ThinkingHandle, type ThinkingOptions, type ThinkingState, type Toast, type ToastStackHandle, type ToastStackOptions, VOICE_PALETTES, type VoiceOrbHandle, type VoiceOrbOptions, type VoicePalette, type VoiceState, type WordmarkHandle, type WordmarkOptions, accordion, artPanel, asciiVideo, beam, beamPalette, blockChart, buttonLoading, codeInput, commandPalette, compare, decode, disintegrate, dropzone, fieldBackground, imageGenerate, likeBurst, mountSurface, odometer, pageDissolve, pill, pricingGlow, pullRefresh, resolveColor, skeleton, slideToConfirm, statusOrb, streamText, swipeDeck, tabs, thinking, toastStack, voiceOrb, wordmark };
+/** `true` follows the pointer with the preset's own response; the GPU presets also take a named hover. */
+type BackgroundCursor = boolean | 'trail' | 'fluid' | 'lantern';
+/** A named ramp from the engine's character sets, `'dots'`, or your own characters from empty to dense. */
+type BackgroundCharset = keyof typeof CHARACTER_SETS | 'dots' | (string & {});
+interface BackgroundOptions extends KitOptions {
+    /** The background to draw, imported by name: `import { background, aurora } from 'asciify-engine/kit'`. */
+    preset: BackgroundPreset;
+    /** The ink, one colour or one per ground. Wins over `color` and `ink`. Default: the preset's graphite for the ground. */
+    palette?: string | {
+        light?: string;
+        dark?: string;
+    };
+    /** One ink for both grounds. Same as `ink`. */
+    color?: string;
+    /** Peaks, heads and signals, for the presets that draw them. Default: the preset's own accent, or one mixed from the ink. */
+    accent?: string;
+    /** Animation speed, 0–5. Default: the preset's tuned pace (the /backgrounds page's Speed control). */
+    speed?: number;
+    /** Character size (dot spacing for `halftone`) in CSS pixels. Default: the preset's own. */
+    cellSize?: number;
+    /** Characters from empty to dense, or a named set (`blocks`, `braille`, `dots`, ...). Default: the preset's own. */
+    charset?: BackgroundCharset;
+    /** Pointer response. Default: on for the presets that answer the cursor. */
+    cursor?: BackgroundCursor;
+    /** An element to keep clear: the field fades out around it so text over it stays readable. */
+    clear?: HTMLElement | false;
+    /** Canvas opacity, 0–1. Default 1 (`fluid` 0.7). */
+    opacity?: number;
+    /** Ordered dither, 0–1, for the presets that tone with density. Default 0. */
+    dither?: number;
+    /** `wordField` only: the word drawn. Default `ASCIIFY`. */
+    text?: string;
+}
+/** The settings a preset draws with, resolved from the options and the preset's defaults. */
+interface BackgroundSettings {
+    speed: number;
+    cellSize: number;
+    charset: string | undefined;
+    cursor: BackgroundCursor;
+    clear: HTMLElement | false;
+    dither: number;
+    accent: string | undefined;
+    text: string;
+    look: GlyphFieldOptions | undefined;
+}
+/** What `background()` hands a preset when it mounts. Settings and ink are read live, so `update()` needs no remount. */
+interface BackgroundContext {
+    readonly host: HTMLElement;
+    /** The live options, for the GPU presets' lazy mounting, context budget, poster and `globalLook`. */
+    readonly kit: {
+        current: KitOptions;
+    };
+    settings(): BackgroundSettings;
+    /** The chosen ink token for the ground, or undefined for the preset's own default. */
+    ink(dark: boolean): string | undefined;
+    reducedMotion(): boolean | undefined;
+    /** The preset failed after mounting and has already removed itself. */
+    onFail(): void;
+}
+interface BackgroundRun {
+    /** The GPU field for field-driven presets; `null` for the canvas templates. */
+    readonly field: GlyphField | null;
+    readonly canvas: HTMLCanvasElement;
+    /** Re-reads settings and ink, and draws. */
+    refresh(): void;
+    play(): void;
+    pause(): void;
+    destroy(): void;
+}
+/** One background. Each is its own export, so a page pays only for the presets it imports. */
+interface BackgroundPreset {
+    readonly id: string;
+    readonly name: string;
+    readonly description: string;
+    /** Default character size in CSS pixels. */
+    readonly cellSize: number;
+    /** Default speed. */
+    readonly speed: number;
+    /** Whether the preset answers the pointer by default. */
+    readonly cursor: boolean;
+    readonly opacity?: number;
+    /** Mounts under the host's content; null when it cannot draw (no 2D canvas, or no WebGL2 for GPU presets). */
+    mount(context: BackgroundContext): BackgroundRun | null;
+}
+interface BackgroundHandle extends KitHandle<BackgroundOptions> {
+    /** The preset on screen. */
+    readonly preset: BackgroundPreset;
+    /** Cross-fades to another preset, keeping your options. Speed and size return to the new preset's defaults unless you set them. */
+    setPreset(preset: BackgroundPreset): void;
+}
+/** A named set, or your own characters; a custom ramp gains the empty first step the templates expect. */
+declare function backgroundCharset(charset: string | undefined): string | undefined;
+/**
+ * An animated ASCII background under an element's content: any of the /backgrounds presets, drawn the same way as on the site.
+ * Canvas templates draw with a 2D canvas; `drift`, `halftone`, `wordField` and `fluid` drive the GPU glyph field.
+ */
+declare function background(element: HTMLElement, options: BackgroundOptions): BackgroundHandle;
+
+/** Characters that drift slowly and stay clear around your content, drawn on the GPU. */
+declare const drift: BackgroundPreset;
+
+/** The drifting ground drawn as dots, clear around your content. `cellSize` is the dot spacing. */
+declare const halftone: BackgroundPreset;
+
+/** A word becomes the background, drawn by the GPU with a soft wake. Set it with `text`; `look: { scene: 'orb' }` for the orb. */
+declare const wordField: BackgroundPreset;
+
+/** Flowing folds with a soft wake behind the cursor: the original Asciify hero, driven through the GPU field. */
+declare const fluid: BackgroundPreset;
+
+/** Soft bands of light drift across the page and ripple under the cursor. */
+declare const aurora: BackgroundPreset;
+
+/** Fine pools of light that drift like water across stone. */
+declare const caustics: BackgroundPreset;
+
+/** Circuit traces with signals running along them. */
+declare const circuit: BackgroundPreset;
+
+/** Fine topographic lines with a slow, rolling drift. */
+declare const contour: BackgroundPreset;
+
+/** Double helices scroll past with base-pair letters. */
+declare const dna: BackgroundPreset;
+
+/** Layered sand ridges with slow-moving light and fine grain. */
+declare const dune: BackgroundPreset;
+
+/** Cut-grain lines follow a slow, sculpted current. */
+declare const etch: BackgroundPreset;
+
+/** Quiet folded planes catch light along their edges. */
+declare const facet: BackgroundPreset;
+
+/** A cellular flame rising from the bottom edge. */
+declare const fire: BackgroundPreset;
+
+/** Scan bands roll down a character grid and glitch near the cursor. */
+declare const grid: BackgroundPreset;
+
+/** Two fine line fields overlap into broad, shifting bands. */
+declare const moire: BackgroundPreset;
+
+/** Every cell shimmers at its own frequencies. */
+declare const morph: BackgroundPreset;
+
+/** A slow fractal noise field that warps around the cursor. */
+declare const noise: BackgroundPreset;
+
+/** Rings of characters ripple out from the cursor. */
+declare const pulse: BackgroundPreset;
+
+/** Columns of falling characters with bright heads. */
+declare const rain: BackgroundPreset;
+
+/** Long ribbons that follow a slow flow field. */
+declare const silk: BackgroundPreset;
+
+/** A sparse starfield that twinkles, drifts and leans toward the cursor. */
+declare const stars: BackgroundPreset;
+
+/** A side-scrolling landscape drawn in density characters. */
+declare const terrain: BackgroundPreset;
+
+/** Tall folds of light drifting across a quiet ground. */
+declare const veil: BackgroundPreset;
+
+/** A gravity well that spirals characters around the cursor. */
+declare const voidWell: BackgroundPreset;
+
+/** An interference field with a soft vortex at the cursor and a slow breath. */
+declare const wave: BackgroundPreset;
+
+/** Interlaced threads with a subtle change in tension. */
+declare const weave: BackgroundPreset;
+
+/** What a canvas template is drawn with each frame. */
+interface TemplateFrame {
+    fontSize: number;
+    chars: string | undefined;
+    ditherStrength: number;
+    lightMode: boolean;
+    /** The ink as #rrggbb. */
+    ink: string;
+    /** Your accent as #rrggbb, or undefined for the template's own. */
+    accent: string | undefined;
+    /** Seconds since mount at speed 1, for templates that keep their own clock (Fire). */
+    elapsed: number;
+    speed: number;
+}
+type TemplateDraw = (ctx: CanvasRenderingContext2D, width: number, height: number, time: number, mouse: {
+    x: number;
+    y: number;
+}, frame: TemplateFrame) => void;
+/**
+ * Runs a canvas template under the host's content exactly as the /backgrounds stage does: the same clock, pointer smoothing,
+ * pixel ratio and frame skipping. `warm` paints extra frames on mount and resize for templates that build up (Fire).
+ */
+declare function mountCanvas(context: BackgroundContext, draw: TemplateDraw, warmFrames?: number): BackgroundRun | null;
+
+/** The page-wide look `setGlobalLook` lays over every glyph field. */
+interface GlobalLook {
+    /** Characters for every glyph field that keeps none of letters of its own. Empty keeps each field's own. */
+    charset?: string;
+}
+/** Re-skins every glyph field on the page at once; `null` gives each field its own characters back. */
+declare function setGlobalLook(next: GlobalLook | null): void;
+declare const getGlobalLook: () => GlobalLook | null;
+/** Calls `listener` after each `setGlobalLook`. Returns the unsubscribe. */
+declare function subscribeGlobalLook(listener: (look: GlobalLook | null) => void): () => void;
+/**
+ * At most `n` kit fields hold a WebGL context at once (default 12; browsers drop the oldest past about 16).
+ * Past it the live field farthest off screen is released first, and shows its poster until it is the nearer one again.
+ */
+declare function setFieldBudget(n: number): void;
+declare const getFieldBudget: () => number;
+
+export { type AccordionHandle, type AccordionImage, type AccordionOptions, type ArtPanelHandle, type ArtPanelOptions, type AsciiVideoHandle, type AsciiVideoOptions, BEAM_PALETTES, type BackgroundCharset, type BackgroundContext, type BackgroundCursor, type BackgroundHandle, type BackgroundOptions, type BackgroundPreset, type BackgroundRun, type BackgroundSettings, type BeamHandle, type BeamMode, type BeamOptions, type BeamPalette, type BlockChartHandle, type BlockChartOptions, type Box, type ButtonLoadingHandle, type ButtonLoadingOptions, type ButtonState, type CodeInputHandle, type CodeInputOptions, type CodeState, type CommandPaletteHandle, type CommandPaletteOptions, type CompareHandle, type CompareOptions, type DecodeHandle, type DecodeOptions, type DisintegrateOptions, type DropState, type DroppedImage, type DropzoneHandle, type DropzoneOptions, type FieldBackgroundHandle, type FieldBackgroundOptions, type FieldPreset, type GenerateState, type GlobalLook, type ImageGenerateHandle, type ImageGenerateOptions, type ImageStream, type ImageUpdate, type KitHandle, type KitOptions, type LikeBurstHandle, type LikeBurstOptions, type LikeMark, type OdometerHandle, type OdometerOptions, type OrbState, PILL_TONES, type PageDissolveHandle, type PageDissolveOptions, type PaintFrame, type PillHandle, type PillOptions, type PillTone, type PricingGlowHandle, type PricingGlowOptions, type PullRefreshHandle, type PullRefreshOptions, type PullState, type SkeletonBlock, type SkeletonHandle, type SkeletonOptions, type SlideToConfirmHandle, type SlideToConfirmOptions, type StatusOrbHandle, type StatusOrbOptions, type StreamState, type StreamTextHandle, type StreamTextOptions, type Surface, type SurfaceConfig, type SwipeDeckHandle, type SwipeDeckOptions, type TabsHandle, type TabsOptions, type TemplateDraw, type TemplateFrame, type ThinkingHandle, type ThinkingOptions, type ThinkingState, type Toast, type ToastStackHandle, type ToastStackOptions, VOICE_PALETTES, type VoiceOrbHandle, type VoiceOrbOptions, type VoicePalette, type VoiceState, type WordmarkHandle, type WordmarkOptions, accordion, artPanel, asciiVideo, aurora, background, backgroundCharset, beam, beamPalette, blockChart, buttonLoading, caustics, circuit, codeInput, commandPalette, compare, contour, decode, disintegrate, dna, drift, dropzone, dune, etch, facet, fieldBackground, fire, fluid, getFieldBudget, getGlobalLook, grid, halftone, imageGenerate, likeBurst, moire, morph, mountCanvas, mountSurface, noise, odometer, pageDissolve, pill, pricingGlow, pullRefresh, pulse, rain, resolveColor, setFieldBudget, setGlobalLook, silk, skeleton, slideToConfirm, stars, statusOrb, streamText, subscribeGlobalLook, swipeDeck, tabs, terrain, thinking, toastStack, veil, voiceOrb, voidWell, wave, weave, wordField, wordmark };