react-native-gtkx 0.2.0-alpha.2 → 0.3.0-alpha.1

package/dist/reanimated-compat/animation.js

@@ -0,0 +1,540 @@
+// `withTiming` / `withSpring` / `withDelay` / `withSequence` / `withRepeat`.
+//
+// Upstream types these as returning the animated type itself
+// (`withTiming(100)` is a `number`), because what starts the animation is
+// ASSIGNING the result to a shared value. The cast at each return mirrors
+// that trick rather than inventing a different API — see `mutable.ts`, which
+// recognises the descriptor in its setter.
+//
+// The descriptors are plain data. Turning one into a running animation is
+// `buildAnimation`, and it builds on the platform's own `src/animated/`
+// engine: same frame scheduler, same closed-form solvers, same preemption
+// rules. This layer adds no clock.
+//
+// It does NOT reuse `Animated.timing`/`Animated.spring`'s DEFAULTS, and that
+// distinction is load-bearing. Reanimated's defaults are materially
+// different animations:
+//
+//   | config          | RN Animated              | Reanimated 4               |
+//   | --------------- | ------------------------ | -------------------------- |
+//   | timing duration | 500 ms                   | 300 ms                     |
+//   | timing easing   | inOut(ease)              | inOut(quad)                |
+//   | spring          | damping 10, mass 1, k 100 | damping 120, mass 4, k 900 |
+//
+// The spring row is not a tuning difference: RN's default has damping ratio
+// 0.5 and visibly bounces, Reanimated 4's is exactly critically damped and
+// does not. Every config below is therefore passed explicitly.
+import { createValueAnimation, } from "../animated/index";
+import { decayStep, resolveDecayConfig } from "./decay";
+import { Easing, resolveEasing } from "./easing";
+const MARKER = "__rnGtkxReanimatedAnimation";
+const mark = (spec) => Object.assign(spec, { [MARKER]: true });
+export const isAnimationSpec = (value) => typeof value === "object" &&
+    value !== null &&
+    value[MARKER] === true;
+// --- the initial run ----------------------------------------------------
+//
+// Upstream's `IN_STYLE_UPDATER`, and it is not a detail: the FIRST evaluation
+// of a `useDerivedValue`/`useAnimatedStyle`/`useAnimatedProps` updater has no
+// value to animate FROM, so every `with*` builder returns its target instead
+// of an animation. `defineAnimation` does it in one line —
+// `if (IN_STYLE_UPDATER.current) return starting` — and that line is what
+// makes the documented pattern
+//
+//   const v = useDerivedValue(() => withSpring(active.value ? 1 : 0))
+//
+// work at all. Without it the shared value is SEEDED with the animation
+// object itself and every later write finds a value that is not a number.
+// Found by building `react-native-draggable-flatlist`, whose `ScaleDecorator`
+// is exactly that pattern (`hooks/useOnCellActiveAnimation.ts`).
+let inInitialRun = false;
+/**
+ * Runs an updater in "seed the value" mode, where every animation collapses
+ * to the value it would have finished at.
+ */
+export const initialUpdaterRun = (updater) => {
+    inInitialRun = true;
+    try {
+        return updater();
+    }
+    finally {
+        inInitialRun = false;
+    }
+};
+// Upstream's own defaults, quoted in the table at the top of this file.
+const DEFAULT_TIMING_DURATION = 300;
+const defaultTimingEasing = Easing.inOut(Easing.quad);
+// GentleSpringConfig + energyThreshold, react-native-reanimated 4.5.3
+// (src/animation/spring/springConfigs.ts).
+const DEFAULT_SPRING_MASS = 4;
+const DEFAULT_SPRING_STIFFNESS = 900;
+const DEFAULT_SPRING_DAMPING = 120;
+const DEFAULT_SPRING_DURATION = 550;
+const DEFAULT_SPRING_DAMPING_RATIO = 1;
+const DEFAULT_ENERGY_THRESHOLD = 6e-9;
+const assertAnimatable = (value, api) => {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error(`react-native-reanimated: ${api}() on this platform animates finite numbers only, got ${typeof value === "string" ? `"${value}"` : String(value)}. ` +
+            "Colors and layout properties cannot be driven imperatively here yet — see docs/api.md.");
+    }
+    return value;
+};
+/**
+ * Lets you animate a value over a duration with an easing curve. Assign the
+ * result to a shared value to start it.
+ */
+export const withTiming = (toValue, config, callback) => inInitialRun
+    ? assertAnimatable(toValue, "withTiming")
+    : mark({
+        kind: "timing",
+        toValue: assertAnimatable(toValue, "withTiming"),
+        config: config ?? {},
+        callback,
+    });
+/** Lets you animate a value with spring physics. */
+export const withSpring = (toValue, config, callback) => inInitialRun
+    ? assertAnimatable(toValue, "withSpring")
+    : mark({
+        kind: "spring",
+        toValue: assertAnimatable(toValue, "withSpring"),
+        config: config ?? {},
+        callback,
+    });
+/** Delays another animation by `delayMs`. */
+export const withDelay = (delayMs, animation) => {
+    // Upstream's `starting` for every composite is the animation it wraps,
+    // which the initial run has already collapsed to a plain value.
+    if (inInitialRun) {
+        return animation;
+    }
+    if (!isAnimationSpec(animation)) {
+        throw new Error("react-native-reanimated: withDelay() takes an animation, e.g. withDelay(500, withTiming(1))");
+    }
+    return mark({
+        kind: "delay",
+        delayMs,
+        animation,
+    });
+};
+/** Runs animations one after another on the same shared value. */
+export const withSequence = (...animations) => {
+    if (inInitialRun) {
+        return animations[0] ?? 0;
+    }
+    const specs = [];
+    for (const animation of animations) {
+        if (!isAnimationSpec(animation)) {
+            throw new Error("react-native-reanimated: withSequence() takes animations, e.g. withSequence(withTiming(1), withTiming(0))");
+        }
+        specs.push(animation);
+    }
+    return mark({ kind: "sequence", animations: specs });
+};
+/**
+ * Repeats an animation. `numberOfReps <= 0` repeats forever; `reverse` plays
+ * every other repetition backwards.
+ */
+export const withRepeat = (animation, numberOfReps = 2, reverse = false, callback) => {
+    if (inInitialRun) {
+        return animation;
+    }
+    if (!isAnimationSpec(animation)) {
+        throw new Error("react-native-reanimated: withRepeat() takes an animation, e.g. withRepeat(withTiming(1), 3)");
+    }
+    return mark({
+        kind: "repeat",
+        animation,
+        numberOfReps,
+        reverse,
+        callback,
+    });
+};
+/**
+ * Coasts to a stop from an initial velocity — the release half of a fling.
+ * Unlike every other animation here it has no target: where it lands is the
+ * result of the velocity and the friction, which is exactly what makes it the
+ * one an inertial gesture needs.
+ *
+ * ```tsx
+ * onPanResponderRelease: (_, g) => {
+ *   x.value = withDecay({ velocity: g.vx * 1000, clamp: [0, width] })
+ * }
+ * ```
+ *
+ * `velocity` is in units per SECOND, as upstream — `PanResponder`'s
+ * `gestureState.vx` is per millisecond, so it wants the ×1000 above.
+ */
+export const withDecay = (config, callback) => inInitialRun
+    ? // Upstream seeds a decay with 0: it has no target to collapse to.
+        0
+    : mark({
+        kind: "decay",
+        config: resolveDecayConfig(config),
+        callback,
+    });
+/**
+ * Confines another animation to a range: the inner animation runs its own
+ * un-truncated course and what reaches the value is clipped to `[min, max]`.
+ * That distinction is upstream's and it is observable — a spring clamped at
+ * 100 that would have overshot to 120 sits at 100 and then comes back down,
+ * rather than settling at 100 the moment it first arrives.
+ */
+export const withClamp = (config, animation) => {
+    if (inInitialRun) {
+        return animation;
+    }
+    if (!isAnimationSpec(animation)) {
+        throw new Error("react-native-reanimated: withClamp() takes an animation, e.g. withClamp({ min: 0 }, withSpring(1))");
+    }
+    if (config.min !== undefined &&
+        config.max !== undefined &&
+        config.max < config.min) {
+        throw new Error(`react-native-reanimated: withClamp() was given min ${config.min} above max ${config.max}.`);
+    }
+    return mark({
+        kind: "clamp",
+        min: config.min,
+        max: config.max,
+        animation,
+    });
+};
+// --- spring config normalisation ----------------------------------------
+const bisect = (min, max, fn, precision, maxIterations = 100) => {
+    let low = min;
+    let high = max;
+    const direction = fn(high) >= fn(low) ? 1 : -1;
+    let current = (low + high) / 2;
+    for (let i = 0; i < maxIterations && Math.abs(fn(current)) > precision; i++) {
+        if (fn(current) * direction < 0) {
+            low = current;
+        }
+        else {
+            high = current;
+        }
+        current = (low + high) / 2;
+    }
+    return current;
+};
+const energyOf = (displacement, velocity, stiffness, mass) => 0.5 * stiffness * displacement ** 2 + 0.5 * mass * velocity ** 2;
+/**
+ * Solves for the stiffness whose settling time matches a requested perceptual
+ * duration, by bisection on the fraction of the initial energy left after
+ * 1.5 × that duration. Ported from upstream's
+ * `calculateNewStiffnessToMatchDuration` — the perceptual-duration spring is
+ * a Reanimated concept with no RN equivalent, so there is nothing on the
+ * platform side to reuse.
+ */
+const stiffnessForDuration = (x0, v0, durationMs, dampingRatio, mass, energyThreshold) => {
+    const PERCEPTUAL_COEFFICIENT = 1.5;
+    const settlingSeconds = (durationMs * PERCEPTUAL_COEFFICIENT) / 1000;
+    const initialEnergyFor = (stiffness) => energyOf(x0, v0, stiffness, mass);
+    const energyFractionLeft = (stiffness) => {
+        const decay = Math.sqrt(stiffness / mass) * dampingRatio;
+        const envelope = Math.exp(-decay * settlingSeconds);
+        const displacement = (x0 + (v0 + x0 * decay) * settlingSeconds) * envelope;
+        const velocity = displacement * -decay + (v0 + x0 * decay) * envelope;
+        const initial = initialEnergyFor(stiffness);
+        if (initial === 0) {
+            return -energyThreshold;
+        }
+        return (energyOf(displacement, velocity, stiffness, mass) / initial -
+            energyThreshold);
+    };
+    return bisect(Number.EPSILON, 
+    // Upstream's bound: even an 8 ms spring stays under 2e3, with margin.
+    8e3, energyFractionLeft, energyThreshold * 1e-3);
+};
+/**
+ * Keeps the overshoot inside `clamp` by raising the damping ratio, using
+ * upstream's approximation: the first two extrema of a damped oscillation sit
+ * at `exp(-zeta * PI)` and `exp(-zeta * 2 * PI)` of the initial displacement,
+ * so the zeta that puts them on the bound is a logarithm away.
+ */
+const zetaForClamp = (zeta, startDisplacement, toValue, clamp) => {
+    if (startDisplacement === 0) {
+        return zeta;
+    }
+    const [firstBound, secondBound] = startDisplacement <= 0 ? [clamp.min, clamp.max] : [clamp.max, clamp.min];
+    const candidates = [zeta];
+    if (secondBound !== undefined) {
+        const extremum = Math.abs((secondBound - toValue) / startDisplacement);
+        candidates.push(Math.abs(Math.log(extremum) / Math.PI));
+    }
+    if (firstBound !== undefined) {
+        const extremum = Math.abs((firstBound - toValue) / startDisplacement);
+        candidates.push(Math.abs(Math.log(extremum) / (2 * Math.PI)));
+    }
+    // Bigger zeta means smaller bounces, so the strictest candidate wins.
+    return Math.max(...candidates);
+};
+/**
+ * Turns a Reanimated spring config into the platform solver's config.
+ *
+ * The rest condition is the one place the two genuinely differ. Upstream
+ * stops when the oscillator's remaining energy falls to `energyThreshold` of
+ * its initial energy — a RELATIVE criterion; the platform's solver stops on
+ * absolute displacement and speed thresholds. Rather than accept RN's
+ * absolute defaults (which would end a 400px spring at a different point than
+ * a 4px one), the thresholds are derived per animation from the same energy
+ * budget, so the stopping point tracks upstream's to well under a pixel.
+ */
+export const toPlatformSpringConfig = (config, toValue, from) => {
+    const mass = config.mass ?? DEFAULT_SPRING_MASS;
+    const velocity = config.velocity ?? 0;
+    const energyThreshold = config.energyThreshold ?? DEFAULT_ENERGY_THRESHOLD;
+    const useDuration = config.duration !== undefined || config.dampingRatio !== undefined;
+    const displacement = from - toValue;
+    let stiffness;
+    let zeta;
+    if (useDuration) {
+        const duration = config.duration ?? DEFAULT_SPRING_DURATION;
+        zeta = config.dampingRatio ?? DEFAULT_SPRING_DAMPING_RATIO;
+        stiffness =
+            duration <= 0
+                ? Number.POSITIVE_INFINITY
+                : stiffnessForDuration(displacement, velocity, duration, zeta, mass, energyThreshold);
+    }
+    else {
+        stiffness = config.stiffness ?? DEFAULT_SPRING_STIFFNESS;
+        const damping = config.damping ?? DEFAULT_SPRING_DAMPING;
+        zeta = damping / (2 * Math.sqrt(stiffness * mass));
+    }
+    if (config.clamp) {
+        zeta = zetaForClamp(zeta, displacement, toValue, config.clamp);
+    }
+    // A zero/degenerate duration means "be there already"; the platform solver
+    // rejects a non-finite stiffness, so collapse it to a 0 ms timing instead.
+    const resolvedStiffness = Number.isFinite(stiffness)
+        ? Math.max(stiffness, Number.EPSILON)
+        : 1e6;
+    const initialEnergy = energyOf(displacement, velocity, resolvedStiffness, mass);
+    const restEnergy = energyThreshold * initialEnergy;
+    return {
+        toValue,
+        mass,
+        stiffness: resolvedStiffness,
+        damping: Math.max(zeta * 2 * Math.sqrt(resolvedStiffness * mass), Number.EPSILON),
+        initialVelocity: velocity,
+        overshootClamping: config.overshootClamping ?? false,
+        // Semi-axes of the energy ellipse: |x| where all the remaining energy is
+        // potential, |v| where all of it is kinetic. A spring at rest is inside
+        // both.
+        restDisplacementThreshold: Math.max(Math.sqrt((2 * restEnergy) / resolvedStiffness), Number.MIN_VALUE),
+        restSpeedThreshold: Math.max(Math.sqrt((2 * restEnergy) / mass), Number.MIN_VALUE),
+    };
+};
+// --- building a running animation ---------------------------------------
+/**
+ * The last value an animation aims at, used by `withRepeat`'s reverse and by
+ * `updater-animations.ts` to seed a key that is animating for the first time.
+ */
+export const targetOf = (spec) => {
+    switch (spec.kind) {
+        case "timing":
+        case "spring":
+            return spec.toValue;
+        case "delay":
+            return targetOf(spec.animation);
+        case "sequence": {
+            const last = spec.animations[spec.animations.length - 1];
+            return last ? targetOf(last) : null;
+        }
+        case "repeat":
+            return targetOf(spec.animation);
+        case "clamp":
+            return targetOf(spec.animation);
+        // A decay has no target by construction — where it lands is the result
+        // rather than the input. `withRepeat(withDecay(...))` therefore replays
+        // from the same origin rather than ping-ponging between two.
+        case "decay":
+            return null;
+    }
+};
+/** A copy of `spec` aimed at `toValue`, for a reversed repetition. */
+const aimedAt = (spec, toValue) => {
+    switch (spec.kind) {
+        case "timing":
+        case "spring":
+            return { ...spec, toValue };
+        case "delay":
+            return { ...spec, animation: aimedAt(spec.animation, toValue) };
+        case "sequence": {
+            const animations = [...spec.animations];
+            const lastIndex = animations.length - 1;
+            const last = animations[lastIndex];
+            if (last) {
+                animations[lastIndex] = aimedAt(last, toValue);
+            }
+            return { ...spec, animations };
+        }
+        case "repeat":
+            return { ...spec, animation: aimedAt(spec.animation, toValue) };
+        case "clamp":
+            return { ...spec, animation: aimedAt(spec.animation, toValue) };
+        // Nothing to re-aim: see targetOf.
+        case "decay":
+            return spec;
+    }
+};
+/**
+ * What makes two descriptors the SAME animation, for a caller that gets a
+ * freshly built one on every evaluation and must decide whether to restart.
+ *
+ * The target and the shape, not object identity and not the whole config: a
+ * mapper re-runs whenever anything it read changed, so `withSpring(open.value
+ * ? 320 : 0)` produces a new object many times a second while asking for the
+ * same animation every time. Config fields that change WHERE the animation
+ * ends are in (a `duration`, a decay's `velocity`); ones that only change how
+ * it gets there are not, because re-aiming a running animation at the value it
+ * is already aimed at is a no-op that costs a restart.
+ */
+export const animationSignature = (spec) => {
+    switch (spec.kind) {
+        case "timing":
+            return `timing(${spec.toValue},${spec.config.duration ?? ""})`;
+        case "spring":
+            return `spring(${spec.toValue})`;
+        case "delay":
+            return `delay(${spec.delayMs},${animationSignature(spec.animation)})`;
+        case "sequence":
+            return `sequence(${spec.animations.map(animationSignature).join(";")})`;
+        case "repeat":
+            return `repeat(${spec.numberOfReps},${spec.reverse},${animationSignature(spec.animation)})`;
+        case "clamp":
+            return `clamp(${spec.min},${spec.max},${animationSignature(spec.animation)})`;
+        // A decay has no target (targetOf), so its identity is the push it was
+        // given: a new flick is a new animation, the same flick is not.
+        case "decay":
+            return `decay(${spec.config.velocity},${spec.config.deceleration})`;
+    }
+};
+const callbackOf = (spec) => spec.kind === "timing" ||
+    spec.kind === "spring" ||
+    spec.kind === "repeat" ||
+    spec.kind === "decay"
+    ? spec.callback
+    : undefined;
+/**
+ * Fires the descriptor's own callback when its animation settles — including
+ * when it is cancelled, which reports `finished: false`, as upstream does.
+ * Every node carries one, so the per-child callbacks of a `withSequence` and
+ * the per-repetition callbacks of a `withRepeat` fire without the caller
+ * having to unpick the tree.
+ */
+const reportingTo = (animation, callback, driver) => callback
+    ? {
+        start: (onEnd) => {
+            animation.start((result) => {
+                callback(result.finished, driver.__getValue());
+                onEnd?.(result);
+            });
+        },
+        stop: () => animation.stop(),
+        reset: () => animation.reset(),
+    }
+    : animation;
+const buildRepeat = (engine, driver, spec) => {
+    let child = null;
+    let cancelled = false;
+    return {
+        start(onEnd) {
+            cancelled = false;
+            const origin = driver.__getValue();
+            let from = origin;
+            let to = targetOf(spec.animation) ?? origin;
+            let completed = 0;
+            const runIteration = () => {
+                child = buildAnimation(engine, driver, aimedAt(spec.animation, to));
+                child.start((result) => {
+                    if (cancelled || !result.finished) {
+                        onEnd?.(result);
+                        return;
+                    }
+                    completed += 1;
+                    if (spec.numberOfReps > 0 && completed >= spec.numberOfReps) {
+                        onEnd?.({ finished: true });
+                        return;
+                    }
+                    if (spec.reverse) {
+                        // Ping-pong: the value is already at `to`, so the next
+                        // repetition simply aims back at where this one started.
+                        const previousTarget = to;
+                        to = from;
+                        from = previousTarget;
+                    }
+                    else {
+                        // Replay: snap back to where the repeat began and run again,
+                        // which is what upstream's onStart(startValue) amounts to.
+                        driver.setValue(from);
+                    }
+                    runIteration();
+                });
+            };
+            runIteration();
+        },
+        stop() {
+            cancelled = true;
+            child?.stop();
+        },
+        reset() {
+            child?.reset();
+        },
+    };
+};
+/**
+ * Turns a descriptor into a running animation on `driver`. Every leaf is one
+ * of the platform's own animations, so the whole tree runs off the single
+ * injected frame scheduler.
+ */
+export const buildAnimation = (engine, driver, spec) => {
+    const { api, scheduler } = engine;
+    const build = () => {
+        switch (spec.kind) {
+            case "timing":
+                return api.timing(driver, {
+                    toValue: spec.toValue,
+                    duration: spec.config.duration ?? DEFAULT_TIMING_DURATION,
+                    easing: spec.config.easing
+                        ? resolveEasing(spec.config.easing)
+                        : defaultTimingEasing,
+                });
+            case "spring":
+                return api.spring(driver, toPlatformSpringConfig(spec.config, spec.toValue, driver.__getValue()));
+            case "delay":
+                return api.sequence([
+                    api.delay(spec.delayMs),
+                    buildAnimation(engine, driver, spec.animation),
+                ]);
+            case "sequence":
+                return api.sequence(spec.animations.map((child) => buildAnimation(engine, driver, child)));
+            case "repeat":
+                return buildRepeat(engine, driver, spec);
+            case "decay":
+                return createValueAnimation(scheduler, driver, decayStep(spec.config));
+            case "clamp":
+                return buildClamp(engine, driver, spec);
+        }
+    };
+    return reportingTo(build(), callbackOf(spec), driver);
+};
+/**
+ * `withClamp` in full: the inner animation is built on a PRIVATE value and
+ * what that value publishes is clipped onto the real driver. Running it
+ * un-truncated is the whole behaviour — upstream keeps the clamped animation's
+ * own `current` unbounded for exactly this reason — and the private node costs
+ * one listener, no extra frame subscription and no second clock, because the
+ * inner animation is an ordinary one built by the same function.
+ */
+const buildClamp = (engine, driver, spec) => {
+    const inner = new engine.api.Value(driver.__getValue());
+    inner.addListener(({ value }) => {
+        const clipped = spec.max !== undefined && value > spec.max
+            ? spec.max
+            : spec.min !== undefined && value < spec.min
+                ? spec.min
+                : value;
+        driver.__updateValue(clipped);
+    });
+    return buildAnimation(engine, inner, spec.animation);
+};
+//# sourceMappingURL=animation.js.map

