{"version":3,"file":"TransformAnimation.mjs","sources":["../../../../../src/animation/waapi/transforms/TransformAnimation.ts"],"sourcesContent":["import {\n    BezierDefinition,\n    clamp,\n    EasingFunction,\n    easingDefinitionToFunction,\n    isBezierDefinition,\n    isEasingArray,\n    millisecondsToSeconds,\n    progress,\n} from \"motion-utils\"\nimport { frame } from \"../../../frameloop/frame\"\nimport { frameData } from \"../../../frameloop/frame-data\"\nimport { time } from \"../../../frameloop/sync-time\"\nimport {\n    isDefaultTransform,\n    transformFunction,\n} from \"../../../render/html/utils/build-transform\"\nimport type { ResolvedValues } from \"../../../render/types\"\nimport { transformPropOrder } from \"../../../render/utils/keys-transform\"\nimport { mixNumber } from \"../../../utils/mix/number\"\nimport type { MotionValue, Owner } from \"../../../value\"\nimport { frameloopDriver } from \"../../drivers/frame\"\nimport { Driver, DriverControls } from \"../../drivers/types\"\nimport { keyframes as keyframesGenerator } from \"../../generators/keyframes\"\nimport { defaultOffset } from \"../../keyframes/offsets/default\"\nimport { JSAnimation, round } from \"../../JSAnimation\"\nimport { sampleDelta } from \"../../NativeAnimationExtended\"\nimport {\n    AnyResolvedKeyframe,\n    TimelineWithFallback,\n    ValueAnimationOptions,\n} from \"../../types\"\nimport { cubicBezierAsString } from \"../easing/cubic-bezier\"\nimport { supportedWaapiEasing } from \"../easing/supported\"\nimport { supportsWaapi } from \"../supports/waapi\"\nimport { needsMixer } from \"../utils/needs-mixer\"\nimport { supportsLinearEasing } from \"../../../utils/supports/linear-easing\"\nimport { TransformGroupHooks, transformGroups } from \"./groups\"\n\n/**\n * Independent transforms (x, y, scale, rotate etc) all write to the one\n * `transform` style, so they can't each run as their own WAAPI animation.\n * Instead, every transform animation on an element joins a group. While\n * every animation in the group can be accelerated, the group composes them\n * into a single `transform` WAAPI animation. The animations stay\n * JSAnimations, but their driver doesn't tick, so they do no work per\n * frame.\n *\n * When every animation follows the same eased progress, which is the case\n * for values that share a transition, the WAAPI animation has just two\n * keyframes and that easing. Otherwise it has as few sampled keyframes\n * as keep it accurate. It's only rebuilt when an animation starts or\n * stops. Pausing, seeking and speed changes that apply to every animation\n * in the group are made to the WAAPI animation, and animations complete\n * on its finish events.\n *\n * If one of them can't be accelerated, or something else keeps writing\n * the element's transform, the whole group moves to the main thread.\n */\n\ninterface TransformOwner extends Owner {\n    current: HTMLElement\n    latestValues?: Record<string, AnyResolvedKeyframe>\n    getValue(key: string): MotionValue | undefined\n    projection?: { isProjecting(): boolean }\n}\n\ninterface TransformDriverControls extends DriverControls {\n    js: DriverControls\n}\n\ninterface TransformGroup extends TransformGroupHooks {\n    tracks: Set<TransformAnimation<any>>\n\n    /**\n     * Whether the group's animations are running on the main thread.\n     */\n    isJS: boolean\n\n    /**\n     * Whether animations are finishing because they reached their end,\n     * which the WAAPI animation has already rendered.\n     */\n    isFinishing: boolean\n\n    /**\n     * Rebuild or retime the WAAPI animation. A churn is a change it may\n     * not be able to follow, like a seek or an outside write.\n     */\n    schedule(needsBuild: boolean, isChurn?: boolean): void\n\n    /**\n     * An animation was stopped. Rebuild without it or, if it was the last,\n     * end the group.\n     */\n    release(track: TransformAnimation<any>): void\n    demote(canReturn?: boolean): true | void\n}\n\n/**\n * Where each animation was when the WAAPI animation was built: its time,\n * speed and whether it was held.\n */\ntype BuiltState = [number, number, boolean]\n\ninterface Segment {\n    animation: Animation\n    /**\n     * When this starts and ends, relative to when the group was built.\n     */\n    offset: number\n    end: number\n    isDone?: boolean\n}\n\n/**\n * Sample at the interruption sampling rate, up to a cap for long\n * animations.\n */\nconst maxSamples = 200\n\n/**\n * How far values may stray from the WAAPI animation: as a fraction of\n * each value's change when they share an easing, otherwise in px or deg,\n * or for scale.\n */\nconst easingTolerance = 0.001\nconst sampleTolerance = 0.1\nconst scaleTolerance = 0.001\n\n/**\n * If an outside write, or a seek the WAAPI animation can't follow,\n * happens again within this window, the group is being driven every\n * frame (scrubbing, drag), which is cheaper on the main thread than\n * rebuilding the WAAPI animation every frame.\n */\nconst churnWindow = 100\n\n/**\n * A WAAPI animation that starts moving later than this, as most segments\n * of a long sequence do, is built this long before it starts, rather than\n * all at once at the start.\n */\nconst buildAhead = 100\n\n/**\n * Named easings that are the same cubic-bezier in JS and CSS.\n */\nconst nativeEasings = new Set([\"linear\", \"easeIn\", \"easeOut\", \"easeInOut\"])\nconst isNativeEasing = (ease: unknown): ease is \"linear\" =>\n    nativeEasings.has(ease as string)\n\n/**\n * The last trace of each easing WAAPI can't run into linear(), with its\n * number of samples, so the elements of a sequence that share an easing\n * and duration trace it once.\n */\nconst traced = new WeakMap<EasingFunction, [number, string]>()\n\nconst trace = (ease: EasingFunction, samples: number) => {\n    let last = traced.get(ease)\n    if (last?.[0] !== samples) {\n        last = [\n            samples,\n            \"linear(\" +\n                defaultOffset(Array(samples + 1)).map(\n                    (p) => round(ease(p)) + \" \" + round(p * 100) + \"%\"\n                ) +\n                \")\",\n        ]\n        traced.set(ease, last)\n    }\n    return last[1]\n}\n\n/**\n * How many samples trace an easing between two timestamps.\n */\nconst countSamples = (from: number, to: number) =>\n    Math.min(maxSamples, Math.max(2, Math.ceil((to - from) / sampleDelta)))\n\n/**\n * Whether two eased progresses match. False if either is NaN.\n */\nconst isNear = (a: number, b: number) => Math.abs(a - b) <= easingTolerance\n\nconst byTime = (a: number, b: number) => a - b\n\n/**\n * n + 1 evenly spaced timestamps, from one timestamp to another.\n */\nconst spread = (from: number, to: number, n: number) =>\n    defaultOffset(Array(n + 1)).map((p) => mixNumber(from, to, p))\n\nconst getOwner = (options: ValueAnimationOptions<any>) =>\n    options.motionValue!.owner as TransformOwner\n\nconst getGroup = (element: Element) =>\n    transformGroups.get(element) as TransformGroup | undefined\n\n/**\n * Whether an animation has ended, so can leave its group.\n */\nconst hasEnded = ({ state }: TransformAnimation<any>) =>\n    state === \"idle\" || state === \"finished\"\n\nconst read = (owner: TransformOwner, key: string) =>\n    owner.latestValues ? owner.latestValues[key] : owner.getValue(key)?.get()\n\n/**\n * Whether this animation should join its element's transform group.\n * Animations that can't be accelerated still join, so the group knows\n * to stay on the main thread while they run. Browsers without linear()\n * easing stay on the main thread.\n */\nexport const canGroupTransform = ({\n    name,\n    motionValue,\n}: ValueAnimationOptions<any>) =>\n    name &&\n    transformPropOrder.includes(name) &&\n    motionValue?.owner?.current instanceof HTMLElement &&\n    supportsWaapi() &&\n    supportsLinearEasing()\n\nfunction canAccelerateTransform(options: ValueAnimationOptions<any>) {\n    const owner = getOwner(options)\n    const { onUpdate, transformTemplate } = owner.getProps()\n\n    return (\n        /**\n         * A handoff from an optimised appear animation is already running\n         * on its own WAAPI animation. onUpdate needs every value, every\n         * frame.\n         */\n        !options.isHandoff &&\n        !onUpdate &&\n        !options.hasOnUpdate &&\n        /**\n         * transformTemplate could output anything.\n         */\n        !transformTemplate &&\n        options.type !== \"inertia\" &&\n        /**\n         * A literal transform, or pathRotation, replaces or adds to the\n         * transform we'd build. styleEffect builds its own as \"none\".\n         */\n        (read(owner, \"transform\") || \"none\") === \"none\" &&\n        !read(owner, \"pathRotation\") &&\n        /**\n         * Layout animations write transform every frame.\n         */\n        !owner.projection?.isProjecting() &&\n        /**\n         * A mixer that blends these values makes them every frame. It's\n         * asked last, as it's user code.\n         */\n        !needsMixer(options)\n    )\n}\n\n/**\n * Starting or stopping tells the group to update its WAAPI animation.\n * The frame loop driver is only made once the group is on the main\n * thread, as accelerated animations never tick.\n */\nclass TransformDriver implements TransformDriverControls {\n    private driver?: DriverControls\n\n    constructor(\n        private element: Element,\n        private update: (timestamp: number) => void,\n        private makeDriver: Driver,\n        public animation?: TransformAnimation<any>\n    ) {}\n\n    get js() {\n        return (this.driver ||= this.makeDriver(this.update))\n    }\n\n    now() {\n        return this.driver || this.makeDriver !== frameloopDriver\n            ? this.js.now()\n            : frameData.isProcessing\n            ? frameData.timestamp\n            : time.now()\n    }\n\n    /**\n     * keepAlive is false when seeking. Seeking the WAAPI animation is\n     * free, but if a seek needs a rebuild and keeps happening, the group\n     * moves to the main thread.\n     */\n    start(keepAlive = true) {\n        const group = getGroup(this.element)\n        !group || group.isJS\n            ? this.js.start(keepAlive)\n            : group.schedule(false, !keepAlive)\n    }\n\n    stopJS() {\n        this.driver?.stop()\n    }\n\n    stop() {\n        this.stopJS()\n        const group = getGroup(this.element)\n        group && !group.isFinishing && group.release(this.animation!)\n    }\n}\n\n/**\n * JSAnimation's time setter, looked up on first use rather than at module\n * load, so the module has no top-level side effects and stays\n * tree-shakeable in flattened bundles.\n */\nlet setTime: ((this: JSAnimation<any>, time: number) => void) | undefined\n\nexport class TransformAnimation<\n    T extends number | string\n> extends JSAnimation<T> {\n    canAccelerate: boolean\n\n    constructor(options: ValueAnimationOptions<T>) {\n        const element = getOwner(options).current\n        const { driver = frameloopDriver } = options\n        let animation: TransformAnimation<T> | undefined\n\n        /**\n         * Before JSAnimation replaces the type with its generator.\n         */\n        const canAccelerate = canAccelerateTransform(options)\n\n        /**\n         * The driver ticks on the main thread only once the group has\n         * moved there, so its frame loop driver is made then.\n         */\n        options.driver = (update) =>\n            new TransformDriver(element, update, driver, animation)\n\n        super(options)\n\n        animation = this\n        /**\n         * The first driver is made in super(), before this was assigned.\n         */\n        const firstDriver = this.driver as TransformDriver | undefined\n        firstDriver && (firstDriver.animation = this)\n        this.canAccelerate = canAccelerate\n\n        /**\n         * stop is bound in JSAnimation, so wrap it rather than override.\n         * Before stopping, set the motion value to where the WAAPI\n         * animation is now, with velocity, for the next animation to\n         * start from.\n         */\n        const { stop } = this\n        this.stop = () => {\n            this.isAccelerated() && this.sync()\n            stop()\n        }\n    }\n\n    private offsetsOf?: unknown[]\n    private cachedOffsets?: number[]\n\n    /**\n     * Each keyframe's offset, made once for the keyframes rather than on\n     * every build.\n     */\n    offsets() {\n        const { keyframes, times } = this.options\n        if (times) return times\n        if (this.offsetsOf !== keyframes) {\n            this.offsetsOf = keyframes\n            this.cachedOffsets = defaultOffset(keyframes)\n        }\n        return this.cachedOffsets!\n    }\n\n    get group() {\n        return getGroup(getOwner(this.options).current)\n    }\n\n    get js() {\n        return (this.driver as TransformDriverControls | undefined)?.js\n    }\n\n    stopJS() {\n        ;(this.driver as TransformDriver | undefined)?.stopJS()\n    }\n\n    get name() {\n        return this.options.name!\n    }\n\n    /**\n     * When this stops moving, or, if it repeats forever, when it starts\n     * repeating, and how long each repeat takes. Held (paused, or at\n     * speed 0) animations never stop moving.\n     */\n    timing() {\n        const { startTime, speed, totalDuration } = this\n        const { delay = 0, repeatType } = this.options\n\n        return this.holdTime !== null\n            ? [Infinity, 0]\n            : totalDuration === Infinity\n            ? [\n                  startTime! + delay / speed,\n                  (this.resolvedDuration * (repeatType === \"loop\" ? 1 : 2)) /\n                      speed || 1,\n              ]\n            : [startTime! + (delay + totalDuration) / speed, 0]\n    }\n\n    /**\n     * Whether this is running, or paused, on the compositor.\n     */\n    isAccelerated() {\n        const { group, state } = this\n        return (\n            group?.tracks.has(this) &&\n            !group.isJS &&\n            this.canAccelerate &&\n            (state === \"running\" || state === \"paused\")\n        )\n    }\n\n    /**\n     * The value now, while this runs on the compositor and so doesn't\n     * set its motion value every frame.\n     */\n    liveValue() {\n        return this.isAccelerated() ? this.sampleAt(time.now()) : undefined\n    }\n\n    /**\n     * If this moves between two keyframes only, holding still either side\n     * of them, as each value of a sequence segment does, when it starts\n     * and stops moving, and its easing: as a string if WAAPI runs it\n     * exactly, otherwise its function, to trace.\n     */\n    tween(): [number, number, (string | EasingFunction)?] | undefined {\n        const { keyframes, type, repeat, delay = 0 } = this.options\n        let span = -1\n\n        if (repeat || type !== keyframesGenerator || this.holdTime !== null) {\n            return\n        }\n\n        for (let i = 1; i < keyframes.length; i++) {\n            if (keyframes[i] !== keyframes[i - 1]) {\n                if (span >= 0) return\n                span = i - 1\n            }\n        }\n\n        let { ease } = this.options\n        if (isEasingArray(ease)) ease = ease[span]\n\n        const offsets = this.offsets()\n        const at = (i: number) =>\n            this.startTime! +\n            (delay + offsets[i] * this.totalDuration) / this.speed\n\n        if (span >= 0) {\n            const easing = isBezierDefinition(ease!)\n                ? cubicBezierAsString(ease as BezierDefinition)\n                : isNativeEasing(ease)\n                ? supportedWaapiEasing[ease]\n                : easingDefinitionToFunction(ease!)\n\n            /**\n             * An easing that doesn't run from 0 to 1 doesn't move between\n             * the keyframes, so is traced from the values it gives instead.\n             */\n            return [\n                at(span),\n                at(span + 1),\n                typeof easing === \"string\" ||\n                (isNear(easing(0), 0) && isNear(easing(1), 1))\n                    ? easing\n                    : undefined,\n            ]\n        }\n    }\n\n    /**\n     * The timestamps between two timestamps where this reaches a\n     * keyframe or starts a repeat, where it can turn or jump.\n     */\n    boundaries(from: number, to: number) {\n        const { startTime, speed, resolvedDuration, options } = this\n        const {\n            delay = 0,\n            repeat = 0,\n            repeatDelay = 0,\n            repeatType,\n            type,\n        } = options\n        const offsets =\n            (type || keyframesGenerator) === keyframesGenerator\n                ? this.offsets()\n                : [0, 1]\n        const start = startTime! + delay / speed\n        const result: number[] = []\n\n        if (this.holdTime !== null || !(resolvedDuration > 0)) return result\n\n        for (\n            let i = Math.max(\n                0,\n                Math.floor(((from - start) * speed) / resolvedDuration)\n            );\n            i <= repeat;\n            i++\n        ) {\n            const iterationStart = start + (i * resolvedDuration) / speed\n            if (iterationStart > to) break\n\n            for (const offset of offsets) {\n                const t =\n                    iterationStart +\n                    ((i % 2 && repeatType && repeatType !== \"loop\"\n                        ? 1 - offset\n                        : offset) *\n                        (resolvedDuration - repeatDelay)) /\n                        speed\n                t > from && t < to && result.push(t)\n            }\n        }\n\n        return result\n    }\n\n    /**\n     * The value at a timestamp, as a number.\n     */\n    numberAt(timestamp: number) {\n        return parseFloat(this.sampleAt(timestamp, true) as string)\n    }\n\n    /**\n     * Write the current value, and velocity, to the motion value.\n     */\n    sync() {\n        const now = time.now()\n        const value = this.sampleAt(now, true)\n\n        /**\n         * A held value doesn't move, so there's no need to sample it\n         * twice.\n         */\n        this.options.motionValue!.setWithVelocity(\n            this.holdTime === null\n                ? this.sampleAt(now - sampleDelta, true)\n                : value,\n            value,\n            sampleDelta\n        )\n    }\n\n    play() {\n        /**\n         * A stopped animation (one that was interrupted) can't play again,\n         * so it mustn't join the group.\n         */\n        if (this.isStopped) return\n        ;(this.group || createGroup(getOwner(this.options))).tracks.add(this)\n\n        super.play()\n    }\n\n    pause() {\n        super.pause()\n\n        this.isAccelerated() && this.group!.schedule(false)\n    }\n\n    /**\n     * JSAnimation finishes on its next tick, which only happens once the\n     * group is on the main thread, so finish now. That includes an\n     * animation that can't be accelerated but reached its end before the\n     * group could move there.\n     */\n    complete() {\n        super.complete()\n        const { group } = this\n        group && !group.isJS && this.tick(time.now())\n    }\n\n    /**\n     * Without a tick to rebase it, a held time still includes the delay,\n     * so take it off here, as a JS animation does on its next tick.\n     */\n    get time() {\n        if (this.isAccelerated()) {\n            return millisecondsToSeconds(\n                clamp(\n                    0,\n                    this.totalDuration,\n                    this.at(time.now()) - (this.options.delay || 0)\n                )\n            )\n        }\n\n        return super.time\n    }\n\n    /**\n     * Calls JSAnimation's setter directly, as `super.time =` is a slow\n     * path in V8 and this runs for every animation of a seeked sequence.\n     */\n    set time(newTime: number) {\n        ;(setTime ??= Object.getOwnPropertyDescriptor(\n            JSAnimation.prototype,\n            \"time\"\n        )!.set!).call(this, newTime)\n    }\n\n    /**\n     * Scroll timelines set time every frame, so run these on the main\n     * thread.\n     */\n    attachTimeline(timeline: TimelineWithFallback) {\n        this.canAccelerate = false\n        this.group?.demote(true)\n        return super.attachTimeline(timeline)\n    }\n}\n\n/**\n * Groups that build straight after the current task build in one\n * microtask, rather than one each.\n */\nlet builds: VoidFunction[] | undefined\n\nconst buildSoon = (build: VoidFunction) => {\n    builds ||\n        queueMicrotask(() => {\n            const queue = builds!\n            builds = undefined\n            queue.forEach((build) => build())\n        })\n    ;(builds ||= []).push(build)\n}\n\nfunction createGroup(owner: TransformOwner): TransformGroup {\n    const element = owner.current\n    const tracks = new Set<TransformAnimation<any>>()\n    const byKey = new Map<string, TransformAnimation<any>>()\n\n    /**\n     * Transforms that aren't animating, as built into the WAAPI animation.\n     */\n    let statics: Record<string, AnyResolvedKeyframe | undefined> = {}\n    /**\n     * The transforms in the WAAPI animation, in order.\n     */\n    let keys: string[] = []\n    let built = new Map<TransformAnimation<any>, BuiltState>()\n    let segments: Segment[] = []\n    let needsBuild = false\n    let isScheduled = false\n    let isEnded = false\n    let hasChurned = false\n    let lastChurn = -Infinity\n    let wake: ReturnType<typeof setTimeout> | undefined\n    let wakeAt = Infinity\n    /**\n     * While waiting to build a tween that starts later, how long after\n     * the last build to build it.\n     */\n    let buildAt: number | undefined\n\n    const has = (key: string) => {\n        for (const track of tracks) if (track.name === key) return true\n    }\n\n    /**\n     * The transform values at a timestamp or, without one, from the\n     * motion values. Animations that don't repeat forever are sampled no\n     * earlier than settled, so a loop that starts from an earlier cycle\n     * boundary holds them at their end.\n     */\n    const valuesAt = (timestamp?: number, settled?: number) => {\n        const values: ResolvedValues = {}\n        for (const key of timestamp === undefined ? transformPropOrder : keys) {\n            const track = byKey.get(key)\n            const value =\n                timestamp === undefined\n                    ? read(owner, key)\n                    : track\n                    ? track.sampleAt(\n                          settled! > timestamp && !track.timing()[1]\n                              ? settled!\n                              : timestamp\n                      )\n                    : statics[key]\n\n            if (value !== undefined) values[key] = value\n        }\n        return values\n    }\n\n    /**\n     * Build a transform from values in transformPropOrder. For a keyframe,\n     * every key is written, even at its default, so each keyframe has the\n     * same list of functions and the browser interpolates them one by one.\n     * As an inline style, defaults are left out, as buildTransform does.\n     */\n    const toTransform = (values: ResolvedValues, isStyle?: boolean) => {\n        let transform = \"\"\n        for (const key in values) {\n            const value = values[key]\n            if (!isStyle || !isDefaultTransform(key, value)) {\n                transform += transformFunction(key, value) + \" \"\n            }\n        }\n        return (isStyle ? transform.trim() : transform) || \"none\"\n    }\n\n    /**\n     * Build the transform at a timestamp.\n     */\n    const compose = (timestamp: number, settled?: number) =>\n        toTransform(valuesAt(timestamp, settled))\n\n    /**\n     * Write the transform as an inline style, as the renderer would.\n     */\n    const commit = (values = valuesAt()) => {\n        element.style.transform = toTransform(values, true)\n    }\n\n    /**\n     * Cancel a WAAPI animation and remove its handlers, as WebKit never\n     * collects an animation once it has run, nor anything its handlers\n     * reference (#4034).\n     */\n    const cancel = (animation: Animation) => {\n        animation.onfinish = animation.oncancel = null\n        animation.cancel()\n    }\n\n    /**\n     * Cancel the WAAPI animations, by default first committing the\n     * transform. The renderer writes its own version on its next render.\n     */\n    const stop = (shouldCommit = true) => {\n        clearTimeout(wake)\n        wakeAt = Infinity\n        buildAt = undefined\n        shouldCommit && commit()\n        segments.forEach(({ animation }) => cancel(animation))\n        segments = []\n    }\n\n    /**\n     * A WAAPI animation that add() starts by setting its startTime. Playing\n     * it first, as element.animate() does, would leave WebKit holding that\n     * play's ready time once startTime ends the play, and it uses that for\n     * the next updatePlaybackRate(), so the animation would jump.\n     */\n    const create = (\n        keyframes: PropertyIndexedKeyframes | null,\n        options: KeyframeAnimationOptions\n    ) =>\n        new Animation(\n            new KeyframeEffect(element, keyframes, options) as AnimationEffect\n        )\n\n    const add = (animation: Animation, offset: number, end = Infinity) => {\n        const segment: Segment = { animation, offset, end }\n        animation.startTime = time.now() + offset\n\n        /**\n         * Animations finish when the WAAPI animation reaches their end.\n         * Once a loop has taken over, the finished animation isn't needed.\n         */\n        if (end < Infinity) {\n            animation.onfinish = () => {\n                segment.isDone = true\n                if (segments.some((s) => s.end === Infinity)) {\n                    cancel(animation)\n                    segments = segments.filter((s) => s !== segment)\n                }\n                group.schedule(false)\n            }\n        }\n\n        /**\n         * Something else cancelled it, so carry on on the main thread.\n         */\n        animation.oncancel = () => segments.includes(segment) && group.demote()\n\n        segments.push(segment)\n    }\n\n    /**\n     * Where a value jumps between two timestamps, as when a repeat starts\n     * again: the timestamps either side of the jump, or none if it moves\n     * there continuously.\n     */\n    const jumpAt = (value: (t: number) => number, a: number, b: number) => {\n        const change = (x: number, y: number) => Math.abs(value(y) - value(x))\n        const size = change(a, b)\n        while (b - a > 0.01) {\n            const mid = (a + b) / 2\n            change(a, mid) > change(mid, b) ? (b = mid) : (a = mid)\n        }\n        return change(a, b) > size / 2 ? [a, b] : []\n    }\n\n    /**\n     * If every moving animation follows the same eased progress between\n     * two timestamps, the easing that describes it.\n     */\n    const getEasing = (\n        moving: TransformAnimation<any>[],\n        from: number,\n        to: number,\n        bounds: number[]\n    ) => {\n        const samples = countSamples(from, to)\n\n        /**\n         * Too many keyframes or repeats to follow with this many samples.\n         */\n        if (bounds.length * 4 > samples) return\n\n        /**\n         * First check half way, where values with different easings\n         * usually differ, before sampling every value many times.\n         */\n        let quick: number | undefined\n        for (const track of moving) {\n            const first = track.numberAt(from)\n            const p =\n                (track.numberAt((from + to) / 2) - first) /\n                (track.numberAt(to) - first)\n\n            /**\n             * NaN if it doesn't move.\n             */\n            if (p !== p) continue\n            if (quick === undefined) quick = p\n            else if (!isNear(p, quick)) return\n        }\n\n        const at = spread(from, to, samples).concat(bounds).sort(byTime)\n\n        const position = (t: number) => progress(from, to, t)\n        let shared: number[] | undefined\n        let progressAt: (t: number) => number\n\n        for (const track of moving) {\n            const first = track.numberAt(from)\n            const changes = at.map((t) => track.numberAt(t) - first)\n            const end = changes[changes.length - 1]\n\n            /**\n             * A value that ends only a tiny way from where it started, as\n             * a round trip does if it's built just after it starts, or\n             * from a float residue, ends where it started. Dividing by\n             * that tiny range would stretch the easing to values the\n             * compositor can't render.\n             */\n            const range = changes.some(\n                (change) => Math.abs(change) * easingTolerance > Math.abs(end)\n            )\n                ? 0\n                : end\n\n            const progress = changes.map((change) =>\n                range ? change / range : change\n            )\n\n            /**\n             * The first value that moves sets the easing, and every other\n             * one must follow it. A value that doesn't change, like one\n             * still in its delay, fits any easing. One that changes but\n             * ends where it started fits none.\n             */\n            if (range && !shared) {\n                shared = progress\n                progressAt = (t) => (track.numberAt(t) - first) / range\n            } else if (\n                progress.some((p, i) => !isNear(p, range && shared![i]))\n            ) {\n                return\n            }\n        }\n\n        if (!shared || shared.every((p, i) => isNear(p, position(at[i])))) {\n            return \"linear\"\n        }\n\n        /**\n         * A repeat that starts again jumps back, which takes two points at\n         * the same position.\n         */\n        const points: string[] = []\n        const point = (t: number, p = progressAt(t)) =>\n            points.push(round(p) + \" \" + round(position(t) * 100) + \"%\")\n        shared.forEach((p, i) => {\n            i &&\n                Math.abs(p - shared![i - 1]) > 0.2 &&\n                jumpAt(progressAt, at[i - 1], at[i]).forEach((t) => point(t))\n            point(at[i], p)\n        })\n\n        return \"linear(\" + points + \")\"\n    }\n\n    /**\n     * Sample timestamps between two timestamps, closer together where the\n     * moving animations curve.\n     */\n    const sample = (\n        moving: TransformAnimation<any>[],\n        from: number,\n        to: number,\n        bounds: number[]\n    ) => {\n        const times = [from]\n\n        /**\n         * A linear tween is straight between its keyframes, so only the\n         * other values can curve, and a tween only while it moves.\n         */\n        const curved: TransformAnimation<any>[] = []\n        let curveFrom = to\n        let curveTo = from\n        for (const track of moving) {\n            const tween = track.tween()\n            if (tween?.[2] !== \"linear\") {\n                const [trackEnd, cycle] = track.timing()\n                const [a, b] = tween || [from, cycle ? to : trackEnd]\n                curveFrom = Math.min(curveFrom, a)\n                curveTo = Math.max(curveTo, b)\n                curved.push(track)\n            }\n        }\n        curveFrom = Math.max(from, curveFrom)\n        curveTo = Math.min(to, curveTo)\n\n        /**\n         * Values that aren't numbers, like calc(), are left to the\n         * browser to interpolate.\n         */\n        const isStraight = (a: number, b: number) =>\n            curved.every(\n                (track) =>\n                    !(\n                        Math.abs(\n                            track.numberAt((a + b) / 2) -\n                                (track.numberAt(a) + track.numberAt(b)) / 2\n                        ) >\n                        (track.name.startsWith(\"scale\")\n                            ? scaleTolerance\n                            : sampleTolerance)\n                    )\n            )\n\n        const split = (a: number, b: number, depth: number) => {\n            if (b - a < 1 || isStraight(a, b)) {\n                times.push(b)\n            } else if (depth < 4) {\n                split(a, (a + b) / 2, depth + 1)\n                split((a + b) / 2, b, depth + 1)\n            } else {\n                /**\n                 * Keyframes either side of a jump, like a repeat starting\n                 * again, so it doesn't play as a quick sweep.\n                 */\n                for (const track of moving) {\n                    times.push(...jumpAt((t) => track.numberAt(t), a, b))\n                }\n                times.push(b)\n            }\n        }\n\n        /**\n         * Split at least every 100ms where a value can curve, and at every\n         * keyframe and repeat, either side of where a value can jump.\n         */\n        const ends =\n            curveTo > curveFrom\n                ? spread(\n                      curveFrom,\n                      curveTo,\n                      Math.ceil((curveTo - curveFrom) / 100)\n                  )\n                : []\n        ends.push(to)\n        for (const t of bounds) ends.push(t, Math.min(t + 0.01, to))\n\n        let start = from\n        for (const end of ends.sort(byTime)) {\n            end > start && split(start, end, 0)\n            start = end\n        }\n\n        return times.sort(byTime)\n    }\n\n    /**\n     * If every moving animation is the same tween, started together, as\n     * happens for the values of one animate() call or transition, when\n     * they move and their native easing.\n     */\n    const getTween = (moving: TransformAnimation<any>[]) => {\n        let shared: [number, number, (string | EasingFunction)?] | undefined\n\n        for (const track of moving) {\n            const tween = track.tween()\n            if (\n                !tween ||\n                (shared &&\n                    (Math.abs(tween[0] - shared[0]) > 1 ||\n                        Math.abs(tween[1] - shared[1]) > 1))\n            ) {\n                return\n            }\n            /**\n             * Easings that differ, like the springs a sequence makes for\n             * each value, can still be the same curve.\n             */\n            shared = [\n                tween[0],\n                tween[1],\n                !shared || tween[2] === shared[2] ? tween[2] : undefined,\n            ]\n        }\n\n        return shared\n    }\n\n    /**\n     * A WAAPI animation of the composed transform between two timestamps.\n     */\n    const run = (\n        moving: TransformAnimation<any>[],\n        from: number,\n        to: number,\n        nativeEasing?: string,\n        options: KeyframeAnimationOptions = { fill: \"both\" },\n        settled?: number\n    ) => {\n        /**\n         * With an easing given, there's nothing to sample, so no need\n         * for the boundaries.\n         */\n        const bounds = nativeEasing\n            ? []\n            : moving.flatMap((track) => track.boundaries(from, to))\n        const easing = nativeEasing || getEasing(moving, from, to, bounds)\n        const times = easing ? [from, to] : sample(moving, from, to, bounds)\n        const transform = times.map((t) => compose(t, settled))\n        let keyframes: PropertyIndexedKeyframes | null = { transform }\n        if (!easing) {\n            keyframes.offset = times.map((t) => progress(from, to, t))\n        }\n\n        /**\n         * If nothing moves, don't hold a transform, which, even at its\n         * default, would make the element a containing block. The empty\n         * animation still finishes the animations.\n         */\n        if (transform.every((t) => t === transform[0])) {\n            commit(valuesAt(from, settled))\n            keyframes = null\n        }\n\n        return create(keyframes, {\n            ...options,\n            duration: to - from,\n            easing: easing || \"linear\",\n        })\n    }\n\n    /**\n     * Check whether it's time to build in this long. A check that's due\n     * sooner is kept, and checks again if it's early, so pausing and\n     * playing don't each replace a timer. One due later, after a seek or\n     * speed change while held, is replaced.\n     */\n    const wakeIn = (delay: number) => {\n        const at = time.now() + delay\n        if (at < wakeAt) {\n            clearTimeout(wake)\n            wakeAt = at\n            wake = setTimeout(() => {\n                wakeAt = Infinity\n                group.schedule(false)\n            }, delay)\n        }\n    }\n\n    /**\n     * Replace the WAAPI animations with ones built from now. Returns\n     * undefined if the animations can't be composed.\n     */\n    const animate = (now: number) => {\n        /**\n         * The finite part runs until the last finite animation (or the\n         * last delay) ends. Infinitely repeating animations then continue\n         * as one looping WAAPI animation, which needs them to share a\n         * cycle.\n         */\n        let end = now\n        let cycle = 0\n        let cycleStart = 0\n        const moving: TransformAnimation<any>[] = []\n        const looping: TransformAnimation<any>[] = []\n        const ends = new Set<number>()\n\n        byKey.clear()\n        built = new Map()\n\n        for (const track of tracks) {\n            byKey.set(track.name, track)\n\n            const [trackEnd, trackCycle] = track.timing()\n            const isHeld = trackEnd === Infinity\n\n            built.set(track, [track.at(now), track.speed, isHeld])\n\n            if (isHeld) continue\n\n            if (track.speed < 0) return\n\n            if (trackCycle) {\n                if (cycle) {\n                    const phase = (trackEnd - cycleStart) / trackCycle\n                    if (\n                        Math.abs(trackCycle - cycle) > 1 ||\n                        Math.abs(phase - Math.round(phase)) * cycle > 1\n                    ) {\n                        return\n                    }\n                } else {\n                    cycle = trackCycle\n                    cycleStart = trackEnd\n                }\n                looping.push(track)\n            } else {\n                ends.add(trackEnd)\n            }\n\n            moving.push(track)\n            end = Math.max(end, trackEnd)\n        }\n\n        statics = {}\n        /**\n         * Transforms that aren't animating are left out at their default.\n         */\n        keys = transformPropOrder.filter((key) => {\n            if (byKey.has(key)) return true\n            const value = (statics[key] = read(owner, key))\n            return value !== undefined && !isDefaultTransform(key, value)\n        })\n\n        stop(false)\n\n        /**\n         * Values that share one tween are one WAAPI animation of it, with\n         * two keyframes and its own easing, from when they started.\n         */\n        const tween = !cycle && getTween(moving)\n\n        try {\n            if (end > now) {\n                let easing: string | undefined\n\n                if (tween && tween[1] > now) {\n                    const [from, to, ease] = tween\n\n                    /**\n                     * Until it's built, the motion values hold where it\n                     * starts, for the renderer to write.\n                     */\n                    if (from - now > buildAhead) {\n                        moving.forEach((track) => track.sync())\n                        wakeIn((buildAt = from - now - buildAhead))\n                        return true\n                    }\n\n                    easing =\n                        typeof ease === \"string\"\n                            ? ease\n                            : ease\n                            ? trace(ease, countSamples(from, to))\n                            : getEasing(moving, from, to, [])\n\n                    /**\n                     * It holds its last keyframe until the animations end.\n                     */\n                    easing &&\n                        add(\n                            run(moving, from, to, easing, {\n                                fill: \"both\",\n                                endDelay: end - to,\n                            }),\n                            from - now,\n                            end - from\n                        )\n                }\n\n                easing || add(run(moving, now, end), 0, end - now)\n\n                /**\n                 * Animations that end sooner finish on the events of\n                 * empty animations that end with them.\n                 */\n                ends.forEach(\n                    (trackEnd) =>\n                        trackEnd < end - 1 &&\n                        add(\n                            create(null, { duration: trackEnd - now }),\n                            0,\n                            trackEnd - now\n                        )\n                )\n            }\n\n            if (cycle) {\n                /**\n                 * Build one cycle from a cycle boundary, so it repeats\n                 * seamlessly, and start it part way through.\n                 */\n                const from =\n                    cycleStart + Math.floor((end - cycleStart) / cycle) * cycle\n\n                add(\n                    run(\n                        looping,\n                        from,\n                        from + cycle,\n                        undefined,\n                        {\n                            iterations: Infinity,\n                            iterationStart: (end - from) / cycle,\n                            /**\n                             * It must not fill backwards over the finite part\n                             * that runs before it.\n                             */\n                            fill: \"forwards\",\n                        },\n                        end\n                    ),\n                    end - now\n                )\n            }\n        } catch {\n            return\n        }\n\n        /**\n         * Everything is held, so hold it with an inline style instead.\n         */\n        segments.length || stop()\n\n        return true\n    }\n\n    /**\n     * If every animation has been paused, played, seeked or sped up\n     * together since the WAAPI animation was built, do the same to it.\n     * Returns false if it needs rebuilding instead. Seeking to before a\n     * tween starts rebuilds, so a running group seeked every frame still\n     * moves to the main thread.\n     */\n    const retime = (now: number, isSeek: boolean) => {\n        let elapsed: number | undefined\n        let rate = 0\n\n        for (const track of tracks) {\n            const state = built.get(track)\n            if (!state) return false\n\n            const [builtTime, builtSpeed, wasHeld] = state\n            const trackTime = track.at(now)\n            const isHeld = track.timing()[0] === Infinity\n\n            /**\n             * With nothing on the compositor, a held animation is set\n             * where it's held, so it can be seeked as often as needed.\n             */\n            if (wasHeld) {\n                if (isHeld && (trackTime === builtTime || !segments.length)) {\n                    continue\n                }\n                return false\n            }\n\n            const trackElapsed = (trackTime - builtTime) / builtSpeed\n            const trackRate = isHeld ? 0 : track.speed / builtSpeed\n\n            if (elapsed === undefined) {\n                elapsed = trackElapsed\n                rate = trackRate\n            } else if (\n                Math.abs(trackElapsed - elapsed) > 1 ||\n                trackRate !== rate\n            ) {\n                return false\n            }\n        }\n\n        if (elapsed === undefined) return true\n\n        /**\n         * Waiting to build a tween that starts later. Until then the\n         * values hold where they start, so only when to build changes.\n         * Held, it has nothing on the compositor, so it can be seeked.\n         */\n        if (!segments.length) {\n            if (buildAt === undefined || (isSeek && rate)) return false\n\n            if (rate) {\n                const delay = (buildAt - elapsed) / rate\n                if (delay < 1) return false\n                wakeIn(delay)\n            }\n            return true\n        }\n\n        /**\n         * Only a tween is built to start later, and it holds its first\n         * keyframe until then, so it can be paused and played before it\n         * starts.\n         */\n        for (const { offset, end, isDone } of segments) {\n            const local = elapsed - offset\n            if (\n                end < Infinity &&\n                (isDone\n                    ? local < end - 1\n                    : (local < 0 && (isSeek || offset <= 0)) || local >= end)\n            ) {\n                return false\n            }\n        }\n\n        for (const { animation, offset, isDone } of segments) {\n            if (isDone) continue\n\n            const local = elapsed - offset\n            if (\n                rate &&\n                animation.updatePlaybackRate &&\n                animation.playState === \"running\" &&\n                Math.abs(Number(animation.currentTime) - local) < 20\n            ) {\n                /**\n                 * Only the speed changed. Setting playbackRate and\n                 * startTime restarts a running compositor animation, which\n                 * can render the underlying value for a frame.\n                 */\n                animation.playbackRate !== rate &&\n                    animation.updatePlaybackRate(rate)\n            } else if (rate) {\n                animation.playbackRate !== rate &&\n                    (animation.playbackRate = rate)\n                animation.startTime = now - local / rate\n            } else {\n                /**\n                 * Hold it without pause(), whose pending pause setting\n                 * currentTime would end at once, leaving WebKit holding its\n                 * ready time (see create()).\n                 */\n                animation.startTime = null\n                animation.currentTime = local\n            }\n        }\n\n        return true\n    }\n\n    /**\n     * If no animations are left, write where they got to and cancel the\n     * WAAPI animations. Returns whether the group ended.\n     */\n    const end = () => {\n        if (tracks.size) return false\n\n        isEnded = true\n        /**\n         * The element may have a newer group if this one was detached\n         * (see handOffElementState).\n         */\n        getGroup(element) === group && transformGroups.delete(element)\n        group.isJS || stop()\n        return true\n    }\n\n    const build = () => {\n        const now = time.now()\n\n        /**\n         * Finish the animations that have reached their end, which the\n         * WAAPI animation has already rendered.\n         */\n        if (!group.isJS) {\n            group.isFinishing = true\n            tracks.forEach((track) => {\n                const [trackEnd, trackCycle] = track.timing()\n\n                if (\n                    track.state === \"running\" &&\n                    track.speed > 0 &&\n                    !trackCycle &&\n                    trackEnd <= now + 1\n                ) {\n                    track.complete()\n\n                    /**\n                     * From now it's checked for outside writes like any\n                     * other static transform. If the WAAPI animation never\n                     * rendered it (it was instant), rebuild with its value.\n                     */\n                    statics[track.name] = read(owner, track.name)\n                    built.has(track) || (needsBuild = true)\n                }\n            })\n            group.isFinishing = false\n        }\n\n        isScheduled = false\n\n        if (isEnded) return\n\n        tracks.forEach((track) => hasEnded(track) && tracks.delete(track))\n\n        if (end()) return\n\n        for (const track of tracks) {\n            if (!track.canAccelerate) return group.demote(true)\n        }\n\n        /**\n         * Everything that kept the group on the main thread has finished,\n         * so move the remaining animations back to the compositor.\n         */\n        if (group.isJS) {\n            group.isJS = false\n            needsBuild = true\n            tracks.forEach((track) => track.stopJS())\n        }\n\n        const shouldBuild = needsBuild\n        const churned = hasChurned\n        needsBuild = hasChurned = false\n\n        if (shouldBuild || !retime(now, churned)) {\n            if (churned) {\n                if (now - lastChurn < churnWindow) return group.demote()\n                lastChurn = now\n            }\n            if (!animate(now)) return group.demote()\n        } else if (buildAt !== undefined && !churned) {\n            /**\n             * Still waiting to build, so the values still hold where\n             * they start.\n             */\n            return\n        }\n\n        /**\n         * Held animations don't move, so set their motion values to where\n         * they're held, as a JSAnimation would on its next tick. Pausing\n         * and seeking schedule this, so it's once however many there are.\n         */\n        tracks.forEach(\n            (track) => track.timing()[0] === Infinity && track.sync()\n        )\n    }\n\n    const group: TransformGroup = {\n        tracks,\n        isJS: false,\n        isFinishing: false,\n\n        schedule(build_: boolean, isChurn?: boolean) {\n            if (isEnded) return\n\n            needsBuild ||= build_\n            hasChurned ||= !!isChurn\n\n            /**\n             * Build in this frame's render step, so it's in place before\n             * anything reads the DOM in postRender, or straight after the\n             * current task outside of a frame.\n             */\n            if (!isScheduled) {\n                isScheduled = true\n                frameData.isProcessing\n                    ? frame.render(build, false, true)\n                    : buildSoon(build)\n            }\n        },\n\n        /**\n         * End the group now, rather than when it next builds, so the\n         * element's transform is the caller's again as soon as its last\n         * animation is stopped.\n         */\n        release(track) {\n            /**\n             * Only drop the stopped animation. Others can be idle because\n             * they're part way through play(), and are about to run.\n             */\n            hasEnded(track) && tracks.delete(track)\n            end() || group.schedule(true)\n        },\n\n        /**\n         * An outside write. Rebuild once, but if it keeps happening, move\n         * to the main thread.\n         */\n        check() {\n            if (group.isJS) return\n\n            for (const key in statics) {\n                if (read(owner, key) !== statics[key] && !has(key)) {\n                    return group.schedule(true, true)\n                }\n            }\n        },\n\n        demote(canReturn?: boolean) {\n            if (group.isJS || isEnded) return\n\n            /**\n             * Unless only another animation is holding the group on the\n             * main thread, these animations stay there until they end.\n             */\n            tracks.forEach((track) => {\n                track.isAccelerated() && track.sync()\n                canReturn || (track.canAccelerate = false)\n            })\n\n            group.isJS = true\n            built = new Map()\n\n            stop()\n\n            tracks.forEach(\n                (track) => track.state === \"running\" && track.js?.start()\n            )\n\n            return true\n        },\n    }\n\n    transformGroups.set(element, group)\n\n    return group\n}\n"],"names":["keyframes","keyframesGenerator"],"mappings":"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"}