@pixerate/editor 0.124.0 → 0.125.0

package/dist/flair-CxB3fOcU.d.ts

@@ -1,739 +0,0 @@
-import { a as MotionBehavior } from './behavior-Ymbld6jL.js';
-import { b as AnimationEasing } from './easing-lM0Xo9Ni.js';
-import { b as AnimationLoopMode } from './evaluate-CfmT6xA3.js';
-import { V as VectorDocument } from './types-BcX7sCsn.js';
-
-/**
- * A vector animation as plain JSON: a piece of vector artwork (the editor's `VectorDocument`,
- * as the vector editor draws it) and the shots that bring it to life.
- *
- * Shots, not timelines: a shot frames the camera, plays its commands and holds. Timing comes
- * from the content (each command has a sensible default length, and drawing a line takes as
- * long as the line is long), so there are no keyframes to manage. The same scene plays the
- * same frames every time: every frame is a pure function of time.
- */
-interface MotionScene {
-    /** Format version (always 1). */
-    version: 1;
-    /** A short name, e.g. `logo-reveal`. */
-    name: string;
-    description?: string;
-    /** The artwork in its resting state. Commands target its node ids. */
-    artwork: VectorDocument;
-    shots: MotionShot[];
-    /** Playback past the end: stop (`none`, default), `loop` or `ping-pong`. */
-    loop?: AnimationLoopMode;
-    /**
-     * Plays in answer to the viewer instead of on its own (exported to Flair's player):
-     * - `click`: nothing plays until the viewer clicks; each click plays the next shot, and after the
-     *   last one a click plays the first again, so a last shot that puts things back makes a toggle.
-     * - `hover` / `press`: plays forward while the pointer is over (or down on) it, and back when it leaves.
-     * - `scroll`: scrubs through the scene as it scrolls through the viewport.
-     * The editor previews it played through; `loop` does not apply.
-     */
-    trigger?: MotionTrigger;
-    /** Frame rate used to sample motion that a target format cannot express exactly (default 30). */
-    fps?: number;
-    /**
-     * Stepped time for every command that gives none: changes hold on a grid of this many frames
-     * per second ("on twos" at 12), for a hand-drawn look. Default: smooth.
-     */
-    steps?: number;
-    /** A beat grid to cue shots to (`MotionShot.at.beat`): music or a voiceover's rhythm. */
-    beat?: MotionBeatGrid;
-    /** A voiceover's words with their times, to cue shots to (`MotionShot.at.word`). */
-    narration?: MotionNarration;
-    /** Wanted length in seconds `[min, max]`; `check` warns outside it. */
-    target?: [number, number];
-    /**
-     * Reusable motion: named command lists written against the target `"$"`, played on any
-     * node with a `play` command (a "pop and settle" or "attention" you use many times).
-     */
-    clips?: Record<string, MotionClip>;
-    /**
-     * Properties that follow other properties: a background moving at half the speed of the
-     * foreground (parallax), a wheel turning as it rolls. Each adds to what its target's commands do.
-     */
-    drivers?: MotionDriver[];
-    /**
-     * Motion blur on the stage and in rendered frames (not in exports): each frame averages a few
-     * moments across the shutter, more for faster motion.
-     */
-    motionBlur?: MotionBlur;
-    /** Parameters a Flair effect made from this scene exposes (see `toFlairVectorEffect`). */
-    controls?: MotionControl[];
-    /** Named sets of control values. */
-    presets?: MotionPreset[];
-}
-/** What the viewer does to play a triggered scene (see `MotionScene.trigger`). */
-type MotionTrigger = 'click' | 'hover' | 'press' | 'scroll';
-declare const MOTION_TRIGGERS: readonly MotionTrigger[];
-/** A rectangle of the artwork, in document units. */
-interface MotionRect {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-/**
- * Where the camera looks: a rectangle, or the id of a node to frame (with `padding` around
- * its bounds, default 24). The camera eases there over `ms` (default 1000; the first shot cuts).
- */
-type MotionCamera = (MotionRect | {
-    frame: string;
-    padding?: number;
-}) & {
-    ease?: AnimationEasing;
-    ms?: number;
-    /** Zoom at a steady rate (the size changes by the same factor each moment) instead of linearly. */
-    geometric?: boolean;
-};
-/** A steady beat: `bpm` beats a minute, the first at `offset` ms, `meter` beats a bar. */
-interface MotionBeatGrid {
-    bpm: number;
-    /** When beat 0 falls, ms (default 0). */
-    offset?: number;
-    /** Beats in a bar (default 4), for reading beats as bar and beat. */
-    meter?: number;
-}
-/** A voiceover: its words in order, each with when it is said (ms), from a TTS or speech-to-text word timing. */
-interface MotionNarration {
-    words: {
-        text: string;
-        start: number;
-        end?: number;
-    }[];
-}
-/** When a shot is cued to start: on a beat, on a narration word, or at a time. */
-interface MotionCue {
-    /** Beat number on the scene's beat grid, from 0 (fractions for off-beats: 2.5 is the "and" of beat 3). */
-    beat?: number;
-    /** Index of a word in the scene's narration, from 0. */
-    word?: number;
-    /** A time in ms. */
-    ms?: number;
-}
-/** One beat of the animation. */
-interface MotionShot {
-    /** Stable id (unique in the scene), e.g. `intro`. */
-    id: string;
-    /** What happens in this shot, in a few words (shown on the timeline). */
-    label?: string;
-    /** Omit to keep the current framing. */
-    camera?: MotionCamera;
-    /**
-     * Start on a cue: a beat, a narration word or a time. The shot before holds until then; a
-     * cue that comes before the shot before has ended is missed (`check` says by how much).
-     * Give one of `beat`, `word` or `ms`.
-     */
-    at?: MotionCue;
-    /** Commands, played one after another (unless a command says `with: "previous"`). */
-    run: MotionCommand[];
-    /** Milliseconds to hold after the commands finish (default 600). */
-    hold?: number;
-    /**
-     * Plays the whole shot this many times as fast (default 1): its camera move, delays,
-     * durations, staggers and hold all scale by 1 / speed. `fit_animation` sets it to fit a length.
-     */
-    speed?: number;
-}
-/** How `split` splits outlined text. */
-type MotionTextUnit = 'letter' | 'word' | 'line';
-declare const MOTION_TEXT_UNITS: readonly MotionTextUnit[];
-/** The order `split` units animate in. */
-type MotionCascade = 'forward' | 'backward' | 'center' | 'edges' | 'random';
-declare const MOTION_CASCADES: readonly MotionCascade[];
-/** Fields every command takes. */
-interface MotionCommandBase {
-    /** Node ids from the artwork (groups animate as one, unless `split` splits their text). */
-    targets: string[];
-    /**
-     * For outlined text (a group of letter paths): animate it a letter, word or line at a time,
-     * staggered in reading order (default stagger 40 ms a letter, 120 a word, 300 a line).
-     */
-    split?: MotionTextUnit;
-    /** With `split`: the order units go in (default `forward`). `random` is the same every time. */
-    cascade?: MotionCascade;
-    /** Length in ms for each target, one cycle when repeating (each type has a default; `draw` follows the path length; a spring `ease` lasts until it settles). */
-    duration?: number;
-    /** Wait this many ms before starting (default 0). */
-    delay?: number;
-    /** Start each further target this many ms after the one before (default 0). */
-    stagger?: number;
-    /** `after` (default) starts when the commands before it finish; `previous` starts with the command before. */
-    with?: 'after' | 'previous';
-    /** An easing; a spring with no `duration` lasts until it settles. */
-    ease?: AnimationEasing;
-    /** Why this command is here (for people and agents reading the scene). */
-    note?: string;
-    /**
-     * Play the change this many times (a whole number, default 1); `duration` is one cycle. Not
-     * for `enter`, `exit` or `wait`.
-     */
-    repeat?: number;
-    /**
-     * How repeats follow each other: `loop` (default) starts each cycle afresh, `mirror` plays
-     * every other one backwards, `offset` carries on from where the last ended (rotate by 90,
-     * repeat 4: a full turn). Colours and shapes offset like `loop`.
-     */
-    repeatMode?: 'loop' | 'mirror' | 'offset';
-    /** Stepped time: hold the change on a grid of this many frames per second (default: the scene's `steps`, else smooth). */
-    steps?: number;
-}
-type MotionEnterStyle = 'fade' | 'pop' | 'grow' | 'slide' | 'draw' | 'zoom' | 'rise' | 'wipe' | 'iris' | 'split';
-type MotionExitStyle = 'fade' | 'shrink' | 'slide' | 'undraw' | 'wipe';
-type MotionDirection = 'up' | 'down' | 'left' | 'right';
-/** The opening an `iris` reveals through. */
-type MotionIrisShape = 'circle' | 'box';
-/** The line a `split` opens from. */
-type MotionSplitOrientation = 'horizontal' | 'vertical';
-/**
- * Brings hidden targets in. Targets entered in a shot are hidden before it. Each style is a
- * Flair motion primitive (`entrance.<style>`) with the same defaults.
- */
-interface MotionEnterCommand extends MotionCommandBase, MotionDrawOrder {
-    type: 'enter';
-    /**
-     * Default `fade`. `draw` draws the outline on, then fades the fill in. `pop` scales up past
-     * full size and settles; `zoom` settles from larger; `rise` rises a short way with a little
-     * overshoot. `wipe`, `iris` and `split` reveal the target through a clip over its box (see
-     * `MotionFrame.clips`), reaching past it far enough to show its whole stroke.
-     */
-    style?: MotionEnterStyle;
-    /**
-     * For `slide`: the direction of travel (default `up`). For `wipe`: the way the edge travels
-     * (default `right`, which reveals from the left).
-     */
-    direction?: MotionDirection;
-    /** For `slide` (default 40) and `rise` (default 20): how far in document units. */
-    distance?: number;
-    /** For `pop` (default 0.5) and `zoom` (default 1.6): the starting scale. */
-    scale?: number;
-    /** For `iris`: open through a `circle` (default; an ellipse on a box that is not square) or a `box`. */
-    shape?: MotionIrisShape;
-    /** For `split`: open up and down from a `horizontal` line through the middle (default), or left and right from a `vertical` one. */
-    orientation?: MotionSplitOrientation;
-}
-/** Takes targets out. */
-interface MotionExitCommand extends MotionCommandBase, MotionDrawOrder {
-    type: 'exit';
-    /** Default `fade`. `wipe` hides the target behind an edge travelling `direction` (a wipe in, reversed). */
-    style?: MotionExitStyle;
-    /** For `slide`: the direction of travel (default `down`). For `wipe`: the way the edge travels (default `right`, which hides from the left). */
-    direction?: MotionDirection;
-    distance?: number;
-}
-/**
- * How the strokes of a group (or several paths) draw on or off together. Default: all at once,
- * each over the whole time.
- */
-interface MotionDrawOrder {
-    /** `together` (default) or `sequence`: one stroke after another, each for a time in proportion to its length. */
-    order?: 'together' | 'sequence';
-    /** With `together`: `time` (default) gives every stroke the whole time; `speed` draws them all at one speed, so short ones take less. */
-    pace?: 'time' | 'speed';
-    /** With `pace: "speed"`: `start` (default) starts them together, `end` finishes them together. */
-    align?: 'start' | 'end';
-    /** With `sequence`: `document` (default, stacking order) or `distance` from `origin` (a radial reveal). */
-    sortBy?: 'document' | 'distance';
-    /** With `sortBy: "distance"`: the point (document units) strokes are drawn out from (default the target's centre). */
-    origin?: {
-        x: number;
-        y: number;
-    };
-}
-/** Draws a stroke on (or off) between two fractions of its length. */
-interface MotionDrawCommand extends MotionCommandBase, MotionDrawOrder {
-    type: 'draw';
-    /**
-     * A travelling stroke this fraction of the length long (0–1): it runs along the path and off
-     * the end, instead of drawing it on and leaving it.
-     */
-    comet?: number;
-    /** Fraction drawn at the end (default 1). */
-    to?: number;
-    /** Fraction drawn at the start (default: what is drawn now). */
-    from?: number;
-}
-/** Moves targets by an offset, or to a point (their centre lands there). */
-interface MotionMoveCommand extends MotionCommandBase {
-    /**
-     * `add` makes the change a layer over the pose instead of a change to it: it stacks on
-     * whatever else moves the target (a shake on a slide), and what it adds stays once it ends.
-     * Default `replace` for move, rotate and scale (the later change takes over), `add` for
-     * pulse, shake, teeter, wave and wiggle.
-     */
-    blend?: 'replace' | 'add';
-    type: 'move';
-    by?: {
-        x: number;
-        y: number;
-    };
-    to?: {
-        x: number;
-        y: number;
-    };
-    /**
-     * Points (document units) the centre passes through on the way, in order. The path is
-     * smooth (velocity carries through each point) and never overshoots a point.
-     */
-    via?: {
-        x: number;
-        y: number;
-    }[];
-    /** With `via`: `even` (default) keeps the speed steady along the path, `equal` gives each leg the same time. */
-    pacing?: 'even' | 'equal';
-}
-/** Turns targets about their centre, by or to an angle in degrees (clockwise). */
-interface MotionRotateCommand extends MotionCommandBase {
-    /**
-     * `add` makes the change a layer over the pose instead of a change to it: it stacks on
-     * whatever else moves the target (a shake on a slide), and what it adds stays once it ends.
-     * Default `replace` for move, rotate and scale (the later change takes over), `add` for
-     * pulse, shake, teeter, wave and wiggle.
-     */
-    blend?: 'replace' | 'add';
-    type: 'rotate';
-    by?: number;
-    to?: number;
-}
-/** Scales targets about their centre (1 = rest size). */
-interface MotionScaleCommand extends MotionCommandBase {
-    /**
-     * `add` makes the change a layer over the pose instead of a change to it: it stacks on
-     * whatever else moves the target (a shake on a slide), and what it adds stays once it ends.
-     * Default `replace` for move, rotate and scale (the later change takes over), `add` for
-     * pulse, shake, teeter, wave and wiggle.
-     */
-    blend?: 'replace' | 'add';
-    type: 'scale';
-    to: number | {
-        x: number;
-        y: number;
-    };
-    /** Grow at a steady rate (the same factor each moment), which reads as an even zoom. */
-    geometric?: boolean;
-}
-/** Changes opacity (0–1). */
-interface MotionFadeCommand extends MotionCommandBase {
-    type: 'fade';
-    to: number;
-}
-/** Changes solid paints and stroke width. Colours mix in OKLab. */
-interface MotionStyleCommand extends MotionCommandBase {
-    type: 'style';
-    fill?: string;
-    stroke?: string;
-    strokeWidth?: number;
-}
-/** Morphs each target into the shape of another node (`into`), which usually stays hidden. */
-interface MotionMorphCommand extends MotionCommandBase {
-    type: 'morph';
-    into: string;
-}
-/**
- * Smart Animate: tweens a group into another group (`into`, usually hidden), part by part. Each
- * part of the target takes the shape, paint and place of its partner in `into`, paired by name,
- * then by id (`card-a-title` ↔ `card-b-title`), then by kind in order. Parts with no partner fade
- * out; parts of `into` with no partner do not appear (`check` lists them).
- */
-interface MotionMatchCommand extends MotionCommandBase {
-    type: 'match';
-    /** Id of the group (or node) to become. */
-    into: string;
-}
-/** A reusable piece of motion: commands that target `"$"` (whatever `play` names), timed as in a shot. */
-interface MotionClip {
-    description?: string;
-    /** Commands, timed as in a shot; `"$"` in `targets` stands for the node played on. Clips cannot play clips. */
-    run: MotionCommand[];
-}
-/** Motion blur: how long the shutter is open and how many moments a frame averages at most. */
-interface MotionBlur {
-    /** Shutter angle in degrees of a frame at the scene's fps (default 180: half a frame; 360 is a whole frame). */
-    shutter?: number;
-    /** Most moments a frame averages (default 8, at most 32); fewer for slower motion. */
-    samples?: number;
-}
-/** Properties a driver reads and drives: offsets (document units), turn (degrees), scales and opacity. */
-type MotionDrivenProperty = 'x' | 'y' | 'rotation' | 'scaleX' | 'scaleY' | 'opacity';
-declare const MOTION_DRIVEN_PROPERTIES: readonly MotionDrivenProperty[];
-/**
- * One property following another. Both are read as a change from rest (offsets and turns from
- * 0, scales and opacity from 1): the target's property changes by `source change · factor + offset`,
- * clamped to `clamp`, on top of its own commands (added to offsets and turns, multiplied into
- * scales and opacity as 1 + change).
- */
-interface MotionDriver {
-    /** The node that follows. */
-    target: string;
-    property: MotionDrivenProperty;
-    /** The node and property it follows. */
-    source: {
-        node: string;
-        property: MotionDrivenProperty;
-    };
-    /** Default 1 (0.5 moves at half the speed; 360 / (2π·radius) turns a wheel by how far it rolls). */
-    factor?: number;
-    /** Added to the change (default 0). */
-    offset?: number;
-    /** Limits the change to `[min, max]`. */
-    clamp?: [number, number];
-}
-/** The placeholder target in a clip's commands. */
-declare const MOTION_CLIP_TARGET = "$";
-/** Plays a clip (`scene.clips`) on the targets: its commands, with `"$"` standing for each target. */
-interface MotionPlayCommand extends MotionCommandBase {
-    type: 'play';
-    /** The clip's name. */
-    clip: string;
-    /** Play it this many times as fast (default 1). */
-    speed?: number;
-}
-/** Moves targets along a path node, centre on the path. */
-interface MotionFollowCommand extends MotionCommandBase {
-    type: 'follow';
-    /** Id of a path node in the artwork (it can be hidden). */
-    path: string;
-    /**
-     * Turn with the path's direction (default false). Moves, shakes and wiggles made during the
-     * follow then turn with it too: they are offsets from the target's place on the path.
-     */
-    rotate?: boolean;
-    /** Fractions of the path's length to travel between (default 0 → 1). */
-    from?: number;
-    to?: number;
-}
-/** Scales up and back, `count` times (draws the eye). */
-interface MotionPulseCommand extends MotionCommandBase {
-    /**
-     * `add` makes the change a layer over the pose instead of a change to it: it stacks on
-     * whatever else moves the target (a shake on a slide), and what it adds stays once it ends.
-     * Default `replace` for move, rotate and scale (the later change takes over), `add` for
-     * pulse, shake, teeter, wave and wiggle.
-     */
-    blend?: 'replace' | 'add';
-    type: 'pulse';
-    /** Extra scale at the peak (default 0.15). */
-    amount?: number;
-    count?: number;
-}
-/** Shakes side to side (or up and down), settling. */
-interface MotionShakeCommand extends MotionCommandBase {
-    /**
-     * `add` makes the change a layer over the pose instead of a change to it: it stacks on
-     * whatever else moves the target (a shake on a slide), and what it adds stays once it ends.
-     * Default `replace` for move, rotate and scale (the later change takes over), `add` for
-     * pulse, shake, teeter, wave and wiggle.
-     */
-    blend?: 'replace' | 'add';
-    type: 'shake';
-    /** Distance in document units (default 8). */
-    amount?: number;
-    count?: number;
-    /** Default `horizontal`. */
-    axis?: 'horizontal' | 'vertical';
-}
-/** Rocks about the centre by `angle` either way, settling (Flair's `emphasis.teeter`). */
-interface MotionTeeterCommand extends MotionCommandBase {
-    /**
-     * `add` makes the change a layer over the pose instead of a change to it: it stacks on
-     * whatever else moves the target (a shake on a slide), and what it adds stays once it ends.
-     * Default `replace` for move, rotate and scale (the later change takes over), `add` for
-     * pulse, shake, teeter, wave and wiggle.
-     */
-    blend?: 'replace' | 'add';
-    type: 'teeter';
-    /** Degrees either way (default 8). */
-    angle?: number;
-    /** Rocks (default 3). */
-    count?: number;
-}
-/** Bobs up and down without settling, like something floating (Flair's `emphasis.wave`). */
-interface MotionWaveCommand extends MotionCommandBase {
-    /**
-     * `add` makes the change a layer over the pose instead of a change to it: it stacks on
-     * whatever else moves the target (a shake on a slide), and what it adds stays once it ends.
-     * Default `replace` for move, rotate and scale (the later change takes over), `add` for
-     * pulse, shake, teeter, wave and wiggle.
-     */
-    blend?: 'replace' | 'add';
-    type: 'wave';
-    /** Height in document units (default 6). */
-    amount?: number;
-    /** Bobs (default 2). */
-    count?: number;
-}
-/**
- * Wanders about its place as smooth seeded noise, easing out of and back to rest (Flair's
- * `emphasis.wiggle`). The same seed always wanders the same way.
- */
-interface MotionWiggleCommand extends MotionCommandBase {
-    /**
-     * `add` makes the change a layer over the pose instead of a change to it: it stacks on
-     * whatever else moves the target (a shake on a slide), and what it adds stays once it ends.
-     * Default `replace` for move, rotate and scale (the later change takes over), `add` for
-     * pulse, shake, teeter, wave and wiggle.
-     */
-    blend?: 'replace' | 'add';
-    type: 'wiggle';
-    /** Up to about this far, in document units (default 6). */
-    amount?: number;
-    /** Wanders per second, in Hz (default 3). */
-    frequency?: number;
-    /** Layers of finer detail (default 2). */
-    octaves?: number;
-    /** Also turns about the centre by up to about this many degrees (default 0). */
-    rotate?: number;
-    /** A whole number; default: one picked from the target's id, so each target wanders its own way. */
-    seed?: number;
-}
-/** Tints solid paint toward a colour and back, `count` times (Flair's `emphasis.color-pulse`). */
-interface MotionColorPulseCommand extends MotionCommandBase {
-    type: 'color-pulse';
-    /** The tint (default `#f59e0b`). Mixes in OKLab. */
-    color?: string;
-    /** Which paint (default `fill`). On a group it tints every path in it. */
-    paint?: 'fill' | 'stroke';
-    count?: number;
-}
-/** Tweens a numeric parameter of a live path effect on the target (twist angle, wiggle time, zig zag size…). */
-interface MotionEffectCommand extends MotionCommandBase {
-    type: 'effect';
-    /** Id of an effect in the target node's `effects`. */
-    effect: string;
-    /** A numeric parameter of that effect, e.g. `angle`. */
-    param: string;
-    to: number;
-}
-/** Does nothing for `duration` ms. */
-interface MotionWaitCommand {
-    type: 'wait';
-    duration: number;
-    with?: 'after' | 'previous';
-    note?: string;
-}
-type MotionCommand = MotionEnterCommand | MotionExitCommand | MotionDrawCommand | MotionMoveCommand | MotionRotateCommand | MotionScaleCommand | MotionFadeCommand | MotionStyleCommand | MotionMorphCommand | MotionMatchCommand | MotionPlayCommand | MotionFollowCommand | MotionPulseCommand | MotionShakeCommand | MotionTeeterCommand | MotionWaveCommand | MotionWiggleCommand | MotionColorPulseCommand | MotionEffectCommand | MotionWaitCommand;
-type MotionCommandType = MotionCommand['type'];
-declare const MOTION_COMMAND_TYPES: readonly MotionCommandType[];
-declare const MOTION_ENTER_STYLES: readonly MotionEnterStyle[];
-declare const MOTION_BLENDS: readonly ["replace", "add"];
-declare const MOTION_REPEAT_MODES: readonly ["loop", "mirror", "offset"];
-declare const MOTION_EXIT_STYLES: readonly MotionExitStyle[];
-declare const MOTION_IRIS_SHAPES: readonly MotionIrisShape[];
-declare const MOTION_SPLIT_ORIENTATIONS: readonly MotionSplitOrientation[];
-declare const MOTION_DIRECTIONS: readonly MotionDirection[];
-/**
- * A colour parameter of the effect made from the scene: it stands for every use of its
- * `default` colour in the artwork and the commands, so recolouring it recolours them all.
- */
-interface MotionControl {
-    /** Identifier, e.g. `accent`. */
-    name: string;
-    type: 'color';
-    /** A `#rrggbb` colour used in the scene. */
-    default: string;
-    label?: string;
-}
-interface MotionPreset {
-    name: string;
-    values: Record<string, string>;
-}
-/** Default lengths (ms) of commands that give none. */
-declare const MOTION_DEFAULT_DURATIONS: Readonly<Record<Exclude<MotionCommandType, 'wait' | 'draw'>, number>>;
-/** Default hold after a shot's commands (ms). */
-declare const MOTION_DEFAULT_HOLD = 600;
-/** Default camera move (ms). */
-declare const MOTION_CAMERA_MS = 1000;
-/** `draw` lasts `length × MOTION_DRAW_MS_PER_UNIT`, clamped to `MOTION_DRAW_RANGE`. */
-declare const MOTION_DRAW_MS_PER_UNIT = 1.5;
-declare const MOTION_DRAW_RANGE: readonly [number, number];
-/**
- * The Flair motion primitive (`@pixerate/flair/motion`) a command plays, or undefined when
- * Flair has none (`move`, `scale`, `fade`, `style`, `morph`, `effect`, `wait` are the editor's
- * own). Commands and primitives of the same name take the same parameters and defaults.
- */
-declare function motionFlairPrimitive(command: MotionCommand): string | undefined;
-
-/**
- * Export to Flair (`@pixerate/flair`): a scene becomes an `SvgMotion` (one SVG plus a list of
- * from → to changes on its elements), a catalog `VectorEffect`, or an `EffectDocument` for
- * Flair's effect editor. The types are mirrored here so this package does not depend on Flair.
- *
- * Changes are exact where Flair can express them: a change with a linear, cubic-out or
- * cubic-in-out curve (the editor's defaults) is one change, and so (Flair 0.36 and later) is
- * one with any cubic-bezier curve, written as `[x1, y1, x2, y2]`. Anything else (springs,
- * elastic, `hold`, morphs and live-effect tweens) is sampled at the
- * scene's `fps` into short linear changes, which Flair plays the same way. Pulses, shakes,
- * teeters, waves, wiggles and colour pulses are one change with a `behavior` (Flair 0.38).
- *
- * Reveals (`wipe`, `iris`, `split`) wrap their node in a group clipped through a rect or circle
- * in the group's own box units (`clipPathUnits="objectBoundingBox"`), as Flair's
- * `entrance.wipe` does, and animate the shape's attributes. A follow wraps its node in a group
- * that Flair's `along` carries along a copy of the path in the node's parent's units (written
- * in `<defs>`, so the path may be hidden or anywhere), turning with it for `orient`, as
- * Flair's `path.follow` does.
- */
-/** Flair's easing names. */
-type FlairEaseName = 'linear' | 'in-out' | 'out';
-/** Flair's spring ease (Flair 0.39 and later): the editor's spring, number for number. */
-interface FlairSpringEase {
-    spring: {
-        mass?: number;
-        stiffness?: number;
-        damping?: number;
-        velocity?: number;
-    };
-}
-/** A Flair easing: a name, (Flair 0.36 and later) a CSS cubic-bezier `[x1, y1, x2, y2]`, or (0.39) a spring. */
-type FlairEase = FlairEaseName | readonly [number, number, number, number] | FlairSpringEase;
-/** Flair's curves, for matching. */
-declare const FLAIR_EASES: Readonly<Record<FlairEaseName, (t: number) => number>>;
-/** One change of a Flair `SvgMotion` (mirrors `SvgAnimation` in `@pixerate/flair/vector`). */
-interface FlairSvgAnimation {
-    id?: string;
-    step?: number;
-    delay?: number;
-    ms?: number;
-    ease?: FlairEase;
-    attrs?: Record<string, readonly [string | number, string | number]>;
-    draw?: boolean | readonly [number, number];
-    /** Moves the element along a path (by id), from and to the fractions of its length in `at`. */
-    along?: string;
-    at?: readonly [number, number];
-    /** With `along`: turns the element with the path's direction. */
-    orient?: boolean;
-    /** Flair 0.38 and later: how the change swings from → to (see `MotionBehavior`). */
-    behavior?: MotionBehavior;
-    /** Flair 0.39 and later: stepped time, held on a grid of this many frames per second. */
-    strobe?: number;
-    /** Flair 0.39 and later: whole cycles to play (default 1); with `alternate`, every other one backwards. */
-    repeat?: number;
-    alternate?: boolean;
-    /** Flair features scenes do not have (imports skip them with a note). */
-    count?: readonly [number, number];
-    /** With `count`: how the number is written (Flair's number format) and to how many decimals. */
-    format?: string;
-    decimals?: number;
-    write?: string;
-    /** With `write`: the caret drawn while typing. */
-    caret?: string;
-    /** Flair's label for the change, e.g. `entrance.fade＠logo`; motion primitives set it to find their changes again. */
-    tag?: string;
-    scramble?: string;
-    solo?: number;
-    view?: readonly [number, number, number, number] | string;
-}
-/** Mirrors `SvgMotion` in `@pixerate/flair/vector`. */
-interface FlairSvgMotion {
-    svg: string;
-    animate?: FlairSvgAnimation[];
-}
-/** Mirrors Flair's catalog `VectorEffect` (`@pixerate/flair/catalog`). */
-interface FlairVectorEffect {
-    kind: 'vector';
-    id: string;
-    name: string;
-    description: string;
-    category: string;
-    tags: string[];
-    motion: FlairSvgMotion;
-    /** Values are `#rrggbb` strings, or `[r, g, b]` channels from 0 to 1 (Flair's catalog writes both); imports turn them into hex. */
-    presets?: {
-        name: string;
-        values: Record<string, string | readonly number[]>;
-    }[];
-    /** Ms on the last frame before looping. */
-    hold?: number;
-    trigger?: 'hover' | 'press' | 'click' | 'scroll';
-}
-/** Mirrors Flair's `EffectDocument` (`@pixerate/flair/editor`) for a vector effect. */
-interface FlairEffectDocument {
-    version: 1;
-    name: string;
-    effect: {
-        kind: 'vector';
-        motion: FlairSvgMotion;
-        hold?: number;
-    };
-    values: Record<string, string>;
-    tracks: Record<string, never>;
-    duration: number;
-    loop: boolean;
-    presets: {
-        name: string;
-        values: Record<string, string>;
-    }[];
-}
-interface FlairMotionExport {
-    motion: FlairSvgMotion;
-    /** The scene's length (ms). */
-    duration: number;
-    /** Ms after the last change (Flair's `hold`). */
-    hold: number;
-    /** Changes sampled into linear steps. */
-    sampled: number;
-    /** What could not be carried over, in sentences. */
-    notes: string[];
-    /** How the viewer plays it: pass to Flair's `SvgPlayer` as `{ trigger }` (from the scene's `trigger`). */
-    trigger?: MotionTrigger;
-}
-interface FlairExportOptions {
-    /**
-     * Play in answer to the viewer (default: the scene's `trigger`; null for none). With `click`
-     * shot n is Flair step n + 1: nothing plays until the first click, and each click plays the next shot.
-     */
-    trigger?: MotionTrigger | null;
-    /** Sampling rate for changes Flair cannot express exactly (default: the scene's `fps`, else 30). */
-    fps?: number;
-    /** Decimal places (default 3). */
-    precision?: number;
-    /**
-     * Write cubic-bezier easings (the `ease`, `ease-in`, `ease-out`, `ease-in-out`, `ease-in-back`
-     * and `ease-out-back` presets, and `{ type: 'cubic-bezier' }` curves) as one change with
-     * `ease: [x1, y1, x2, y2]` (default true). Needs Flair 0.36 or later; set false for older
-     * Flair, and they are sampled into linear steps.
-     */
-    curves?: boolean;
-    /**
-     * Write pulses, shakes, teeters, waves, wiggles and colour pulses as one change with a Flair
-     * `behavior` (default true), so they play exactly. Needs Flair 0.38 or later; set false for
-     * older Flair, and they are sampled into linear steps.
-     */
-    behaviors?: boolean;
-    /**
-     * The Flair version the export is for (default `0.39`): it decides what is written exactly
-     * and what is sampled. 0.36 adds cubic-bezier curves, 0.38 behaviours, 0.39 springs and
-     * stepped time (`strobe`). `curves` and `behaviors` override it.
-     */
-    flair?: string;
-}
-/** The Flair version exports target by default. */
-declare const FLAIR_EXPORT_VERSION = "0.39";
-/** Whether Flair `version` is at least `min` (dotted numbers). */
-declare function flairAtLeast(version: string, min: string): boolean;
-/** The Flair easing that matches `ease` (within 1% everywhere), if any. */
-declare function flairEaseFor(ease: AnimationEasing): FlairEaseName | undefined;
-/**
- * The Flair easing for `ease`: a Flair name when one matches within 1%, else (with `curves`,
- * the default) the curve's `[x1, y1, x2, y2]` when it is a cubic-bezier. Undefined for curves
- * Flair cannot play (springs, elastic, `hold`), which are sampled.
- */
-declare function flairCurveFor(ease: AnimationEasing, curves?: boolean): FlairEase | undefined;
-/** A scene as a Flair `SvgMotion`. */
-declare function toFlairSvgMotion(scene: MotionScene, options?: FlairExportOptions): FlairMotionExport;
-interface FlairEffectOptions extends FlairExportOptions {
-    /** Kebab-case id (default: the scene's name). */
-    id?: string;
-    name?: string;
-    description?: string;
-    /** Flair catalog category (default `icon`). */
-    category?: string;
-    tags?: string[];
-}
-/** A scene as a Flair catalog vector effect, with its colour controls and presets. */
-declare function toFlairVectorEffect(scene: MotionScene, options?: FlairEffectOptions): FlairVectorEffect;
-/** A scene as a document for Flair's `EffectEditor` (`replaceDocument`). */
-declare function toFlairEffectDocument(scene: MotionScene, options?: FlairExportOptions): FlairEffectDocument;
-
-export { type MotionCommandBase as $, type MotionNarration as A, FLAIR_EASES as B, FLAIR_EXPORT_VERSION as C, type FlairEase as D, type FlairEaseName as E, type FlairSvgAnimation as F, type FlairSpringEase as G, MOTION_BLENDS as H, MOTION_CAMERA_MS as I, MOTION_CASCADES as J, MOTION_CLIP_TARGET as K, MOTION_COMMAND_TYPES as L, type MotionCommand as M, MOTION_DEFAULT_DURATIONS as N, MOTION_DEFAULT_HOLD as O, MOTION_DIRECTIONS as P, MOTION_DRAW_MS_PER_UNIT as Q, MOTION_DRAW_RANGE as R, MOTION_DRIVEN_PROPERTIES as S, MOTION_ENTER_STYLES as T, MOTION_EXIT_STYLES as U, MOTION_IRIS_SHAPES as V, MOTION_REPEAT_MODES as W, MOTION_SPLIT_ORIENTATIONS as X, MOTION_TEXT_UNITS as Y, MOTION_TRIGGERS as Z, type MotionColorPulseCommand as _, type MotionShot as a, type MotionDrawCommand as a0, type MotionDrawOrder as a1, type MotionEffectCommand as a2, type MotionEnterCommand as a3, type MotionExitCommand as a4, type MotionFadeCommand as a5, type MotionFollowCommand as a6, type MotionMatchCommand as a7, type MotionMorphCommand as a8, type MotionMoveCommand as a9, type MotionPlayCommand as aa, type MotionPulseCommand as ab, type MotionRotateCommand as ac, type MotionScaleCommand as ad, type MotionShakeCommand as ae, type MotionStyleCommand as af, type MotionTeeterCommand as ag, type MotionTrigger as ah, type MotionWaitCommand as ai, type MotionWaveCommand as aj, type MotionWiggleCommand as ak, flairAtLeast as al, flairCurveFor as am, flairEaseFor as an, motionFlairPrimitive as ao, toFlairEffectDocument as ap, toFlairSvgMotion as aq, toFlairVectorEffect as ar, type MotionScene as b, type MotionDirection as c, type MotionIrisShape as d, type MotionSplitOrientation as e, type MotionDriver as f, type MotionDrivenProperty as g, type MotionRect as h, type MotionBeatGrid as i, type MotionCue as j, type MotionCamera as k, type MotionTextUnit as l, type MotionCascade as m, type MotionBlur as n, type MotionControl as o, type MotionPreset as p, type MotionClip as q, type FlairSvgMotion as r, type FlairVectorEffect as s, type FlairExportOptions as t, type FlairMotionExport as u, type FlairEffectOptions as v, type FlairEffectDocument as w, type MotionEnterStyle as x, type MotionExitStyle as y, type MotionCommandType as z };