package/dist/reanimated-compat/animation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation.js","sourceRoot":"","sources":["../../src/reanimated-compat/animation.ts"],"names":[],"mappings":"AAAA,6EAA6E;AAC7E,EAAE;AACF,6DAA6D;AAC7D,0EAA0E;AAC1E,0EAA0E;AAC1E,6EAA6E;AAC7E,2CAA2C;AAC3C,EAAE;AACF,0EAA0E;AAC1E,wEAAwE;AACxE,0EAA0E;AAC1E,mCAAmC;AACnC,EAAE;AACF,6EAA6E;AAC7E,oEAAoE;AACpE,wBAAwB;AACxB,EAAE;AACF,gFAAgF;AAChF,gFAAgF;AAChF,gFAAgF;AAChF,gFAAgF;AAChF,iFAAiF;AACjF,EAAE;AACF,4EAA4E;AAC5E,2EAA2E;AAC3E,+DAA+D;AAC/D,OAAO,EACL,oBAAoB,GAKrB,MAAM,mBAAmB,CAAA;AAC1B,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAwB,MAAM,SAAS,CAAA;AAC7E,OAAO,EAAE,MAAM,EAAE,aAAa,EAAuB,MAAM,UAAU,CAAA;AAmFrE,MAAM,MAAM,GAAG,6BAA6B,CAAA;AAI5C,MAAM,IAAI,GAAG,CAAC,IAAmB,EAAc,EAAE,CAC/C,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,IAAa,EAAE,CAAC,CAAA;AAElD,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,KAAc,EAA0B,EAAE,CACxE,OAAO,KAAK,KAAK,QAAQ;IACzB,KAAK,KAAK,IAAI;IACb,KAAiC,CAAC,MAAM,CAAC,KAAK,IAAI,CAAA;AAErD,2EAA2E;AAC3E,EAAE;AACF,8EAA8E;AAC9E,8EAA8E;AAC9E,6EAA6E;AAC7E,2DAA2D;AAC3D,0EAA0E;AAC1E,+BAA+B;AAC/B,EAAE;AACF,sEAAsE;AACtE,EAAE;AACF,wEAAwE;AACxE,0EAA0E;AAC1E,8EAA8E;AAC9E,iEAAiE;AACjE,IAAI,YAAY,GAAG,KAAK,CAAA;AAExB;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAI,OAAgB,EAAK,EAAE;IAC1D,YAAY,GAAG,IAAI,CAAA;IACnB,IAAI,CAAC;QACH,OAAO,OAAO,EAAE,CAAA;IAClB,CAAC;YAAS,CAAC;QACT,YAAY,GAAG,KAAK,CAAA;IACtB,CAAC;AACH,CAAC,CAAA;AAED,wEAAwE;AACxE,MAAM,uBAAuB,GAAG,GAAG,CAAA;AACnC,MAAM,mBAAmB,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;AAErD,sEAAsE;AACtE,2CAA2C;AAC3C,MAAM,mBAAmB,GAAG,CAAC,CAAA;AAC7B,MAAM,wBAAwB,GAAG,GAAG,CAAA;AACpC,MAAM,sBAAsB,GAAG,GAAG,CAAA;AAClC,MAAM,uBAAuB,GAAG,GAAG,CAAA;AACnC,MAAM,4BAA4B,GAAG,CAAC,CAAA;AACtC,MAAM,wBAAwB,GAAG,IAAI,CAAA;AAErC,MAAM,gBAAgB,GAAG,CAAC,KAAc,EAAE,GAAW,EAAU,EAAE;IAC/D,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACzD,MAAM,IAAI,KAAK,CACb,4BAA4B,GAAG,yDAAyD,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI;YAClJ,wFAAwF,CAC3F,CAAA;IACH,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC,CAAA;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,OAAe,EACf,MAAyB,EACzB,QAA4B,EACpB,EAAE,CACV,YAAY;IACV,CAAC,CAAC,gBAAgB,CAAC,OAAO,EAAE,YAAY,CAAC;IACzC,CAAC,CAAE,IAAI,CAAC;QACJ,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,gBAAgB,CAAC,OAAO,EAAE,YAAY,CAAC;QAChD,MAAM,EAAE,MAAM,IAAI,EAAE;QACpB,QAAQ;KACT,CAAuB,CAAA;AAE9B,oDAAoD;AACpD,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,OAAe,EACf,MAAyB,EACzB,QAA4B,EACpB,EAAE,CACV,YAAY;IACV,CAAC,CAAC,gBAAgB,CAAC,OAAO,EAAE,YAAY,CAAC;IACzC,CAAC,CAAE,IAAI,CAAC;QACJ,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,gBAAgB,CAAC,OAAO,EAAE,YAAY,CAAC;QAChD,MAAM,EAAE,MAAM,IAAI,EAAE;QACpB,QAAQ;KACT,CAAuB,CAAA;AAE9B,6CAA6C;AAC7C,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,OAAe,EAAE,SAAiB,EAAU,EAAE;IACtE,uEAAuE;IACvE,gEAAgE;IAChE,IAAI,YAAY,EAAE,CAAC;QACjB,OAAO,SAAS,CAAA;IAClB,CAAC;IACD,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CACb,6FAA6F,CAC9F,CAAA;IACH,CAAC;IACD,OAAO,IAAI,CAAC;QACV,IAAI,EAAE,OAAO;QACb,OAAO;QACP,SAAS;KACV,CAAsB,CAAA;AACzB,CAAC,CAAA;AAED,kEAAkE;AAClE,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,GAAG,UAAoB,EAAU,EAAE;IAC9D,IAAI,YAAY,EAAE,CAAC;QACjB,OAAO,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAA;IAC3B,CAAC;IACD,MAAM,KAAK,GAAoB,EAAE,CAAA;IACjC,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACnC,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,EAAE,CAAC;YAChC,MAAM,IAAI,KAAK,CACb,2GAA2G,CAC5G,CAAA;QACH,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;IACvB,CAAC;IACD,OAAO,IAAI,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,KAAK,EAAE,CAAsB,CAAA;AAC3E,CAAC,CAAA;AAED;;;GAGG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,SAAiB,EACjB,YAAY,GAAG,CAAC,EAChB,OAAO,GAAG,KAAK,EACf,QAA4B,EACpB,EAAE;IACV,IAAI,YAAY,EAAE,CAAC;QACjB,OAAO,SAAS,CAAA;IAClB,CAAC;IACD,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CACb,6FAA6F,CAC9F,CAAA;IACH,CAAC;IACD,OAAO,IAAI,CAAC;QACV,IAAI,EAAE,QAAQ;QACd,SAAS;QACT,YAAY;QACZ,OAAO;QACP,QAAQ;KACT,CAAsB,CAAA;AACzB,CAAC,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CACvB,MAAwB,EACxB,QAA4B,EACpB,EAAE,CACV,YAAY;IACV,CAAC,CAAC,kEAAkE;QAClE,CAAC;IACH,CAAC,CAAE,IAAI,CAAC;QACJ,IAAI,EAAE,OAAO;QACb,MAAM,EAAE,kBAAkB,CAAC,MAAM,CAAC;QAClC,QAAQ;KACT,CAAuB,CAAA;AAE9B;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CACvB,MAAsC,EACtC,SAAiB,EACT,EAAE;IACV,IAAI,YAAY,EAAE,CAAC;QACjB,OAAO,SAAS,CAAA;IAClB,CAAC;IACD,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CACb,oGAAoG,CACrG,CAAA;IACH,CAAC;IACD,IACE,MAAM,CAAC,GAAG,KAAK,SAAS;QACxB,MAAM,CAAC,GAAG,KAAK,SAAS;QACxB,MAAM,CAAC,GAAG,GAAG,MAAM,CAAC,GAAG,EACvB,CAAC;QACD,MAAM,IAAI,KAAK,CACb,sDAAsD,MAAM,CAAC,GAAG,cAAc,MAAM,CAAC,GAAG,GAAG,CAC5F,CAAA;IACH,CAAC;IACD,OAAO,IAAI,CAAC;QACV,IAAI,EAAE,OAAO;QACb,GAAG,EAAE,MAAM,CAAC,GAAG;QACf,GAAG,EAAE,MAAM,CAAC,GAAG;QACf,SAAS;KACV,CAAsB,CAAA;AACzB,CAAC,CAAA;AAID,2EAA2E;AAE3E,MAAM,MAAM,GAAG,CACb,GAAW,EACX,GAAW,EACX,EAAyB,EACzB,SAAiB,EACjB,aAAa,GAAG,GAAG,EACX,EAAE;IACV,IAAI,GAAG,GAAG,GAAG,CAAA;IACb,IAAI,IAAI,GAAG,GAAG,CAAA;IACd,MAAM,SAAS,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;IAC9C,IAAI,OAAO,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAA;IAC9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC;QAC5E,IAAI,EAAE,CAAC,OAAO,CAAC,GAAG,SAAS,GAAG,CAAC,EAAE,CAAC;YAChC,GAAG,GAAG,OAAO,CAAA;QACf,CAAC;aAAM,CAAC;YACN,IAAI,GAAG,OAAO,CAAA;QAChB,CAAC;QACD,OAAO,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAA;IAC5B,CAAC;IACD,OAAO,OAAO,CAAA;AAChB,CAAC,CAAA;AAED,MAAM,QAAQ,GAAG,CACf,YAAoB,EACpB,QAAgB,EAChB,SAAiB,EACjB,IAAY,EACJ,EAAE,CAAC,GAAG,GAAG,SAAS,GAAG,YAAY,IAAI,CAAC,GAAG,GAAG,GAAG,IAAI,GAAG,QAAQ,IAAI,CAAC,CAAA;AAE7E;;;;;;;GAOG;AACH,MAAM,oBAAoB,GAAG,CAC3B,EAAU,EACV,EAAU,EACV,UAAkB,EAClB,YAAoB,EACpB,IAAY,EACZ,eAAuB,EACf,EAAE;IACV,MAAM,sBAAsB,GAAG,GAAG,CAAA;IAClC,MAAM,eAAe,GAAG,CAAC,UAAU,GAAG,sBAAsB,CAAC,GAAG,IAAI,CAAA;IACpE,MAAM,gBAAgB,GAAG,CAAC,SAAiB,EAAU,EAAE,CACrD,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,IAAI,CAAC,CAAA;IAEnC,MAAM,kBAAkB,GAAG,CAAC,SAAiB,EAAU,EAAE;QACvD,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,YAAY,CAAA;QACxD,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,eAAe,CAAC,CAAA;QACnD,MAAM,YAAY,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC,GAAG,eAAe,CAAC,GAAG,QAAQ,CAAA;QAC1E,MAAM,QAAQ,GAAG,YAAY,GAAG,CAAC,KAAK,GAAG,CAAC,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC,GAAG,QAAQ,CAAA;QACrE,MAAM,OAAO,GAAG,gBAAgB,CAAC,SAAS,CAAC,CAAA;QAC3C,IAAI,OAAO,KAAK,CAAC,EAAE,CAAC;YAClB,OAAO,CAAC,eAAe,CAAA;QACzB,CAAC;QACD,OAAO,CACL,QAAQ,CAAC,YAAY,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,GAAG,OAAO;YAC3D,eAAe,CAChB,CAAA;IACH,CAAC,CAAA;IAED,OAAO,MAAM,CACX,MAAM,CAAC,OAAO;IACd,sEAAsE;IACtE,GAAG,EACH,kBAAkB,EAClB,eAAe,GAAG,IAAI,CACvB,CAAA;AACH,CAAC,CAAA;AAED;;;;;GAKG;AACH,MAAM,YAAY,GAAG,CACnB,IAAY,EACZ,iBAAyB,EACzB,OAAe,EACf,KAAqC,EAC7B,EAAE;IACV,IAAI,iBAAiB,KAAK,CAAC,EAAE,CAAC;QAC5B,OAAO,IAAI,CAAA;IACb,CAAC;IACD,MAAM,CAAC,UAAU,EAAE,WAAW,CAAC,GAC7B,iBAAiB,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,KAAK,CAAC,GAAG,CAAC,CAAA;IAC1E,MAAM,UAAU,GAAG,CAAC,IAAI,CAAC,CAAA;IACzB,IAAI,WAAW,KAAK,SAAS,EAAE,CAAC;QAC9B,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,WAAW,GAAG,OAAO,CAAC,GAAG,iBAAiB,CAAC,CAAA;QACtE,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAA;IACzD,CAAC;IACD,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;QAC7B,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,UAAU,GAAG,OAAO,CAAC,GAAG,iBAAiB,CAAC,CAAA;QACrE,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;IAC/D,CAAC;IACD,sEAAsE;IACtE,OAAO,IAAI,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC,CAAA;AAChC,CAAC,CAAA;AAaD;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CACpC,MAAwB,EACxB,OAAe,EACf,IAAY,EACU,EAAE;IACxB,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,mBAAmB,CAAA;IAC/C,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAA;IACrC,MAAM,eAAe,GAAG,MAAM,CAAC,eAAe,IAAI,wBAAwB,CAAA;IAC1E,MAAM,WAAW,GACf,MAAM,CAAC,QAAQ,KAAK,SAAS,IAAI,MAAM,CAAC,YAAY,KAAK,SAAS,CAAA;IAEpE,MAAM,YAAY,GAAG,IAAI,GAAG,OAAO,CAAA;IAEnC,IAAI,SAAiB,CAAA;IACrB,IAAI,IAAY,CAAA;IAChB,IAAI,WAAW,EAAE,CAAC;QAChB,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,uBAAuB,CAAA;QAC3D,IAAI,GAAG,MAAM,CAAC,YAAY,IAAI,4BAA4B,CAAA;QAC1D,SAAS;YACP,QAAQ,IAAI,CAAC;gBACX,CAAC,CAAC,MAAM,CAAC,iBAAiB;gBAC1B,CAAC,CAAC,oBAAoB,CAClB,YAAY,EACZ,QAAQ,EACR,QAAQ,EACR,IAAI,EACJ,IAAI,EACJ,eAAe,CAChB,CAAA;IACT,CAAC;SAAM,CAAC;QACN,SAAS,GAAG,MAAM,CAAC,SAAS,IAAI,wBAAwB,CAAA;QACxD,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,sBAAsB,CAAA;QACxD,IAAI,GAAG,OAAO,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,CAAA;IACpD,CAAC;IAED,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;QACjB,IAAI,GAAG,YAAY,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,CAAA;IAChE,CAAC;IAED,2EAA2E;IAC3E,2EAA2E;IAC3E,MAAM,iBAAiB,GAAG,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC;QAClD,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC;QACrC,CAAC,CAAC,GAAG,CAAA;IAEP,MAAM,aAAa,GAAG,QAAQ,CAC5B,YAAY,EACZ,QAAQ,EACR,iBAAiB,EACjB,IAAI,CACL,CAAA;IACD,MAAM,UAAU,GAAG,eAAe,GAAG,aAAa,CAAA;IAElD,OAAO;QACL,OAAO;QACP,IAAI;QACJ,SAAS,EAAE,iBAAiB;QAC5B,OAAO,EAAE,IAAI,CAAC,GAAG,CACf,IAAI,GAAG,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,iBAAiB,GAAG,IAAI,CAAC,EAC9C,MAAM,CAAC,OAAO,CACf;QACD,eAAe,EAAE,QAAQ;QACzB,iBAAiB,EAAE,MAAM,CAAC,iBAAiB,IAAI,KAAK;QACpD,yEAAyE;QACzE,wEAAwE;QACxE,QAAQ;QACR,yBAAyB,EAAE,IAAI,CAAC,GAAG,CACjC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,GAAG,iBAAiB,CAAC,EAC/C,MAAM,CAAC,SAAS,CACjB;QACD,kBAAkB,EAAE,IAAI,CAAC,GAAG,CAC1B,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,GAAG,IAAI,CAAC,EAClC,MAAM,CAAC,SAAS,CACjB;KACF,CAAA;AACH,CAAC,CAAA;AAED,2EAA2E;AAE3E;;;GAGG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,IAAmB,EAAiB,EAAE;IAC7D,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,QAAQ,CAAC;QACd,KAAK,QAAQ;YACX,OAAO,IAAI,CAAC,OAAO,CAAA;QACrB,KAAK,OAAO;YACV,OAAO,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QACjC,KAAK,UAAU,CAAC,CAAC,CAAC;YAChB,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;YACxD,OAAO,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;QACrC,CAAC;QACD,KAAK,QAAQ;YACX,OAAO,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QACjC,KAAK,OAAO;YACV,OAAO,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QACjC,uEAAuE;QACvE,wEAAwE;QACxE,6DAA6D;QAC7D,KAAK,OAAO;YACV,OAAO,IAAI,CAAA;IACf,CAAC;AACH,CAAC,CAAA;AAED,sEAAsE;AACtE,MAAM,OAAO,GAAG,CAAC,IAAmB,EAAE,OAAe,EAAiB,EAAE;IACtE,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,QAAQ,CAAC;QACd,KAAK,QAAQ;YACX,OAAO,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,CAAA;QAC7B,KAAK,OAAO;YACV,OAAO,EAAE,GAAG,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,CAAA;QACjE,KAAK,UAAU,CAAC,CAAC,CAAC;YAChB,MAAM,UAAU,GAAG,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,CAAA;YACvC,MAAM,SAAS,GAAG,UAAU,CAAC,MAAM,GAAG,CAAC,CAAA;YACvC,MAAM,IAAI,GAAG,UAAU,CAAC,SAAS,CAAC,CAAA;YAClC,IAAI,IAAI,EAAE,CAAC;gBACT,UAAU,CAAC,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;YAChD,CAAC;YACD,OAAO,EAAE,GAAG,IAAI,EAAE,UAAU,EAAE,CAAA;QAChC,CAAC;QACD,KAAK,QAAQ;YACX,OAAO,EAAE,GAAG,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,CAAA;QACjE,KAAK,OAAO;YACV,OAAO,EAAE,GAAG,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,CAAA;QACjE,mCAAmC;QACnC,KAAK,OAAO;YACV,OAAO,IAAI,CAAA;IACf,CAAC;AACH,CAAC,CAAA;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,IAAmB,EAAU,EAAE;IAChE,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,QAAQ;YACX,OAAO,UAAU,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,EAAE,GAAG,CAAA;QAChE,KAAK,QAAQ;YACX,OAAO,UAAU,IAAI,CAAC,OAAO,GAAG,CAAA;QAClC,KAAK,OAAO;YACV,OAAO,SAAS,IAAI,CAAC,OAAO,IAAI,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAA;QACvE,KAAK,UAAU;YACb,OAAO,YAAY,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAA;QACzE,KAAK,QAAQ;YACX,OAAO,UAAU,IAAI,CAAC,YAAY,IAAI,IAAI,CAAC,OAAO,IAAI,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAA;QAC7F,KAAK,OAAO;YACV,OAAO,SAAS,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,IAAI,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAA;QAC/E,uEAAuE;QACvE,gEAAgE;QAChE,KAAK,OAAO;YACV,OAAO,SAAS,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC,YAAY,GAAG,CAAA;IACvE,CAAC;AACH,CAAC,CAAA;AAED,MAAM,UAAU,GAAG,CAAC,IAAmB,EAAiC,EAAE,CACxE,IAAI,CAAC,IAAI,KAAK,QAAQ;IACtB,IAAI,CAAC,IAAI,KAAK,QAAQ;IACtB,IAAI,CAAC,IAAI,KAAK,QAAQ;IACtB,IAAI,CAAC,IAAI,KAAK,OAAO;IACnB,CAAC,CAAC,IAAI,CAAC,QAAQ;IACf,CAAC,CAAC,SAAS,CAAA;AAEf;;;;;;GAMG;AACH,MAAM,WAAW,GAAG,CAClB,SAA6B,EAC7B,QAAuC,EACvC,MAAqB,EACD,EAAE,CACtB,QAAQ;IACN,CAAC,CAAC;QACE,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE;YACf,SAAS,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE;gBACzB,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,UAAU,EAAE,CAAC,CAAA;gBAC9C,KAAK,EAAE,CAAC,MAAM,CAAC,CAAA;YACjB,CAAC,CAAC,CAAA;QACJ,CAAC;QACD,IAAI,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE;QAC5B,KAAK,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,KAAK,EAAE;KAC/B;IACH,CAAC,CAAC,SAAS,CAAA;AAaf,MAAM,WAAW,GAAG,CAClB,MAAuB,EACvB,MAAqB,EACrB,IAAgB,EACI,EAAE;IACtB,IAAI,KAAK,GAA8B,IAAI,CAAA;IAC3C,IAAI,SAAS,GAAG,KAAK,CAAA;IAErB,OAAO;QACL,KAAK,CAAC,KAAK;YACT,SAAS,GAAG,KAAK,CAAA;YACjB,MAAM,MAAM,GAAG,MAAM,CAAC,UAAU,EAAE,CAAA;YAClC,IAAI,IAAI,GAAG,MAAM,CAAA;YACjB,IAAI,EAAE,GAAG,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,MAAM,CAAA;YAC3C,IAAI,SAAS,GAAG,CAAC,CAAA;YAEjB,MAAM,YAAY,GAAG,GAAS,EAAE;gBAC9B,KAAK,GAAG,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,CAAA;gBACnE,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,EAAE,EAAE;oBACrB,IAAI,SAAS,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;wBAClC,KAAK,EAAE,CAAC,MAAM,CAAC,CAAA;wBACf,OAAM;oBACR,CAAC;oBACD,SAAS,IAAI,CAAC,CAAA;oBACd,IAAI,IAAI,CAAC,YAAY,GAAG,CAAC,IAAI,SAAS,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;wBAC5D,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAA;wBAC3B,OAAM;oBACR,CAAC;oBACD,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;wBACjB,uDAAuD;wBACvD,yDAAyD;wBACzD,MAAM,cAAc,GAAG,EAAE,CAAA;wBACzB,EAAE,GAAG,IAAI,CAAA;wBACT,IAAI,GAAG,cAAc,CAAA;oBACvB,CAAC;yBAAM,CAAC;wBACN,6DAA6D;wBAC7D,2DAA2D;wBAC3D,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;oBACvB,CAAC;oBACD,YAAY,EAAE,CAAA;gBAChB,CAAC,CAAC,CAAA;YACJ,CAAC,CAAA;YAED,YAAY,EAAE,CAAA;QAChB,CAAC;QACD,IAAI;YACF,SAAS,GAAG,IAAI,CAAA;YAChB,KAAK,EAAE,IAAI,EAAE,CAAA;QACf,CAAC;QACD,KAAK;YACH,KAAK,EAAE,KAAK,EAAE,CAAA;QAChB,CAAC;KACF,CAAA;AACH,CAAC,CAAA;AAED;;;;GAIG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,MAAuB,EACvB,MAAqB,EACrB,IAAmB,EACC,EAAE;IACtB,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,MAAM,CAAA;IACjC,MAAM,KAAK,GAAG,GAAuB,EAAE;QACrC,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;YAClB,KAAK,QAAQ;gBACX,OAAO,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE;oBACxB,OAAO,EAAE,IAAI,CAAC,OAAO;oBACrB,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ,IAAI,uBAAuB;oBACzD,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,MAAM;wBACxB,CAAC,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC;wBACnC,CAAC,CAAC,mBAAmB;iBACxB,CAAC,CAAA;YACJ,KAAK,QAAQ;gBACX,OAAO,GAAG,CAAC,MAAM,CACf,MAAM,EACN,sBAAsB,CACpB,IAAI,CAAC,MAAM,EACX,IAAI,CAAC,OAAO,EACZ,MAAM,CAAC,UAAU,EAAE,CACpB,CACF,CAAA;YACH,KAAK,OAAO;gBACV,OAAO,GAAG,CAAC,QAAQ,CAAC;oBAClB,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC;oBACvB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC;iBAC/C,CAAC,CAAA;YACJ,KAAK,UAAU;gBACb,OAAO,GAAG,CAAC,QAAQ,CACjB,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CACtE,CAAA;YACH,KAAK,QAAQ;gBACX,OAAO,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,CAAA;YAC1C,KAAK,OAAO;gBACV,OAAO,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAA;YACxE,KAAK,OAAO;gBACV,OAAO,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,CAAA;QAC3C,CAAC;IACH,CAAC,CAAA;IACD,OAAO,WAAW,CAAC,KAAK,EAAE,EAAE,UAAU,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,CAAA;AACvD,CAAC,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,GAAG,CACjB,MAAuB,EACvB,MAAqB,EACrB,IAAe,EACK,EAAE;IACtB,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,CAAA;IACvD,KAAK,CAAC,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE;QAC9B,MAAM,OAAO,GACX,IAAI,CAAC,GAAG,KAAK,SAAS,IAAI,KAAK,GAAG,IAAI,CAAC,GAAG;YACxC,CAAC,CAAC,IAAI,CAAC,GAAG;YACV,CAAC,CAAC,IAAI,CAAC,GAAG,KAAK,SAAS,IAAI,KAAK,GAAG,IAAI,CAAC,GAAG;gBAC1C,CAAC,CAAC,IAAI,CAAC,GAAG;gBACV,CAAC,CAAC,KAAK,CAAA;QACb,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,CAAA;IAC/B,CAAC,CAAC,CAAA;IACF,OAAO,cAAc,CAAC,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;AACtD,CAAC,CAAA","sourcesContent":["// `withTiming` / `withSpring` / `withDelay` / `withSequence` / `withRepeat`.\n//\n// Upstream types these as returning the animated type itself\n// (`withTiming(100)` is a `number`), because what starts the animation is\n// ASSIGNING the result to a shared value. The cast at each return mirrors\n// that trick rather than inventing a different API — see `mutable.ts`, which\n// recognises the descriptor in its setter.\n//\n// The descriptors are plain data. Turning one into a running animation is\n// `buildAnimation`, and it builds on the platform's own `src/animated/`\n// engine: same frame scheduler, same closed-form solvers, same preemption\n// rules. This layer adds no clock.\n//\n// It does NOT reuse `Animated.timing`/`Animated.spring`'s DEFAULTS, and that\n// distinction is load-bearing. Reanimated's defaults are materially\n// different animations:\n//\n//   | config          | RN Animated              | Reanimated 4               |\n//   | --------------- | ------------------------ | -------------------------- |\n//   | timing duration | 500 ms                   | 300 ms                     |\n//   | timing easing   | inOut(ease)              | inOut(quad)                |\n//   | spring          | damping 10, mass 1, k 100 | damping 120, mass 4, k 900 |\n//\n// The spring row is not a tuning difference: RN's default has damping ratio\n// 0.5 and visibly bounces, Reanimated 4's is exactly critically damped and\n// does not. Every config below is therefore passed explicitly.\nimport {\n  createValueAnimation,\n  type AnimatedApi,\n  type AnimatedValue,\n  type CompositeAnimation,\n  type FrameScheduler,\n} from \"../animated/index\"\nimport { decayStep, resolveDecayConfig, type WithDecayConfig } from \"./decay\"\nimport { Easing, resolveEasing, type EasingFunction } from \"./easing\"\n\n/** Called when an animation settles or is cancelled, as upstream. */\nexport type AnimationCallback = (finished?: boolean, current?: number) => void\n\nexport type WithTimingConfig = {\n  duration?: number\n  easing?: EasingFunction | { factory: () => EasingFunction }\n}\n\n/**\n * Upstream's config is a mutually exclusive union: either the physical\n * parameterisation (`stiffness`/`damping`) or the perceptual one\n * (`duration`/`dampingRatio`). Both are accepted here and normalised into the\n * physical one, which is what the platform's spring solver takes.\n */\nexport type WithSpringConfig = {\n  mass?: number\n  stiffness?: number\n  damping?: number\n  duration?: number\n  dampingRatio?: number\n  clamp?: { min?: number; max?: number }\n  velocity?: number\n  overshootClamping?: boolean\n  energyThreshold?: number\n}\n\ntype TimingSpec = {\n  kind: \"timing\"\n  toValue: number\n  config: WithTimingConfig\n  callback?: AnimationCallback\n}\n\ntype SpringSpec = {\n  kind: \"spring\"\n  toValue: number\n  config: WithSpringConfig\n  callback?: AnimationCallback\n}\n\ntype DelaySpec = {\n  kind: \"delay\"\n  delayMs: number\n  animation: AnimationSpec\n}\n\ntype SequenceSpec = {\n  kind: \"sequence\"\n  animations: AnimationSpec[]\n}\n\ntype RepeatSpec = {\n  kind: \"repeat\"\n  animation: AnimationSpec\n  numberOfReps: number\n  reverse: boolean\n  callback?: AnimationCallback\n}\n\ntype DecaySpec = {\n  kind: \"decay\"\n  config: ReturnType<typeof resolveDecayConfig>\n  callback?: AnimationCallback\n}\n\ntype ClampSpec = {\n  kind: \"clamp\"\n  min?: number\n  max?: number\n  animation: AnimationSpec\n}\n\nexport type AnimationSpec =\n  | TimingSpec\n  | SpringSpec\n  | DelaySpec\n  | SequenceSpec\n  | RepeatSpec\n  | DecaySpec\n  | ClampSpec\n\nconst MARKER = \"__rnGtkxReanimatedAnimation\"\n\ntype MarkedSpec = AnimationSpec & { [MARKER]: true }\n\nconst mark = (spec: AnimationSpec): MarkedSpec =>\n  Object.assign(spec, { [MARKER]: true as const })\n\nexport const isAnimationSpec = (value: unknown): value is AnimationSpec =>\n  typeof value === \"object\" &&\n  value !== null &&\n  (value as Record<string, unknown>)[MARKER] === true\n\n// --- the initial run ----------------------------------------------------\n//\n// Upstream's `IN_STYLE_UPDATER`, and it is not a detail: the FIRST evaluation\n// of a `useDerivedValue`/`useAnimatedStyle`/`useAnimatedProps` updater has no\n// value to animate FROM, so every `with*` builder returns its target instead\n// of an animation. `defineAnimation` does it in one line —\n// `if (IN_STYLE_UPDATER.current) return starting` — and that line is what\n// makes the documented pattern\n//\n//   const v = useDerivedValue(() => withSpring(active.value ? 1 : 0))\n//\n// work at all. Without it the shared value is SEEDED with the animation\n// object itself and every later write finds a value that is not a number.\n// Found by building `react-native-draggable-flatlist`, whose `ScaleDecorator`\n// is exactly that pattern (`hooks/useOnCellActiveAnimation.ts`).\nlet inInitialRun = false\n\n/**\n * Runs an updater in \"seed the value\" mode, where every animation collapses\n * to the value it would have finished at.\n */\nexport const initialUpdaterRun = <T>(updater: () => T): T => {\n  inInitialRun = true\n  try {\n    return updater()\n  } finally {\n    inInitialRun = false\n  }\n}\n\n// Upstream's own defaults, quoted in the table at the top of this file.\nconst DEFAULT_TIMING_DURATION = 300\nconst defaultTimingEasing = Easing.inOut(Easing.quad)\n\n// GentleSpringConfig + energyThreshold, react-native-reanimated 4.5.3\n// (src/animation/spring/springConfigs.ts).\nconst DEFAULT_SPRING_MASS = 4\nconst DEFAULT_SPRING_STIFFNESS = 900\nconst DEFAULT_SPRING_DAMPING = 120\nconst DEFAULT_SPRING_DURATION = 550\nconst DEFAULT_SPRING_DAMPING_RATIO = 1\nconst DEFAULT_ENERGY_THRESHOLD = 6e-9\n\nconst assertAnimatable = (value: unknown, api: string): number => {\n  if (typeof value !== \"number\" || !Number.isFinite(value)) {\n    throw new Error(\n      `react-native-reanimated: ${api}() on this platform animates finite numbers only, got ${typeof value === \"string\" ? `\"${value}\"` : String(value)}. ` +\n        \"Colors and layout properties cannot be driven imperatively here yet — see docs/api.md.\",\n    )\n  }\n  return value\n}\n\n/**\n * Lets you animate a value over a duration with an easing curve. Assign the\n * result to a shared value to start it.\n */\nexport const withTiming = (\n  toValue: number,\n  config?: WithTimingConfig,\n  callback?: AnimationCallback,\n): number =>\n  inInitialRun\n    ? assertAnimatable(toValue, \"withTiming\")\n    : (mark({\n        kind: \"timing\",\n        toValue: assertAnimatable(toValue, \"withTiming\"),\n        config: config ?? {},\n        callback,\n      }) as unknown as number)\n\n/** Lets you animate a value with spring physics. */\nexport const withSpring = (\n  toValue: number,\n  config?: WithSpringConfig,\n  callback?: AnimationCallback,\n): number =>\n  inInitialRun\n    ? assertAnimatable(toValue, \"withSpring\")\n    : (mark({\n        kind: \"spring\",\n        toValue: assertAnimatable(toValue, \"withSpring\"),\n        config: config ?? {},\n        callback,\n      }) as unknown as number)\n\n/** Delays another animation by `delayMs`. */\nexport const withDelay = (delayMs: number, animation: number): number => {\n  // Upstream's `starting` for every composite is the animation it wraps,\n  // which the initial run has already collapsed to a plain value.\n  if (inInitialRun) {\n    return animation\n  }\n  if (!isAnimationSpec(animation)) {\n    throw new Error(\n      \"react-native-reanimated: withDelay() takes an animation, e.g. withDelay(500, withTiming(1))\",\n    )\n  }\n  return mark({\n    kind: \"delay\",\n    delayMs,\n    animation,\n  }) as unknown as number\n}\n\n/** Runs animations one after another on the same shared value. */\nexport const withSequence = (...animations: number[]): number => {\n  if (inInitialRun) {\n    return animations[0] ?? 0\n  }\n  const specs: AnimationSpec[] = []\n  for (const animation of animations) {\n    if (!isAnimationSpec(animation)) {\n      throw new Error(\n        \"react-native-reanimated: withSequence() takes animations, e.g. withSequence(withTiming(1), withTiming(0))\",\n      )\n    }\n    specs.push(animation)\n  }\n  return mark({ kind: \"sequence\", animations: specs }) as unknown as number\n}\n\n/**\n * Repeats an animation. `numberOfReps <= 0` repeats forever; `reverse` plays\n * every other repetition backwards.\n */\nexport const withRepeat = (\n  animation: number,\n  numberOfReps = 2,\n  reverse = false,\n  callback?: AnimationCallback,\n): number => {\n  if (inInitialRun) {\n    return animation\n  }\n  if (!isAnimationSpec(animation)) {\n    throw new Error(\n      \"react-native-reanimated: withRepeat() takes an animation, e.g. withRepeat(withTiming(1), 3)\",\n    )\n  }\n  return mark({\n    kind: \"repeat\",\n    animation,\n    numberOfReps,\n    reverse,\n    callback,\n  }) as unknown as number\n}\n\n/**\n * Coasts to a stop from an initial velocity — the release half of a fling.\n * Unlike every other animation here it has no target: where it lands is the\n * result of the velocity and the friction, which is exactly what makes it the\n * one an inertial gesture needs.\n *\n * ```tsx\n * onPanResponderRelease: (_, g) => {\n *   x.value = withDecay({ velocity: g.vx * 1000, clamp: [0, width] })\n * }\n * ```\n *\n * `velocity` is in units per SECOND, as upstream — `PanResponder`'s\n * `gestureState.vx` is per millisecond, so it wants the ×1000 above.\n */\nexport const withDecay = (\n  config?: WithDecayConfig,\n  callback?: AnimationCallback,\n): number =>\n  inInitialRun\n    ? // Upstream seeds a decay with 0: it has no target to collapse to.\n      0\n    : (mark({\n        kind: \"decay\",\n        config: resolveDecayConfig(config),\n        callback,\n      }) as unknown as number)\n\n/**\n * Confines another animation to a range: the inner animation runs its own\n * un-truncated course and what reaches the value is clipped to `[min, max]`.\n * That distinction is upstream's and it is observable — a spring clamped at\n * 100 that would have overshot to 120 sits at 100 and then comes back down,\n * rather than settling at 100 the moment it first arrives.\n */\nexport const withClamp = (\n  config: { min?: number; max?: number },\n  animation: number,\n): number => {\n  if (inInitialRun) {\n    return animation\n  }\n  if (!isAnimationSpec(animation)) {\n    throw new Error(\n      \"react-native-reanimated: withClamp() takes an animation, e.g. withClamp({ min: 0 }, withSpring(1))\",\n    )\n  }\n  if (\n    config.min !== undefined &&\n    config.max !== undefined &&\n    config.max < config.min\n  ) {\n    throw new Error(\n      `react-native-reanimated: withClamp() was given min ${config.min} above max ${config.max}.`,\n    )\n  }\n  return mark({\n    kind: \"clamp\",\n    min: config.min,\n    max: config.max,\n    animation,\n  }) as unknown as number\n}\n\nexport type { WithDecayConfig } from \"./decay\"\n\n// --- spring config normalisation ----------------------------------------\n\nconst bisect = (\n  min: number,\n  max: number,\n  fn: (x: number) => number,\n  precision: number,\n  maxIterations = 100,\n): number => {\n  let low = min\n  let high = max\n  const direction = fn(high) >= fn(low) ? 1 : -1\n  let current = (low + high) / 2\n  for (let i = 0; i < maxIterations && Math.abs(fn(current)) > precision; i++) {\n    if (fn(current) * direction < 0) {\n      low = current\n    } else {\n      high = current\n    }\n    current = (low + high) / 2\n  }\n  return current\n}\n\nconst energyOf = (\n  displacement: number,\n  velocity: number,\n  stiffness: number,\n  mass: number,\n): number => 0.5 * stiffness * displacement ** 2 + 0.5 * mass * velocity ** 2\n\n/**\n * Solves for the stiffness whose settling time matches a requested perceptual\n * duration, by bisection on the fraction of the initial energy left after\n * 1.5 × that duration. Ported from upstream's\n * `calculateNewStiffnessToMatchDuration` — the perceptual-duration spring is\n * a Reanimated concept with no RN equivalent, so there is nothing on the\n * platform side to reuse.\n */\nconst stiffnessForDuration = (\n  x0: number,\n  v0: number,\n  durationMs: number,\n  dampingRatio: number,\n  mass: number,\n  energyThreshold: number,\n): number => {\n  const PERCEPTUAL_COEFFICIENT = 1.5\n  const settlingSeconds = (durationMs * PERCEPTUAL_COEFFICIENT) / 1000\n  const initialEnergyFor = (stiffness: number): number =>\n    energyOf(x0, v0, stiffness, mass)\n\n  const energyFractionLeft = (stiffness: number): number => {\n    const decay = Math.sqrt(stiffness / mass) * dampingRatio\n    const envelope = Math.exp(-decay * settlingSeconds)\n    const displacement = (x0 + (v0 + x0 * decay) * settlingSeconds) * envelope\n    const velocity = displacement * -decay + (v0 + x0 * decay) * envelope\n    const initial = initialEnergyFor(stiffness)\n    if (initial === 0) {\n      return -energyThreshold\n    }\n    return (\n      energyOf(displacement, velocity, stiffness, mass) / initial -\n      energyThreshold\n    )\n  }\n\n  return bisect(\n    Number.EPSILON,\n    // Upstream's bound: even an 8 ms spring stays under 2e3, with margin.\n    8e3,\n    energyFractionLeft,\n    energyThreshold * 1e-3,\n  )\n}\n\n/**\n * Keeps the overshoot inside `clamp` by raising the damping ratio, using\n * upstream's approximation: the first two extrema of a damped oscillation sit\n * at `exp(-zeta * PI)` and `exp(-zeta * 2 * PI)` of the initial displacement,\n * so the zeta that puts them on the bound is a logarithm away.\n */\nconst zetaForClamp = (\n  zeta: number,\n  startDisplacement: number,\n  toValue: number,\n  clamp: { min?: number; max?: number },\n): number => {\n  if (startDisplacement === 0) {\n    return zeta\n  }\n  const [firstBound, secondBound] =\n    startDisplacement <= 0 ? [clamp.min, clamp.max] : [clamp.max, clamp.min]\n  const candidates = [zeta]\n  if (secondBound !== undefined) {\n    const extremum = Math.abs((secondBound - toValue) / startDisplacement)\n    candidates.push(Math.abs(Math.log(extremum) / Math.PI))\n  }\n  if (firstBound !== undefined) {\n    const extremum = Math.abs((firstBound - toValue) / startDisplacement)\n    candidates.push(Math.abs(Math.log(extremum) / (2 * Math.PI)))\n  }\n  // Bigger zeta means smaller bounces, so the strictest candidate wins.\n  return Math.max(...candidates)\n}\n\ntype PlatformSpringConfig = {\n  toValue: number\n  mass: number\n  stiffness: number\n  damping: number\n  initialVelocity: number\n  overshootClamping: boolean\n  restDisplacementThreshold: number\n  restSpeedThreshold: number\n}\n\n/**\n * Turns a Reanimated spring config into the platform solver's config.\n *\n * The rest condition is the one place the two genuinely differ. Upstream\n * stops when the oscillator's remaining energy falls to `energyThreshold` of\n * its initial energy — a RELATIVE criterion; the platform's solver stops on\n * absolute displacement and speed thresholds. Rather than accept RN's\n * absolute defaults (which would end a 400px spring at a different point than\n * a 4px one), the thresholds are derived per animation from the same energy\n * budget, so the stopping point tracks upstream's to well under a pixel.\n */\nexport const toPlatformSpringConfig = (\n  config: WithSpringConfig,\n  toValue: number,\n  from: number,\n): PlatformSpringConfig => {\n  const mass = config.mass ?? DEFAULT_SPRING_MASS\n  const velocity = config.velocity ?? 0\n  const energyThreshold = config.energyThreshold ?? DEFAULT_ENERGY_THRESHOLD\n  const useDuration =\n    config.duration !== undefined || config.dampingRatio !== undefined\n\n  const displacement = from - toValue\n\n  let stiffness: number\n  let zeta: number\n  if (useDuration) {\n    const duration = config.duration ?? DEFAULT_SPRING_DURATION\n    zeta = config.dampingRatio ?? DEFAULT_SPRING_DAMPING_RATIO\n    stiffness =\n      duration <= 0\n        ? Number.POSITIVE_INFINITY\n        : stiffnessForDuration(\n            displacement,\n            velocity,\n            duration,\n            zeta,\n            mass,\n            energyThreshold,\n          )\n  } else {\n    stiffness = config.stiffness ?? DEFAULT_SPRING_STIFFNESS\n    const damping = config.damping ?? DEFAULT_SPRING_DAMPING\n    zeta = damping / (2 * Math.sqrt(stiffness * mass))\n  }\n\n  if (config.clamp) {\n    zeta = zetaForClamp(zeta, displacement, toValue, config.clamp)\n  }\n\n  // A zero/degenerate duration means \"be there already\"; the platform solver\n  // rejects a non-finite stiffness, so collapse it to a 0 ms timing instead.\n  const resolvedStiffness = Number.isFinite(stiffness)\n    ? Math.max(stiffness, Number.EPSILON)\n    : 1e6\n\n  const initialEnergy = energyOf(\n    displacement,\n    velocity,\n    resolvedStiffness,\n    mass,\n  )\n  const restEnergy = energyThreshold * initialEnergy\n\n  return {\n    toValue,\n    mass,\n    stiffness: resolvedStiffness,\n    damping: Math.max(\n      zeta * 2 * Math.sqrt(resolvedStiffness * mass),\n      Number.EPSILON,\n    ),\n    initialVelocity: velocity,\n    overshootClamping: config.overshootClamping ?? false,\n    // Semi-axes of the energy ellipse: |x| where all the remaining energy is\n    // potential, |v| where all of it is kinetic. A spring at rest is inside\n    // both.\n    restDisplacementThreshold: Math.max(\n      Math.sqrt((2 * restEnergy) / resolvedStiffness),\n      Number.MIN_VALUE,\n    ),\n    restSpeedThreshold: Math.max(\n      Math.sqrt((2 * restEnergy) / mass),\n      Number.MIN_VALUE,\n    ),\n  }\n}\n\n// --- building a running animation ---------------------------------------\n\n/**\n * The last value an animation aims at, used by `withRepeat`'s reverse and by\n * `updater-animations.ts` to seed a key that is animating for the first time.\n */\nexport const targetOf = (spec: AnimationSpec): number | null => {\n  switch (spec.kind) {\n    case \"timing\":\n    case \"spring\":\n      return spec.toValue\n    case \"delay\":\n      return targetOf(spec.animation)\n    case \"sequence\": {\n      const last = spec.animations[spec.animations.length - 1]\n      return last ? targetOf(last) : null\n    }\n    case \"repeat\":\n      return targetOf(spec.animation)\n    case \"clamp\":\n      return targetOf(spec.animation)\n    // A decay has no target by construction — where it lands is the result\n    // rather than the input. `withRepeat(withDecay(...))` therefore replays\n    // from the same origin rather than ping-ponging between two.\n    case \"decay\":\n      return null\n  }\n}\n\n/** A copy of `spec` aimed at `toValue`, for a reversed repetition. */\nconst aimedAt = (spec: AnimationSpec, toValue: number): AnimationSpec => {\n  switch (spec.kind) {\n    case \"timing\":\n    case \"spring\":\n      return { ...spec, toValue }\n    case \"delay\":\n      return { ...spec, animation: aimedAt(spec.animation, toValue) }\n    case \"sequence\": {\n      const animations = [...spec.animations]\n      const lastIndex = animations.length - 1\n      const last = animations[lastIndex]\n      if (last) {\n        animations[lastIndex] = aimedAt(last, toValue)\n      }\n      return { ...spec, animations }\n    }\n    case \"repeat\":\n      return { ...spec, animation: aimedAt(spec.animation, toValue) }\n    case \"clamp\":\n      return { ...spec, animation: aimedAt(spec.animation, toValue) }\n    // Nothing to re-aim: see targetOf.\n    case \"decay\":\n      return spec\n  }\n}\n\n/**\n * What makes two descriptors the SAME animation, for a caller that gets a\n * freshly built one on every evaluation and must decide whether to restart.\n *\n * The target and the shape, not object identity and not the whole config: a\n * mapper re-runs whenever anything it read changed, so `withSpring(open.value\n * ? 320 : 0)` produces a new object many times a second while asking for the\n * same animation every time. Config fields that change WHERE the animation\n * ends are in (a `duration`, a decay's `velocity`); ones that only change how\n * it gets there are not, because re-aiming a running animation at the value it\n * is already aimed at is a no-op that costs a restart.\n */\nexport const animationSignature = (spec: AnimationSpec): string => {\n  switch (spec.kind) {\n    case \"timing\":\n      return `timing(${spec.toValue},${spec.config.duration ?? \"\"})`\n    case \"spring\":\n      return `spring(${spec.toValue})`\n    case \"delay\":\n      return `delay(${spec.delayMs},${animationSignature(spec.animation)})`\n    case \"sequence\":\n      return `sequence(${spec.animations.map(animationSignature).join(\";\")})`\n    case \"repeat\":\n      return `repeat(${spec.numberOfReps},${spec.reverse},${animationSignature(spec.animation)})`\n    case \"clamp\":\n      return `clamp(${spec.min},${spec.max},${animationSignature(spec.animation)})`\n    // A decay has no target (targetOf), so its identity is the push it was\n    // given: a new flick is a new animation, the same flick is not.\n    case \"decay\":\n      return `decay(${spec.config.velocity},${spec.config.deceleration})`\n  }\n}\n\nconst callbackOf = (spec: AnimationSpec): AnimationCallback | undefined =>\n  spec.kind === \"timing\" ||\n  spec.kind === \"spring\" ||\n  spec.kind === \"repeat\" ||\n  spec.kind === \"decay\"\n    ? spec.callback\n    : undefined\n\n/**\n * Fires the descriptor's own callback when its animation settles — including\n * when it is cancelled, which reports `finished: false`, as upstream does.\n * Every node carries one, so the per-child callbacks of a `withSequence` and\n * the per-repetition callbacks of a `withRepeat` fire without the caller\n * having to unpick the tree.\n */\nconst reportingTo = (\n  animation: CompositeAnimation,\n  callback: AnimationCallback | undefined,\n  driver: AnimatedValue,\n): CompositeAnimation =>\n  callback\n    ? {\n        start: (onEnd) => {\n          animation.start((result) => {\n            callback(result.finished, driver.__getValue())\n            onEnd?.(result)\n          })\n        },\n        stop: () => animation.stop(),\n        reset: () => animation.reset(),\n      }\n    : animation\n\n/**\n * What a descriptor needs to become a running animation: the platform's\n * Animated api for the animations it already has, and the frame scheduler\n * behind it for the one it does not (`withDecay` — see decay.ts). Both come\n * from the same place, so there is still exactly one clock under this layer.\n */\nexport type AnimationEngine = {\n  api: AnimatedApi\n  scheduler: FrameScheduler\n}\n\nconst buildRepeat = (\n  engine: AnimationEngine,\n  driver: AnimatedValue,\n  spec: RepeatSpec,\n): CompositeAnimation => {\n  let child: CompositeAnimation | null = null\n  let cancelled = false\n\n  return {\n    start(onEnd) {\n      cancelled = false\n      const origin = driver.__getValue()\n      let from = origin\n      let to = targetOf(spec.animation) ?? origin\n      let completed = 0\n\n      const runIteration = (): void => {\n        child = buildAnimation(engine, driver, aimedAt(spec.animation, to))\n        child.start((result) => {\n          if (cancelled || !result.finished) {\n            onEnd?.(result)\n            return\n          }\n          completed += 1\n          if (spec.numberOfReps > 0 && completed >= spec.numberOfReps) {\n            onEnd?.({ finished: true })\n            return\n          }\n          if (spec.reverse) {\n            // Ping-pong: the value is already at `to`, so the next\n            // repetition simply aims back at where this one started.\n            const previousTarget = to\n            to = from\n            from = previousTarget\n          } else {\n            // Replay: snap back to where the repeat began and run again,\n            // which is what upstream's onStart(startValue) amounts to.\n            driver.setValue(from)\n          }\n          runIteration()\n        })\n      }\n\n      runIteration()\n    },\n    stop() {\n      cancelled = true\n      child?.stop()\n    },\n    reset() {\n      child?.reset()\n    },\n  }\n}\n\n/**\n * Turns a descriptor into a running animation on `driver`. Every leaf is one\n * of the platform's own animations, so the whole tree runs off the single\n * injected frame scheduler.\n */\nexport const buildAnimation = (\n  engine: AnimationEngine,\n  driver: AnimatedValue,\n  spec: AnimationSpec,\n): CompositeAnimation => {\n  const { api, scheduler } = engine\n  const build = (): CompositeAnimation => {\n    switch (spec.kind) {\n      case \"timing\":\n        return api.timing(driver, {\n          toValue: spec.toValue,\n          duration: spec.config.duration ?? DEFAULT_TIMING_DURATION,\n          easing: spec.config.easing\n            ? resolveEasing(spec.config.easing)\n            : defaultTimingEasing,\n        })\n      case \"spring\":\n        return api.spring(\n          driver,\n          toPlatformSpringConfig(\n            spec.config,\n            spec.toValue,\n            driver.__getValue(),\n          ),\n        )\n      case \"delay\":\n        return api.sequence([\n          api.delay(spec.delayMs),\n          buildAnimation(engine, driver, spec.animation),\n        ])\n      case \"sequence\":\n        return api.sequence(\n          spec.animations.map((child) => buildAnimation(engine, driver, child)),\n        )\n      case \"repeat\":\n        return buildRepeat(engine, driver, spec)\n      case \"decay\":\n        return createValueAnimation(scheduler, driver, decayStep(spec.config))\n      case \"clamp\":\n        return buildClamp(engine, driver, spec)\n    }\n  }\n  return reportingTo(build(), callbackOf(spec), driver)\n}\n\n/**\n * `withClamp` in full: the inner animation is built on a PRIVATE value and\n * what that value publishes is clipped onto the real driver. Running it\n * un-truncated is the whole behaviour — upstream keeps the clamped animation's\n * own `current` unbounded for exactly this reason — and the private node costs\n * one listener, no extra frame subscription and no second clock, because the\n * inner animation is an ordinary one built by the same function.\n */\nconst buildClamp = (\n  engine: AnimationEngine,\n  driver: AnimatedValue,\n  spec: ClampSpec,\n): CompositeAnimation => {\n  const inner = new engine.api.Value(driver.__getValue())\n  inner.addListener(({ value }) => {\n    const clipped =\n      spec.max !== undefined && value > spec.max\n        ? spec.max\n        : spec.min !== undefined && value < spec.min\n          ? spec.min\n          : value\n    driver.__updateValue(clipped)\n  })\n  return buildAnimation(engine, inner, spec.animation)\n}\n"]}

package/dist/reanimated-compat/color.d.ts

@@ -0,0 +1,28 @@
+/** Upstream's shape: red, green, blue and alpha, each normalised to 0-1. */
+export type ParsedColorArray = [number, number, number, number];
+/** Upstream's `InterpolationOptions`, with upstream's defaults. */
+export type ColorInterpolationOptions = {
+    /** Gamma used for the RGB colour space. Defaults to `2.2`. */
+    gamma?: number;
+    /** Wrap hues the short way round. Defaults to `true`. */
+    useCorrectedHSVInterpolation?: boolean;
+};
+export type ColorSpace = "RGB" | "HSV";
+/** True for a string this platform can turn into a colour. Upstream's contract: numbers are not colours. */
+export declare const isColor: (value: unknown) => value is string;
+/**
+ * A colour as four 0-1 channels. Alpha is quantised to eighths-of-a-percent
+ * (n/255) exactly as upstream's is, because upstream reads it back out of an
+ * 8-bit packed integer and callers compare against those values.
+ */
+export declare const convertToRGBA: (color: unknown) => ParsedColorArray;
+/** The inverse of {@link convertToRGBA}, in upstream's output format. */
+export declare const rgbaArrayToRGBAColor: (rgba: ParsedColorArray) => string;
+/**
+ * Maps `value` from `inputRange` onto a range of colours, returning
+ * `rgba(r, g, b, a)`.
+ *
+ * Outside `inputRange` the result is clamped to the nearest end, as upstream
+ * does — colour has no meaningful extrapolation.
+ */
+export declare const interpolateColor: (value: number, inputRange: readonly number[], outputRange: readonly string[], colorSpace?: ColorSpace, options?: ColorInterpolationOptions) => string;