@nulogy/components 16.1.0 → 17.0.0

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/inertia.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inertia.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/inertia.mjs"],"sourcesContent":["import { spring } from './spring/index.mjs';\nimport { calcGeneratorVelocity } from './utils/velocity.mjs';\n\nfunction inertia({ keyframes, velocity = 0.0, power = 0.8, timeConstant = 325, bounceDamping = 10, bounceStiffness = 500, modifyTarget, min, max, restDelta = 0.5, restSpeed, }) {\n    const origin = keyframes[0];\n    const state = {\n        done: false,\n        value: origin,\n    };\n    const isOutOfBounds = (v) => (min !== undefined && v < min) || (max !== undefined && v > max);\n    const nearestBoundary = (v) => {\n        if (min === undefined)\n            return max;\n        if (max === undefined)\n            return min;\n        return Math.abs(min - v) < Math.abs(max - v) ? min : max;\n    };\n    let amplitude = power * velocity;\n    const ideal = origin + amplitude;\n    const target = modifyTarget === undefined ? ideal : modifyTarget(ideal);\n    /**\n     * If the target has changed we need to re-calculate the amplitude, otherwise\n     * the animation will start from the wrong position.\n     */\n    if (target !== ideal)\n        amplitude = target - origin;\n    const calcDelta = (t) => -amplitude * Math.exp(-t / timeConstant);\n    const calcLatest = (t) => target + calcDelta(t);\n    const applyFriction = (t) => {\n        const delta = calcDelta(t);\n        const latest = calcLatest(t);\n        state.done = Math.abs(delta) <= restDelta;\n        state.value = state.done ? target : latest;\n    };\n    /**\n     * Ideally this would resolve for t in a stateless way, we could\n     * do that by always precalculating the animation but as we know\n     * this will be done anyway we can assume that spring will\n     * be discovered during that.\n     */\n    let timeReachedBoundary;\n    let spring$1;\n    const checkCatchBoundary = (t) => {\n        if (!isOutOfBounds(state.value))\n            return;\n        timeReachedBoundary = t;\n        spring$1 = spring({\n            keyframes: [state.value, nearestBoundary(state.value)],\n            velocity: calcGeneratorVelocity(calcLatest, t, state.value), // TODO: This should be passing * 1000\n            damping: bounceDamping,\n            stiffness: bounceStiffness,\n            restDelta,\n            restSpeed,\n        });\n    };\n    checkCatchBoundary(0);\n    return {\n        calculatedDuration: null,\n        next: (t) => {\n            /**\n             * We need to resolve the friction to figure out if we need a\n             * spring but we don't want to do this twice per frame. So here\n             * we flag if we updated for this frame and later if we did\n             * we can skip doing it again.\n             */\n            let hasUpdatedFrame = false;\n            if (!spring$1 && timeReachedBoundary === undefined) {\n                hasUpdatedFrame = true;\n                applyFriction(t);\n                checkCatchBoundary(t);\n            }\n            /**\n             * If we have a spring and the provided t is beyond the moment the friction\n             * animation crossed the min/max boundary, use the spring.\n             */\n            if (timeReachedBoundary !== undefined && t >= timeReachedBoundary) {\n                return spring$1.next(t - timeReachedBoundary);\n            }\n            else {\n                !hasUpdatedFrame && applyFriction(t);\n                return state;\n            }\n        },\n    };\n}\n\nexport { inertia };\n//# sourceMappingURL=inertia.mjs.map\n"],"names":[],"mappings":";;AAGA,SAAS,QAAQ,EAAE,WAAW,WAAW,GAAK,QAAQ,KAAK,eAAe,KAAK,gBAAgB,IAAI,kBAAkB,KAAK,cAAc,KAAK,KAAK,YAAY,KAAK,aAAc;AAC7K,QAAM,SAAS,UAAU,CAAC;AAC1B,QAAM,QAAQ;AAAA,IACV,MAAM;AAAA,IACN,OAAO;AAAA,EACf;AACI,QAAM,gBAAgB,CAAC,MAAO,QAAQ,UAAa,IAAI,OAAS,QAAQ,UAAa,IAAI;AACzF,QAAM,kBAAkB,CAAC,MAAM;AAC3B,QAAI,QAAQ;AACR,aAAO;AACX,QAAI,QAAQ;AACR,aAAO;AACX,WAAO,KAAK,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,MAAM,CAAC,IAAI,MAAM;AAAA,EACzD;AACA,MAAI,YAAY,QAAQ;AACxB,QAAM,QAAQ,SAAS;AACvB,QAAM,SAAS,iBAAiB,SAAY,QAAQ,aAAa,KAAK;AAKtE,MAAI,WAAW;AACX,gBAAY,SAAS;AACzB,QAAM,YAAY,CAAC,MAAM,CAAC,YAAY,KAAK,IAAI,CAAC,IAAI,YAAY;AAChE,QAAM,aAAa,CAAC,MAAM,SAAS,UAAU,CAAC;AAC9C,QAAM,gBAAgB,CAAC,MAAM;AACzB,UAAM,QAAQ,UAAU,CAAC;AACzB,UAAM,SAAS,WAAW,CAAC;AAC3B,UAAM,OAAO,KAAK,IAAI,KAAK,KAAK;AAChC,UAAM,QAAQ,MAAM,OAAO,SAAS;AAAA,EACxC;AAOA,MAAI;AACJ,MAAI;AACJ,QAAM,qBAAqB,CAAC,MAAM;AAC9B,QAAI,CAAC,cAAc,MAAM,KAAK;AAC1B;AACJ,0BAAsB;AACtB,eAAW,OAAO;AAAA,MACd,WAAW,CAAC,MAAM,OAAO,gBAAgB,MAAM,KAAK,CAAC;AAAA,MACrD,UAAU,sBAAsB,YAAY,GAAG,MAAM,KAAK;AAAA;AAAA,MAC1D,SAAS;AAAA,MACT,WAAW;AAAA,MACX;AAAA,MACA;AAAA,IACZ,CAAS;AAAA,EACL;AACA,qBAAmB,CAAC;AACpB,SAAO;AAAA,IACH,oBAAoB;AAAA,IACpB,MAAM,CAAC,MAAM;AAOT,UAAI,kBAAkB;AACtB,UAAI,CAAC,YAAY,wBAAwB,QAAW;AAChD,0BAAkB;AAClB,sBAAc,CAAC;AACf,2BAAmB,CAAC;AAAA,MACxB;AAKA,UAAI,wBAAwB,UAAa,KAAK,qBAAqB;AAC/D,eAAO,SAAS,KAAK,IAAI,mBAAmB;AAAA,MAChD,OACK;AACD,SAAC,mBAAmB,cAAc,CAAC;AACnC,eAAO;AAAA,MACX;AAAA,IACJ;AAAA,EACR;AACA;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/keyframes.js

@@ -0,0 +1,38 @@
+import { interpolate } from "../../utils/interpolate.js";
+import { defaultOffset } from "../keyframes/offsets/default.js";
+import { convertOffsetToTimes } from "../keyframes/offsets/time.js";
+import { isEasingArray } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/easing/utils/is-easing-array.js";
+import { easingDefinitionToFunction } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/easing/utils/map.js";
+import { easeInOut } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/easing/ease.js";
+function defaultEasing(values, easing) {
+  return values.map(() => easing || easeInOut).splice(0, values.length - 1);
+}
+function keyframes({ duration = 300, keyframes: keyframeValues, times, ease = "easeInOut" }) {
+  const easingFunctions = isEasingArray(ease) ? ease.map(easingDefinitionToFunction) : easingDefinitionToFunction(ease);
+  const state = {
+    done: false,
+    value: keyframeValues[0]
+  };
+  const absoluteTimes = convertOffsetToTimes(
+    // Only use the provided offsets if they're the correct length
+    // TODO Maybe we should warn here if there's a length mismatch
+    times && times.length === keyframeValues.length ? times : defaultOffset(keyframeValues),
+    duration
+  );
+  const mapTimeToKeyframe = interpolate(absoluteTimes, keyframeValues, {
+    ease: Array.isArray(easingFunctions) ? easingFunctions : defaultEasing(keyframeValues, easingFunctions)
+  });
+  return {
+    calculatedDuration: duration,
+    next: (t) => {
+      state.value = mapTimeToKeyframe(t);
+      state.done = t >= duration;
+      return state;
+    }
+  };
+}
+export {
+  defaultEasing,
+  keyframes
+};
+//# sourceMappingURL=keyframes.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/keyframes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyframes.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/keyframes.mjs"],"sourcesContent":["import { easeInOut, isEasingArray, easingDefinitionToFunction } from 'motion-utils';\nimport { interpolate } from '../../utils/interpolate.mjs';\nimport { defaultOffset } from '../keyframes/offsets/default.mjs';\nimport { convertOffsetToTimes } from '../keyframes/offsets/time.mjs';\n\nfunction defaultEasing(values, easing) {\n    return values.map(() => easing || easeInOut).splice(0, values.length - 1);\n}\nfunction keyframes({ duration = 300, keyframes: keyframeValues, times, ease = \"easeInOut\", }) {\n    /**\n     * Easing functions can be externally defined as strings. Here we convert them\n     * into actual functions.\n     */\n    const easingFunctions = isEasingArray(ease)\n        ? ease.map(easingDefinitionToFunction)\n        : easingDefinitionToFunction(ease);\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = {\n        done: false,\n        value: keyframeValues[0],\n    };\n    /**\n     * Create a times array based on the provided 0-1 offsets\n     */\n    const absoluteTimes = convertOffsetToTimes(\n    // Only use the provided offsets if they're the correct length\n    // TODO Maybe we should warn here if there's a length mismatch\n    times && times.length === keyframeValues.length\n        ? times\n        : defaultOffset(keyframeValues), duration);\n    const mapTimeToKeyframe = interpolate(absoluteTimes, keyframeValues, {\n        ease: Array.isArray(easingFunctions)\n            ? easingFunctions\n            : defaultEasing(keyframeValues, easingFunctions),\n    });\n    return {\n        calculatedDuration: duration,\n        next: (t) => {\n            state.value = mapTimeToKeyframe(t);\n            state.done = t >= duration;\n            return state;\n        },\n    };\n}\n\nexport { defaultEasing, keyframes };\n//# sourceMappingURL=keyframes.mjs.map\n"],"names":[],"mappings":";;;;;;AAKA,SAAS,cAAc,QAAQ,QAAQ;AACnC,SAAO,OAAO,IAAI,MAAM,UAAU,SAAS,EAAE,OAAO,GAAG,OAAO,SAAS,CAAC;AAC5E;AACA,SAAS,UAAU,EAAE,WAAW,KAAK,WAAW,gBAAgB,OAAO,OAAO,eAAgB;AAK1F,QAAM,kBAAkB,cAAc,IAAI,IACpC,KAAK,IAAI,0BAA0B,IACnC,2BAA2B,IAAI;AAKrC,QAAM,QAAQ;AAAA,IACV,MAAM;AAAA,IACN,OAAO,eAAe,CAAC;AAAA,EAC/B;AAII,QAAM,gBAAgB;AAAA;AAAA;AAAA,IAGtB,SAAS,MAAM,WAAW,eAAe,SACnC,QACA,cAAc,cAAc;AAAA,IAAG;AAAA,EAAQ;AAC7C,QAAM,oBAAoB,YAAY,eAAe,gBAAgB;AAAA,IACjE,MAAM,MAAM,QAAQ,eAAe,IAC7B,kBACA,cAAc,gBAAgB,eAAe;AAAA,EAC3D,CAAK;AACD,SAAO;AAAA,IACH,oBAAoB;AAAA,IACpB,MAAM,CAAC,MAAM;AACT,YAAM,QAAQ,kBAAkB,CAAC;AACjC,YAAM,OAAO,KAAK;AAClB,aAAO;AAAA,IACX;AAAA,EACR;AACA;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/spring/defaults.js

@@ -0,0 +1,33 @@
+const springDefaults = {
+  // Default spring physics
+  stiffness: 100,
+  damping: 10,
+  mass: 1,
+  velocity: 0,
+  // Default duration/bounce-based options
+  duration: 800,
+  // in ms
+  bounce: 0.3,
+  visualDuration: 0.3,
+  // in seconds
+  // Rest thresholds
+  restSpeed: {
+    granular: 0.01,
+    default: 2
+  },
+  restDelta: {
+    granular: 5e-3,
+    default: 0.5
+  },
+  // Limits
+  minDuration: 0.01,
+  // in seconds
+  maxDuration: 10,
+  // in seconds
+  minDamping: 0.05,
+  maxDamping: 1
+};
+export {
+  springDefaults
+};
+//# sourceMappingURL=defaults.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/spring/defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/spring/defaults.mjs"],"sourcesContent":["const springDefaults = {\n    // Default spring physics\n    stiffness: 100,\n    damping: 10,\n    mass: 1.0,\n    velocity: 0.0,\n    // Default duration/bounce-based options\n    duration: 800, // in ms\n    bounce: 0.3,\n    visualDuration: 0.3, // in seconds\n    // Rest thresholds\n    restSpeed: {\n        granular: 0.01,\n        default: 2,\n    },\n    restDelta: {\n        granular: 0.005,\n        default: 0.5,\n    },\n    // Limits\n    minDuration: 0.01, // in seconds\n    maxDuration: 10.0, // in seconds\n    minDamping: 0.05,\n    maxDamping: 1,\n};\n\nexport { springDefaults };\n//# sourceMappingURL=defaults.mjs.map\n"],"names":[],"mappings":"AAAK,MAAC,iBAAiB;AAAA;AAAA,EAEnB,WAAW;AAAA,EACX,SAAS;AAAA,EACT,MAAM;AAAA,EACN,UAAU;AAAA;AAAA,EAEV,UAAU;AAAA;AAAA,EACV,QAAQ;AAAA,EACR,gBAAgB;AAAA;AAAA;AAAA,EAEhB,WAAW;AAAA,IACP,UAAU;AAAA,IACV,SAAS;AAAA,EACjB;AAAA,EACI,WAAW;AAAA,IACP,UAAU;AAAA,IACV,SAAS;AAAA,EACjB;AAAA;AAAA,EAEI,aAAa;AAAA;AAAA,EACb,aAAa;AAAA;AAAA,EACb,YAAY;AAAA,EACZ,YAAY;AAChB;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/spring/find.js

@@ -0,0 +1,75 @@
+import { springDefaults } from "./defaults.js";
+import { clamp } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/clamp.js";
+import { millisecondsToSeconds, secondsToMilliseconds } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/time-conversion.js";
+const safeMin = 1e-3;
+function findSpring({ duration = springDefaults.duration, bounce = springDefaults.bounce, velocity = springDefaults.velocity, mass = springDefaults.mass }) {
+  let envelope;
+  let derivative;
+  let dampingRatio = 1 - bounce;
+  dampingRatio = clamp(springDefaults.minDamping, springDefaults.maxDamping, dampingRatio);
+  duration = clamp(springDefaults.minDuration, springDefaults.maxDuration, millisecondsToSeconds(duration));
+  if (dampingRatio < 1) {
+    envelope = (undampedFreq2) => {
+      const exponentialDecay = undampedFreq2 * dampingRatio;
+      const delta = exponentialDecay * duration;
+      const a = exponentialDecay - velocity;
+      const b = calcAngularFreq(undampedFreq2, dampingRatio);
+      const c = Math.exp(-delta);
+      return safeMin - a / b * c;
+    };
+    derivative = (undampedFreq2) => {
+      const exponentialDecay = undampedFreq2 * dampingRatio;
+      const delta = exponentialDecay * duration;
+      const d = delta * velocity + velocity;
+      const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq2, 2) * duration;
+      const f = Math.exp(-delta);
+      const g = calcAngularFreq(Math.pow(undampedFreq2, 2), dampingRatio);
+      const factor = -envelope(undampedFreq2) + safeMin > 0 ? -1 : 1;
+      return factor * ((d - e) * f) / g;
+    };
+  } else {
+    envelope = (undampedFreq2) => {
+      const a = Math.exp(-undampedFreq2 * duration);
+      const b = (undampedFreq2 - velocity) * duration + 1;
+      return -safeMin + a * b;
+    };
+    derivative = (undampedFreq2) => {
+      const a = Math.exp(-undampedFreq2 * duration);
+      const b = (velocity - undampedFreq2) * (duration * duration);
+      return a * b;
+    };
+  }
+  const initialGuess = 5 / duration;
+  const undampedFreq = approximateRoot(envelope, derivative, initialGuess);
+  duration = secondsToMilliseconds(duration);
+  if (isNaN(undampedFreq)) {
+    return {
+      stiffness: springDefaults.stiffness,
+      damping: springDefaults.damping,
+      duration
+    };
+  } else {
+    const stiffness = Math.pow(undampedFreq, 2) * mass;
+    return {
+      stiffness,
+      damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),
+      duration
+    };
+  }
+}
+const rootIterations = 12;
+function approximateRoot(envelope, derivative, initialGuess) {
+  let result = initialGuess;
+  for (let i = 1; i < rootIterations; i++) {
+    result = result - envelope(result) / derivative(result);
+  }
+  return result;
+}
+function calcAngularFreq(undampedFreq, dampingRatio) {
+  return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);
+}
+export {
+  calcAngularFreq,
+  findSpring
+};
+//# sourceMappingURL=find.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/spring/find.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"find.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/spring/find.mjs"],"sourcesContent":["import { warning, secondsToMilliseconds, clamp, millisecondsToSeconds } from 'motion-utils';\nimport { springDefaults } from './defaults.mjs';\n\nconst safeMin = 0.001;\nfunction findSpring({ duration = springDefaults.duration, bounce = springDefaults.bounce, velocity = springDefaults.velocity, mass = springDefaults.mass, }) {\n    let envelope;\n    let derivative;\n    warning(duration <= secondsToMilliseconds(springDefaults.maxDuration), \"Spring duration must be 10 seconds or less\", \"spring-duration-limit\");\n    let dampingRatio = 1 - bounce;\n    /**\n     * Restrict dampingRatio and duration to within acceptable ranges.\n     */\n    dampingRatio = clamp(springDefaults.minDamping, springDefaults.maxDamping, dampingRatio);\n    duration = clamp(springDefaults.minDuration, springDefaults.maxDuration, millisecondsToSeconds(duration));\n    if (dampingRatio < 1) {\n        /**\n         * Underdamped spring\n         */\n        envelope = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const a = exponentialDecay - velocity;\n            const b = calcAngularFreq(undampedFreq, dampingRatio);\n            const c = Math.exp(-delta);\n            return safeMin - (a / b) * c;\n        };\n        derivative = (undampedFreq) => {\n            const exponentialDecay = undampedFreq * dampingRatio;\n            const delta = exponentialDecay * duration;\n            const d = delta * velocity + velocity;\n            const e = Math.pow(dampingRatio, 2) * Math.pow(undampedFreq, 2) * duration;\n            const f = Math.exp(-delta);\n            const g = calcAngularFreq(Math.pow(undampedFreq, 2), dampingRatio);\n            const factor = -envelope(undampedFreq) + safeMin > 0 ? -1 : 1;\n            return (factor * ((d - e) * f)) / g;\n        };\n    }\n    else {\n        /**\n         * Critically-damped spring\n         */\n        envelope = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (undampedFreq - velocity) * duration + 1;\n            return -safeMin + a * b;\n        };\n        derivative = (undampedFreq) => {\n            const a = Math.exp(-undampedFreq * duration);\n            const b = (velocity - undampedFreq) * (duration * duration);\n            return a * b;\n        };\n    }\n    const initialGuess = 5 / duration;\n    const undampedFreq = approximateRoot(envelope, derivative, initialGuess);\n    duration = secondsToMilliseconds(duration);\n    if (isNaN(undampedFreq)) {\n        return {\n            stiffness: springDefaults.stiffness,\n            damping: springDefaults.damping,\n            duration,\n        };\n    }\n    else {\n        const stiffness = Math.pow(undampedFreq, 2) * mass;\n        return {\n            stiffness,\n            damping: dampingRatio * 2 * Math.sqrt(mass * stiffness),\n            duration,\n        };\n    }\n}\nconst rootIterations = 12;\nfunction approximateRoot(envelope, derivative, initialGuess) {\n    let result = initialGuess;\n    for (let i = 1; i < rootIterations; i++) {\n        result = result - envelope(result) / derivative(result);\n    }\n    return result;\n}\nfunction calcAngularFreq(undampedFreq, dampingRatio) {\n    return undampedFreq * Math.sqrt(1 - dampingRatio * dampingRatio);\n}\n\nexport { calcAngularFreq, findSpring };\n//# sourceMappingURL=find.mjs.map\n"],"names":["undampedFreq"],"mappings":";;;AAGA,MAAM,UAAU;AAChB,SAAS,WAAW,EAAE,WAAW,eAAe,UAAU,SAAS,eAAe,QAAQ,WAAW,eAAe,UAAU,OAAO,eAAe,KAAI,GAAK;AACzJ,MAAI;AACJ,MAAI;AAEJ,MAAI,eAAe,IAAI;AAIvB,iBAAe,MAAM,eAAe,YAAY,eAAe,YAAY,YAAY;AACvF,aAAW,MAAM,eAAe,aAAa,eAAe,aAAa,sBAAsB,QAAQ,CAAC;AACxG,MAAI,eAAe,GAAG;AAIlB,eAAW,CAACA,kBAAiB;AACzB,YAAM,mBAAmBA,gBAAe;AACxC,YAAM,QAAQ,mBAAmB;AACjC,YAAM,IAAI,mBAAmB;AAC7B,YAAM,IAAI,gBAAgBA,eAAc,YAAY;AACpD,YAAM,IAAI,KAAK,IAAI,CAAC,KAAK;AACzB,aAAO,UAAW,IAAI,IAAK;AAAA,IAC/B;AACA,iBAAa,CAACA,kBAAiB;AAC3B,YAAM,mBAAmBA,gBAAe;AACxC,YAAM,QAAQ,mBAAmB;AACjC,YAAM,IAAI,QAAQ,WAAW;AAC7B,YAAM,IAAI,KAAK,IAAI,cAAc,CAAC,IAAI,KAAK,IAAIA,eAAc,CAAC,IAAI;AAClE,YAAM,IAAI,KAAK,IAAI,CAAC,KAAK;AACzB,YAAM,IAAI,gBAAgB,KAAK,IAAIA,eAAc,CAAC,GAAG,YAAY;AACjE,YAAM,SAAS,CAAC,SAASA,aAAY,IAAI,UAAU,IAAI,KAAK;AAC5D,aAAQ,WAAW,IAAI,KAAK,KAAM;AAAA,IACtC;AAAA,EACJ,OACK;AAID,eAAW,CAACA,kBAAiB;AACzB,YAAM,IAAI,KAAK,IAAI,CAACA,gBAAe,QAAQ;AAC3C,YAAM,KAAKA,gBAAe,YAAY,WAAW;AACjD,aAAO,CAAC,UAAU,IAAI;AAAA,IAC1B;AACA,iBAAa,CAACA,kBAAiB;AAC3B,YAAM,IAAI,KAAK,IAAI,CAACA,gBAAe,QAAQ;AAC3C,YAAM,KAAK,WAAWA,kBAAiB,WAAW;AAClD,aAAO,IAAI;AAAA,IACf;AAAA,EACJ;AACA,QAAM,eAAe,IAAI;AACzB,QAAM,eAAe,gBAAgB,UAAU,YAAY,YAAY;AACvE,aAAW,sBAAsB,QAAQ;AACzC,MAAI,MAAM,YAAY,GAAG;AACrB,WAAO;AAAA,MACH,WAAW,eAAe;AAAA,MAC1B,SAAS,eAAe;AAAA,MACxB;AAAA,IACZ;AAAA,EACI,OACK;AACD,UAAM,YAAY,KAAK,IAAI,cAAc,CAAC,IAAI;AAC9C,WAAO;AAAA,MACH;AAAA,MACA,SAAS,eAAe,IAAI,KAAK,KAAK,OAAO,SAAS;AAAA,MACtD;AAAA,IACZ;AAAA,EACI;AACJ;AACA,MAAM,iBAAiB;AACvB,SAAS,gBAAgB,UAAU,YAAY,cAAc;AACzD,MAAI,SAAS;AACb,WAAS,IAAI,GAAG,IAAI,gBAAgB,KAAK;AACrC,aAAS,SAAS,SAAS,MAAM,IAAI,WAAW,MAAM;AAAA,EAC1D;AACA,SAAO;AACX;AACA,SAAS,gBAAgB,cAAc,cAAc;AACjD,SAAO,eAAe,KAAK,KAAK,IAAI,eAAe,YAAY;AACnE;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/spring/index.js

@@ -0,0 +1,124 @@
+import { generateLinearEasing } from "../../waapi/utils/linear.js";
+import { calcGeneratorDuration, maxGeneratorDuration } from "../utils/calc-duration.js";
+import { createGeneratorEasing } from "../utils/create-generator-easing.js";
+import { calcGeneratorVelocity } from "../utils/velocity.js";
+import { springDefaults } from "./defaults.js";
+import { findSpring, calcAngularFreq } from "./find.js";
+import { millisecondsToSeconds, secondsToMilliseconds } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/time-conversion.js";
+import { clamp } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/clamp.js";
+const durationKeys = ["duration", "bounce"];
+const physicsKeys = ["stiffness", "damping", "mass"];
+function isSpringType(options, keys) {
+  return keys.some((key) => options[key] !== void 0);
+}
+function getSpringOptions(options) {
+  let springOptions = {
+    velocity: springDefaults.velocity,
+    stiffness: springDefaults.stiffness,
+    damping: springDefaults.damping,
+    mass: springDefaults.mass,
+    isResolvedFromDuration: false,
+    ...options
+  };
+  if (!isSpringType(options, physicsKeys) && isSpringType(options, durationKeys)) {
+    springOptions.velocity = 0;
+    if (options.visualDuration) {
+      const visualDuration = options.visualDuration;
+      const root = 2 * Math.PI / (visualDuration * 1.2);
+      const stiffness = root * root;
+      const damping = 2 * clamp(0.05, 1, 1 - (options.bounce || 0)) * Math.sqrt(stiffness);
+      springOptions = {
+        ...springOptions,
+        mass: springDefaults.mass,
+        stiffness,
+        damping
+      };
+    } else {
+      const derived = findSpring({ ...options, velocity: 0 });
+      springOptions = {
+        ...springOptions,
+        ...derived,
+        mass: springDefaults.mass
+      };
+      springOptions.isResolvedFromDuration = true;
+    }
+  }
+  return springOptions;
+}
+function spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce = springDefaults.bounce) {
+  const options = typeof optionsOrVisualDuration !== "object" ? {
+    visualDuration: optionsOrVisualDuration,
+    keyframes: [0, 1],
+    bounce
+  } : optionsOrVisualDuration;
+  let { restSpeed, restDelta } = options;
+  const origin = options.keyframes[0];
+  const target = options.keyframes[options.keyframes.length - 1];
+  const state = { done: false, value: origin };
+  const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration } = getSpringOptions({
+    ...options,
+    velocity: -millisecondsToSeconds(options.velocity || 0)
+  });
+  const initialVelocity = velocity || 0;
+  const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));
+  const initialDelta = target - origin;
+  const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));
+  const isGranularScale = Math.abs(initialDelta) < 5;
+  restSpeed || (restSpeed = isGranularScale ? springDefaults.restSpeed.granular : springDefaults.restSpeed.default);
+  restDelta || (restDelta = isGranularScale ? springDefaults.restDelta.granular : springDefaults.restDelta.default);
+  let resolveSpring;
+  if (dampingRatio < 1) {
+    const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);
+    resolveSpring = (t) => {
+      const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
+      return target - envelope * ((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) / angularFreq * Math.sin(angularFreq * t) + initialDelta * Math.cos(angularFreq * t));
+    };
+  } else if (dampingRatio === 1) {
+    resolveSpring = (t) => target - Math.exp(-undampedAngularFreq * t) * (initialDelta + (initialVelocity + undampedAngularFreq * initialDelta) * t);
+  } else {
+    const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);
+    resolveSpring = (t) => {
+      const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);
+      const freqForT = Math.min(dampedAngularFreq * t, 300);
+      return target - envelope * ((initialVelocity + dampingRatio * undampedAngularFreq * initialDelta) * Math.sinh(freqForT) + dampedAngularFreq * initialDelta * Math.cosh(freqForT)) / dampedAngularFreq;
+    };
+  }
+  const generator = {
+    calculatedDuration: isResolvedFromDuration ? duration || null : null,
+    next: (t) => {
+      const current = resolveSpring(t);
+      if (!isResolvedFromDuration) {
+        let currentVelocity = t === 0 ? initialVelocity : 0;
+        if (dampingRatio < 1) {
+          currentVelocity = t === 0 ? secondsToMilliseconds(initialVelocity) : calcGeneratorVelocity(resolveSpring, t, current);
+        }
+        const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;
+        const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;
+        state.done = isBelowVelocityThreshold && isBelowDisplacementThreshold;
+      } else {
+        state.done = t >= duration;
+      }
+      state.value = state.done ? target : current;
+      return state;
+    },
+    toString: () => {
+      const calculatedDuration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
+      const easing = generateLinearEasing((progress) => generator.next(calculatedDuration * progress).value, calculatedDuration, 30);
+      return calculatedDuration + "ms " + easing;
+    },
+    toTransition: () => {
+    }
+  };
+  return generator;
+}
+spring.applyToOptions = (options) => {
+  const generatorOptions = createGeneratorEasing(options, 100, spring);
+  options.ease = generatorOptions.ease;
+  options.duration = secondsToMilliseconds(generatorOptions.duration);
+  options.type = "keyframes";
+  return options;
+};
+export {
+  spring
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/spring/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/spring/index.mjs"],"sourcesContent":["import { millisecondsToSeconds, clamp, secondsToMilliseconds } from 'motion-utils';\nimport { generateLinearEasing } from '../../waapi/utils/linear.mjs';\nimport { calcGeneratorDuration, maxGeneratorDuration } from '../utils/calc-duration.mjs';\nimport { createGeneratorEasing } from '../utils/create-generator-easing.mjs';\nimport { calcGeneratorVelocity } from '../utils/velocity.mjs';\nimport { springDefaults } from './defaults.mjs';\nimport { findSpring, calcAngularFreq } from './find.mjs';\n\nconst durationKeys = [\"duration\", \"bounce\"];\nconst physicsKeys = [\"stiffness\", \"damping\", \"mass\"];\nfunction isSpringType(options, keys) {\n    return keys.some((key) => options[key] !== undefined);\n}\nfunction getSpringOptions(options) {\n    let springOptions = {\n        velocity: springDefaults.velocity,\n        stiffness: springDefaults.stiffness,\n        damping: springDefaults.damping,\n        mass: springDefaults.mass,\n        isResolvedFromDuration: false,\n        ...options,\n    };\n    // stiffness/damping/mass overrides duration/bounce\n    if (!isSpringType(options, physicsKeys) &&\n        isSpringType(options, durationKeys)) {\n        // Time-defined springs should ignore inherited velocity.\n        // Velocity from interrupted animations can cause findSpring()\n        // to compute wildly different spring parameters, leading to\n        // massive oscillation on small-range animations.\n        springOptions.velocity = 0;\n        if (options.visualDuration) {\n            const visualDuration = options.visualDuration;\n            const root = (2 * Math.PI) / (visualDuration * 1.2);\n            const stiffness = root * root;\n            const damping = 2 *\n                clamp(0.05, 1, 1 - (options.bounce || 0)) *\n                Math.sqrt(stiffness);\n            springOptions = {\n                ...springOptions,\n                mass: springDefaults.mass,\n                stiffness,\n                damping,\n            };\n        }\n        else {\n            const derived = findSpring({ ...options, velocity: 0 });\n            springOptions = {\n                ...springOptions,\n                ...derived,\n                mass: springDefaults.mass,\n            };\n            springOptions.isResolvedFromDuration = true;\n        }\n    }\n    return springOptions;\n}\nfunction spring(optionsOrVisualDuration = springDefaults.visualDuration, bounce = springDefaults.bounce) {\n    const options = typeof optionsOrVisualDuration !== \"object\"\n        ? {\n            visualDuration: optionsOrVisualDuration,\n            keyframes: [0, 1],\n            bounce,\n        }\n        : optionsOrVisualDuration;\n    let { restSpeed, restDelta } = options;\n    const origin = options.keyframes[0];\n    const target = options.keyframes[options.keyframes.length - 1];\n    /**\n     * This is the Iterator-spec return value. We ensure it's mutable rather than using a generator\n     * to reduce GC during animation.\n     */\n    const state = { done: false, value: origin };\n    const { stiffness, damping, mass, duration, velocity, isResolvedFromDuration, } = getSpringOptions({\n        ...options,\n        velocity: -millisecondsToSeconds(options.velocity || 0),\n    });\n    const initialVelocity = velocity || 0.0;\n    const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));\n    const initialDelta = target - origin;\n    const undampedAngularFreq = millisecondsToSeconds(Math.sqrt(stiffness / mass));\n    /**\n     * If we're working on a granular scale, use smaller defaults for determining\n     * when the spring is finished.\n     *\n     * These defaults have been selected emprically based on what strikes a good\n     * ratio between feeling good and finishing as soon as changes are imperceptible.\n     */\n    const isGranularScale = Math.abs(initialDelta) < 5;\n    restSpeed || (restSpeed = isGranularScale\n        ? springDefaults.restSpeed.granular\n        : springDefaults.restSpeed.default);\n    restDelta || (restDelta = isGranularScale\n        ? springDefaults.restDelta.granular\n        : springDefaults.restDelta.default);\n    let resolveSpring;\n    if (dampingRatio < 1) {\n        const angularFreq = calcAngularFreq(undampedAngularFreq, dampingRatio);\n        // Underdamped spring\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            return (target -\n                envelope *\n                    (((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) /\n                        angularFreq) *\n                        Math.sin(angularFreq * t) +\n                        initialDelta * Math.cos(angularFreq * t)));\n        };\n    }\n    else if (dampingRatio === 1) {\n        // Critically damped spring\n        resolveSpring = (t) => target -\n            Math.exp(-undampedAngularFreq * t) *\n                (initialDelta +\n                    (initialVelocity + undampedAngularFreq * initialDelta) * t);\n    }\n    else {\n        // Overdamped spring\n        const dampedAngularFreq = undampedAngularFreq * Math.sqrt(dampingRatio * dampingRatio - 1);\n        resolveSpring = (t) => {\n            const envelope = Math.exp(-dampingRatio * undampedAngularFreq * t);\n            // When performing sinh or cosh values can hit Infinity so we cap them here\n            const freqForT = Math.min(dampedAngularFreq * t, 300);\n            return (target -\n                (envelope *\n                    ((initialVelocity +\n                        dampingRatio * undampedAngularFreq * initialDelta) *\n                        Math.sinh(freqForT) +\n                        dampedAngularFreq *\n                            initialDelta *\n                            Math.cosh(freqForT))) /\n                    dampedAngularFreq);\n        };\n    }\n    const generator = {\n        calculatedDuration: isResolvedFromDuration ? duration || null : null,\n        next: (t) => {\n            const current = resolveSpring(t);\n            if (!isResolvedFromDuration) {\n                let currentVelocity = t === 0 ? initialVelocity : 0.0;\n                /**\n                 * We only need to calculate velocity for under-damped springs\n                 * as over- and critically-damped springs can't overshoot, so\n                 * checking only for displacement is enough.\n                 */\n                if (dampingRatio < 1) {\n                    currentVelocity =\n                        t === 0\n                            ? secondsToMilliseconds(initialVelocity)\n                            : calcGeneratorVelocity(resolveSpring, t, current);\n                }\n                const isBelowVelocityThreshold = Math.abs(currentVelocity) <= restSpeed;\n                const isBelowDisplacementThreshold = Math.abs(target - current) <= restDelta;\n                state.done =\n                    isBelowVelocityThreshold && isBelowDisplacementThreshold;\n            }\n            else {\n                state.done = t >= duration;\n            }\n            state.value = state.done ? target : current;\n            return state;\n        },\n        toString: () => {\n            const calculatedDuration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);\n            const easing = generateLinearEasing((progress) => generator.next(calculatedDuration * progress).value, calculatedDuration, 30);\n            return calculatedDuration + \"ms \" + easing;\n        },\n        toTransition: () => { },\n    };\n    return generator;\n}\nspring.applyToOptions = (options) => {\n    const generatorOptions = createGeneratorEasing(options, 100, spring);\n    options.ease = generatorOptions.ease;\n    options.duration = secondsToMilliseconds(generatorOptions.duration);\n    options.type = \"keyframes\";\n    return options;\n};\n\nexport { spring };\n//# sourceMappingURL=index.mjs.map\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.js

@@ -0,0 +1,16 @@
+const maxGeneratorDuration = 2e4;
+function calcGeneratorDuration(generator) {
+  let duration = 0;
+  const timeStep = 50;
+  let state = generator.next(duration);
+  while (!state.done && duration < maxGeneratorDuration) {
+    duration += timeStep;
+    state = generator.next(duration);
+  }
+  return duration >= maxGeneratorDuration ? Infinity : duration;
+}
+export {
+  calcGeneratorDuration,
+  maxGeneratorDuration
+};
+//# sourceMappingURL=calc-duration.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"calc-duration.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/utils/calc-duration.mjs"],"sourcesContent":["/**\n * Implement a practical max duration for keyframe generation\n * to prevent infinite loops\n */\nconst maxGeneratorDuration = 20000;\nfunction calcGeneratorDuration(generator) {\n    let duration = 0;\n    const timeStep = 50;\n    let state = generator.next(duration);\n    while (!state.done && duration < maxGeneratorDuration) {\n        duration += timeStep;\n        state = generator.next(duration);\n    }\n    return duration >= maxGeneratorDuration ? Infinity : duration;\n}\n\nexport { calcGeneratorDuration, maxGeneratorDuration };\n//# sourceMappingURL=calc-duration.mjs.map\n"],"names":[],"mappings":"AAIK,MAAC,uBAAuB;AAC7B,SAAS,sBAAsB,WAAW;AACtC,MAAI,WAAW;AACf,QAAM,WAAW;AACjB,MAAI,QAAQ,UAAU,KAAK,QAAQ;AACnC,SAAO,CAAC,MAAM,QAAQ,WAAW,sBAAsB;AACnD,gBAAY;AACZ,YAAQ,UAAU,KAAK,QAAQ;AAAA,EACnC;AACA,SAAO,YAAY,uBAAuB,WAAW;AACzD;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.js

@@ -0,0 +1,17 @@
+import { calcGeneratorDuration, maxGeneratorDuration } from "./calc-duration.js";
+import { millisecondsToSeconds } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/time-conversion.js";
+function createGeneratorEasing(options, scale = 100, createGenerator) {
+  const generator = createGenerator({ ...options, keyframes: [0, scale] });
+  const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);
+  return {
+    type: "keyframes",
+    ease: (progress) => {
+      return generator.next(duration * progress).value / scale;
+    },
+    duration: millisecondsToSeconds(duration)
+  };
+}
+export {
+  createGeneratorEasing
+};
+//# sourceMappingURL=create-generator-easing.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-generator-easing.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/utils/create-generator-easing.mjs"],"sourcesContent":["import { millisecondsToSeconds } from 'motion-utils';\nimport { calcGeneratorDuration, maxGeneratorDuration } from './calc-duration.mjs';\n\n/**\n * Create a progress => progress easing function from a generator.\n */\nfunction createGeneratorEasing(options, scale = 100, createGenerator) {\n    const generator = createGenerator({ ...options, keyframes: [0, scale] });\n    const duration = Math.min(calcGeneratorDuration(generator), maxGeneratorDuration);\n    return {\n        type: \"keyframes\",\n        ease: (progress) => {\n            return generator.next(duration * progress).value / scale;\n        },\n        duration: millisecondsToSeconds(duration),\n    };\n}\n\nexport { createGeneratorEasing };\n//# sourceMappingURL=create-generator-easing.mjs.map\n"],"names":[],"mappings":";;AAMA,SAAS,sBAAsB,SAAS,QAAQ,KAAK,iBAAiB;AAClE,QAAM,YAAY,gBAAgB,EAAE,GAAG,SAAS,WAAW,CAAC,GAAG,KAAK,GAAG;AACvE,QAAM,WAAW,KAAK,IAAI,sBAAsB,SAAS,GAAG,oBAAoB;AAChF,SAAO;AAAA,IACH,MAAM;AAAA,IACN,MAAM,CAAC,aAAa;AAChB,aAAO,UAAU,KAAK,WAAW,QAAQ,EAAE,QAAQ;AAAA,IACvD;AAAA,IACA,UAAU,sBAAsB,QAAQ;AAAA,EAChD;AACA;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.js

@@ -0,0 +1,7 @@
+function isGenerator(type) {
+  return typeof type === "function" && "applyToOptions" in type;
+}
+export {
+  isGenerator
+};
+//# sourceMappingURL=is-generator.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-generator.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/utils/is-generator.mjs"],"sourcesContent":["function isGenerator(type) {\n    return typeof type === \"function\" && \"applyToOptions\" in type;\n}\n\nexport { isGenerator };\n//# sourceMappingURL=is-generator.mjs.map\n"],"names":[],"mappings":"AAAA,SAAS,YAAY,MAAM;AACvB,SAAO,OAAO,SAAS,cAAc,oBAAoB;AAC7D;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/utils/velocity.js

@@ -0,0 +1,10 @@
+import { velocityPerSecond } from "../../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/velocity-per-second.js";
+const velocitySampleDuration = 5;
+function calcGeneratorVelocity(resolveValue, t, current) {
+  const prevT = Math.max(t - velocitySampleDuration, 0);
+  return velocityPerSecond(current - resolveValue(prevT), t - prevT);
+}
+export {
+  calcGeneratorVelocity
+};
+//# sourceMappingURL=velocity.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/utils/velocity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"velocity.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/generators/utils/velocity.mjs"],"sourcesContent":["import { velocityPerSecond } from 'motion-utils';\n\nconst velocitySampleDuration = 5; // ms\nfunction calcGeneratorVelocity(resolveValue, t, current) {\n    const prevT = Math.max(t - velocitySampleDuration, 0);\n    return velocityPerSecond(current - resolveValue(prevT), t - prevT);\n}\n\nexport { calcGeneratorVelocity };\n//# sourceMappingURL=velocity.mjs.map\n"],"names":[],"mappings":";AAEA,MAAM,yBAAyB;AAC/B,SAAS,sBAAsB,cAAc,GAAG,SAAS;AACrD,QAAM,QAAQ,KAAK,IAAI,IAAI,wBAAwB,CAAC;AACpD,SAAO,kBAAkB,UAAU,aAAa,KAAK,GAAG,IAAI,KAAK;AACrE;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/interfaces/motion-value.js

@@ -0,0 +1,70 @@
+import { AsyncMotionValueAnimation } from "../AsyncMotionValueAnimation.js";
+import { JSAnimation } from "../JSAnimation.js";
+import { getValueTransition } from "../utils/get-value-transition.js";
+import { makeAnimationInstant } from "../utils/make-animation-instant.js";
+import { getDefaultTransition } from "../utils/default-transitions.js";
+import { getFinalKeyframe } from "../utils/get-final-keyframe.js";
+import { isTransitionDefined } from "../utils/is-transition-defined.js";
+import { frame } from "../../frameloop/frame.js";
+import { secondsToMilliseconds } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/time-conversion.js";
+import { MotionGlobalConfig } from "../../../../../../../motion-utils@12.29.2/node_modules/motion-utils/dist/es/global-config.js";
+const animateMotionValue = (name, value, target, transition = {}, element, isHandoff) => (onComplete) => {
+  const valueTransition = getValueTransition(transition, name) || {};
+  const delay = valueTransition.delay || transition.delay || 0;
+  let { elapsed = 0 } = transition;
+  elapsed = elapsed - secondsToMilliseconds(delay);
+  const options = {
+    keyframes: Array.isArray(target) ? target : [null, target],
+    ease: "easeOut",
+    velocity: value.getVelocity(),
+    ...valueTransition,
+    delay: -elapsed,
+    onUpdate: (v) => {
+      value.set(v);
+      valueTransition.onUpdate && valueTransition.onUpdate(v);
+    },
+    onComplete: () => {
+      onComplete();
+      valueTransition.onComplete && valueTransition.onComplete();
+    },
+    name,
+    motionValue: value,
+    element: isHandoff ? void 0 : element
+  };
+  if (!isTransitionDefined(valueTransition)) {
+    Object.assign(options, getDefaultTransition(name, options));
+  }
+  options.duration && (options.duration = secondsToMilliseconds(options.duration));
+  options.repeatDelay && (options.repeatDelay = secondsToMilliseconds(options.repeatDelay));
+  if (options.from !== void 0) {
+    options.keyframes[0] = options.from;
+  }
+  let shouldSkip = false;
+  if (options.type === false || options.duration === 0 && !options.repeatDelay) {
+    makeAnimationInstant(options);
+    if (options.delay === 0) {
+      shouldSkip = true;
+    }
+  }
+  if (MotionGlobalConfig.instantAnimations || MotionGlobalConfig.skipAnimations || element?.shouldSkipAnimations) {
+    shouldSkip = true;
+    makeAnimationInstant(options);
+    options.delay = 0;
+  }
+  options.allowFlatten = !valueTransition.type && !valueTransition.ease;
+  if (shouldSkip && !isHandoff && value.get() !== void 0) {
+    const finalKeyframe = getFinalKeyframe(options.keyframes, valueTransition);
+    if (finalKeyframe !== void 0) {
+      frame.update(() => {
+        options.onUpdate(finalKeyframe);
+        options.onComplete();
+      });
+      return;
+    }
+  }
+  return valueTransition.isSync ? new JSAnimation(options) : new AsyncMotionValueAnimation(options);
+};
+export {
+  animateMotionValue
+};
+//# sourceMappingURL=motion-value.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/interfaces/motion-value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"motion-value.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/interfaces/motion-value.mjs"],"sourcesContent":["import { secondsToMilliseconds, MotionGlobalConfig } from 'motion-utils';\nimport { AsyncMotionValueAnimation } from '../AsyncMotionValueAnimation.mjs';\nimport { JSAnimation } from '../JSAnimation.mjs';\nimport { getValueTransition } from '../utils/get-value-transition.mjs';\nimport { makeAnimationInstant } from '../utils/make-animation-instant.mjs';\nimport { getDefaultTransition } from '../utils/default-transitions.mjs';\nimport { getFinalKeyframe } from '../utils/get-final-keyframe.mjs';\nimport { isTransitionDefined } from '../utils/is-transition-defined.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\nconst animateMotionValue = (name, value, target, transition = {}, element, isHandoff) => (onComplete) => {\n    const valueTransition = getValueTransition(transition, name) || {};\n    /**\n     * Most transition values are currently completely overwritten by value-specific\n     * transitions. In the future it'd be nicer to blend these transitions. But for now\n     * delay actually does inherit from the root transition if not value-specific.\n     */\n    const delay = valueTransition.delay || transition.delay || 0;\n    /**\n     * Elapsed isn't a public transition option but can be passed through from\n     * optimized appear effects in milliseconds.\n     */\n    let { elapsed = 0 } = transition;\n    elapsed = elapsed - secondsToMilliseconds(delay);\n    const options = {\n        keyframes: Array.isArray(target) ? target : [null, target],\n        ease: \"easeOut\",\n        velocity: value.getVelocity(),\n        ...valueTransition,\n        delay: -elapsed,\n        onUpdate: (v) => {\n            value.set(v);\n            valueTransition.onUpdate && valueTransition.onUpdate(v);\n        },\n        onComplete: () => {\n            onComplete();\n            valueTransition.onComplete && valueTransition.onComplete();\n        },\n        name,\n        motionValue: value,\n        element: isHandoff ? undefined : element,\n    };\n    /**\n     * If there's no transition defined for this value, we can generate\n     * unique transition settings for this value.\n     */\n    if (!isTransitionDefined(valueTransition)) {\n        Object.assign(options, getDefaultTransition(name, options));\n    }\n    /**\n     * Both WAAPI and our internal animation functions use durations\n     * as defined by milliseconds, while our external API defines them\n     * as seconds.\n     */\n    options.duration && (options.duration = secondsToMilliseconds(options.duration));\n    options.repeatDelay && (options.repeatDelay = secondsToMilliseconds(options.repeatDelay));\n    /**\n     * Support deprecated way to set initial value. Prefer keyframe syntax.\n     */\n    if (options.from !== undefined) {\n        options.keyframes[0] = options.from;\n    }\n    let shouldSkip = false;\n    if (options.type === false ||\n        (options.duration === 0 && !options.repeatDelay)) {\n        makeAnimationInstant(options);\n        if (options.delay === 0) {\n            shouldSkip = true;\n        }\n    }\n    if (MotionGlobalConfig.instantAnimations ||\n        MotionGlobalConfig.skipAnimations ||\n        element?.shouldSkipAnimations) {\n        shouldSkip = true;\n        makeAnimationInstant(options);\n        options.delay = 0;\n    }\n    /**\n     * If the transition type or easing has been explicitly set by the user\n     * then we don't want to allow flattening the animation.\n     */\n    options.allowFlatten = !valueTransition.type && !valueTransition.ease;\n    /**\n     * If we can or must skip creating the animation, and apply only\n     * the final keyframe, do so. We also check once keyframes are resolved but\n     * this early check prevents the need to create an animation at all.\n     */\n    if (shouldSkip && !isHandoff && value.get() !== undefined) {\n        const finalKeyframe = getFinalKeyframe(options.keyframes, valueTransition);\n        if (finalKeyframe !== undefined) {\n            frame.update(() => {\n                options.onUpdate(finalKeyframe);\n                options.onComplete();\n            });\n            return;\n        }\n    }\n    return valueTransition.isSync\n        ? new JSAnimation(options)\n        : new AsyncMotionValueAnimation(options);\n};\n\nexport { animateMotionValue };\n//# sourceMappingURL=motion-value.mjs.map\n"],"names":[],"mappings":";;;;;;;;;;AAUK,MAAC,qBAAqB,CAAC,MAAM,OAAO,QAAQ,aAAa,CAAA,GAAI,SAAS,cAAc,CAAC,eAAe;AACrG,QAAM,kBAAkB,mBAAmB,YAAY,IAAI,KAAK,CAAA;AAMhE,QAAM,QAAQ,gBAAgB,SAAS,WAAW,SAAS;AAK3D,MAAI,EAAE,UAAU,EAAC,IAAK;AACtB,YAAU,UAAU,sBAAsB,KAAK;AAC/C,QAAM,UAAU;AAAA,IACZ,WAAW,MAAM,QAAQ,MAAM,IAAI,SAAS,CAAC,MAAM,MAAM;AAAA,IACzD,MAAM;AAAA,IACN,UAAU,MAAM,YAAW;AAAA,IAC3B,GAAG;AAAA,IACH,OAAO,CAAC;AAAA,IACR,UAAU,CAAC,MAAM;AACb,YAAM,IAAI,CAAC;AACX,sBAAgB,YAAY,gBAAgB,SAAS,CAAC;AAAA,IAC1D;AAAA,IACA,YAAY,MAAM;AACd,iBAAU;AACV,sBAAgB,cAAc,gBAAgB,WAAU;AAAA,IAC5D;AAAA,IACA;AAAA,IACA,aAAa;AAAA,IACb,SAAS,YAAY,SAAY;AAAA,EACzC;AAKI,MAAI,CAAC,oBAAoB,eAAe,GAAG;AACvC,WAAO,OAAO,SAAS,qBAAqB,MAAM,OAAO,CAAC;AAAA,EAC9D;AAMA,UAAQ,aAAa,QAAQ,WAAW,sBAAsB,QAAQ,QAAQ;AAC9E,UAAQ,gBAAgB,QAAQ,cAAc,sBAAsB,QAAQ,WAAW;AAIvF,MAAI,QAAQ,SAAS,QAAW;AAC5B,YAAQ,UAAU,CAAC,IAAI,QAAQ;AAAA,EACnC;AACA,MAAI,aAAa;AACjB,MAAI,QAAQ,SAAS,SAChB,QAAQ,aAAa,KAAK,CAAC,QAAQ,aAAc;AAClD,yBAAqB,OAAO;AAC5B,QAAI,QAAQ,UAAU,GAAG;AACrB,mBAAa;AAAA,IACjB;AAAA,EACJ;AACA,MAAI,mBAAmB,qBACnB,mBAAmB,kBACnB,SAAS,sBAAsB;AAC/B,iBAAa;AACb,yBAAqB,OAAO;AAC5B,YAAQ,QAAQ;AAAA,EACpB;AAKA,UAAQ,eAAe,CAAC,gBAAgB,QAAQ,CAAC,gBAAgB;AAMjE,MAAI,cAAc,CAAC,aAAa,MAAM,IAAG,MAAO,QAAW;AACvD,UAAM,gBAAgB,iBAAiB,QAAQ,WAAW,eAAe;AACzE,QAAI,kBAAkB,QAAW;AAC7B,YAAM,OAAO,MAAM;AACf,gBAAQ,SAAS,aAAa;AAC9B,gBAAQ,WAAU;AAAA,MACtB,CAAC;AACD;AAAA,IACJ;AAAA,EACJ;AACA,SAAO,gBAAgB,SACjB,IAAI,YAAY,OAAO,IACvB,IAAI,0BAA0B,OAAO;AAC/C;","x_google_ignoreList":[0]}

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.js

@@ -0,0 +1,71 @@
+import { getValueTransition } from "../utils/get-value-transition.js";
+import { resolveTransition } from "../utils/resolve-transition.js";
+import { positionalKeys } from "../../render/utils/keys-position.js";
+import { setTarget } from "../../render/utils/setters.js";
+import { addValueToWillChange } from "../../value/will-change/add-will-change.js";
+import { getOptimisedAppearId } from "../optimized-appear/get-appear-id.js";
+import { animateMotionValue } from "./motion-value.js";
+import { frame } from "../../frameloop/frame.js";
+function shouldBlockAnimation({ protectedKeys, needsAnimating }, key) {
+  const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;
+  needsAnimating[key] = false;
+  return shouldBlock;
+}
+function animateTarget(visualElement, targetAndTransition, { delay = 0, transitionOverride, type } = {}) {
+  let { transition, transitionEnd, ...target } = targetAndTransition;
+  const defaultTransition = visualElement.getDefaultTransition();
+  transition = transition ? resolveTransition(transition, defaultTransition) : defaultTransition;
+  const reduceMotion = transition?.reduceMotion;
+  if (transitionOverride)
+    transition = transitionOverride;
+  const animations = [];
+  const animationTypeState = type && visualElement.animationState && visualElement.animationState.getState()[type];
+  for (const key in target) {
+    const value = visualElement.getValue(key, visualElement.latestValues[key] ?? null);
+    const valueTarget = target[key];
+    if (valueTarget === void 0 || animationTypeState && shouldBlockAnimation(animationTypeState, key)) {
+      continue;
+    }
+    const valueTransition = {
+      delay,
+      ...getValueTransition(transition || {}, key)
+    };
+    const currentValue = value.get();
+    if (currentValue !== void 0 && !value.isAnimating && !Array.isArray(valueTarget) && valueTarget === currentValue && !valueTransition.velocity) {
+      continue;
+    }
+    let isHandoff = false;
+    if (window.MotionHandoffAnimation) {
+      const appearId = getOptimisedAppearId(visualElement);
+      if (appearId) {
+        const startTime = window.MotionHandoffAnimation(appearId, key, frame);
+        if (startTime !== null) {
+          valueTransition.startTime = startTime;
+          isHandoff = true;
+        }
+      }
+    }
+    addValueToWillChange(visualElement, key);
+    const shouldReduceMotion = reduceMotion ?? visualElement.shouldReduceMotion;
+    value.start(animateMotionValue(key, value, valueTarget, shouldReduceMotion && positionalKeys.has(key) ? { type: false } : valueTransition, visualElement, isHandoff));
+    const animation = value.animation;
+    if (animation) {
+      animations.push(animation);
+    }
+  }
+  if (transitionEnd) {
+    const applyTransitionEnd = () => frame.update(() => {
+      transitionEnd && setTarget(visualElement, transitionEnd);
+    });
+    if (animations.length) {
+      Promise.all(animations).then(applyTransitionEnd);
+    } else {
+      applyTransitionEnd();
+    }
+  }
+  return animations;
+}
+export {
+  animateTarget
+};
+//# sourceMappingURL=visual-element-target.js.map

package/dist/esm/node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"visual-element-target.js","sources":["../../../../../../../../../../../node_modules/.pnpm/motion-dom@12.35.0/node_modules/motion-dom/dist/es/animation/interfaces/visual-element-target.mjs"],"sourcesContent":["import { getValueTransition } from '../utils/get-value-transition.mjs';\nimport { resolveTransition } from '../utils/resolve-transition.mjs';\nimport { positionalKeys } from '../../render/utils/keys-position.mjs';\nimport { setTarget } from '../../render/utils/setters.mjs';\nimport { addValueToWillChange } from '../../value/will-change/add-will-change.mjs';\nimport { getOptimisedAppearId } from '../optimized-appear/get-appear-id.mjs';\nimport { animateMotionValue } from './motion-value.mjs';\nimport { frame } from '../../frameloop/frame.mjs';\n\n/**\n * Decide whether we should block this animation. Previously, we achieved this\n * just by checking whether the key was listed in protectedKeys, but this\n * posed problems if an animation was triggered by afterChildren and protectedKeys\n * had been set to true in the meantime.\n */\nfunction shouldBlockAnimation({ protectedKeys, needsAnimating }, key) {\n    const shouldBlock = protectedKeys.hasOwnProperty(key) && needsAnimating[key] !== true;\n    needsAnimating[key] = false;\n    return shouldBlock;\n}\nfunction animateTarget(visualElement, targetAndTransition, { delay = 0, transitionOverride, type } = {}) {\n    let { transition, transitionEnd, ...target } = targetAndTransition;\n    const defaultTransition = visualElement.getDefaultTransition();\n    transition = transition\n        ? resolveTransition(transition, defaultTransition)\n        : defaultTransition;\n    const reduceMotion = transition?.reduceMotion;\n    if (transitionOverride)\n        transition = transitionOverride;\n    const animations = [];\n    const animationTypeState = type &&\n        visualElement.animationState &&\n        visualElement.animationState.getState()[type];\n    for (const key in target) {\n        const value = visualElement.getValue(key, visualElement.latestValues[key] ?? null);\n        const valueTarget = target[key];\n        if (valueTarget === undefined ||\n            (animationTypeState &&\n                shouldBlockAnimation(animationTypeState, key))) {\n            continue;\n        }\n        const valueTransition = {\n            delay,\n            ...getValueTransition(transition || {}, key),\n        };\n        /**\n         * If the value is already at the defined target, skip the animation.\n         */\n        const currentValue = value.get();\n        if (currentValue !== undefined &&\n            !value.isAnimating &&\n            !Array.isArray(valueTarget) &&\n            valueTarget === currentValue &&\n            !valueTransition.velocity) {\n            continue;\n        }\n        /**\n         * If this is the first time a value is being animated, check\n         * to see if we're handling off from an existing animation.\n         */\n        let isHandoff = false;\n        if (window.MotionHandoffAnimation) {\n            const appearId = getOptimisedAppearId(visualElement);\n            if (appearId) {\n                const startTime = window.MotionHandoffAnimation(appearId, key, frame);\n                if (startTime !== null) {\n                    valueTransition.startTime = startTime;\n                    isHandoff = true;\n                }\n            }\n        }\n        addValueToWillChange(visualElement, key);\n        const shouldReduceMotion = reduceMotion ?? visualElement.shouldReduceMotion;\n        value.start(animateMotionValue(key, value, valueTarget, shouldReduceMotion && positionalKeys.has(key)\n            ? { type: false }\n            : valueTransition, visualElement, isHandoff));\n        const animation = value.animation;\n        if (animation) {\n            animations.push(animation);\n        }\n    }\n    if (transitionEnd) {\n        const applyTransitionEnd = () => frame.update(() => {\n            transitionEnd && setTarget(visualElement, transitionEnd);\n        });\n        if (animations.length) {\n            Promise.all(animations).then(applyTransitionEnd);\n        }\n        else {\n            applyTransitionEnd();\n        }\n    }\n    return animations;\n}\n\nexport { animateTarget };\n//# sourceMappingURL=visual-element-target.mjs.map\n"],"names":[],"mappings":";;;;;;;;AAeA,SAAS,qBAAqB,EAAE,eAAe,eAAc,GAAI,KAAK;AAClE,QAAM,cAAc,cAAc,eAAe,GAAG,KAAK,eAAe,GAAG,MAAM;AACjF,iBAAe,GAAG,IAAI;AACtB,SAAO;AACX;AACA,SAAS,cAAc,eAAe,qBAAqB,EAAE,QAAQ,GAAG,oBAAoB,KAAI,IAAK,IAAI;AACrG,MAAI,EAAE,YAAY,eAAe,GAAG,OAAM,IAAK;AAC/C,QAAM,oBAAoB,cAAc,qBAAoB;AAC5D,eAAa,aACP,kBAAkB,YAAY,iBAAiB,IAC/C;AACN,QAAM,eAAe,YAAY;AACjC,MAAI;AACA,iBAAa;AACjB,QAAM,aAAa,CAAA;AACnB,QAAM,qBAAqB,QACvB,cAAc,kBACd,cAAc,eAAe,SAAQ,EAAG,IAAI;AAChD,aAAW,OAAO,QAAQ;AACtB,UAAM,QAAQ,cAAc,SAAS,KAAK,cAAc,aAAa,GAAG,KAAK,IAAI;AACjF,UAAM,cAAc,OAAO,GAAG;AAC9B,QAAI,gBAAgB,UACf,sBACG,qBAAqB,oBAAoB,GAAG,GAAI;AACpD;AAAA,IACJ;AACA,UAAM,kBAAkB;AAAA,MACpB;AAAA,MACA,GAAG,mBAAmB,cAAc,CAAA,GAAI,GAAG;AAAA,IACvD;AAIQ,UAAM,eAAe,MAAM,IAAG;AAC9B,QAAI,iBAAiB,UACjB,CAAC,MAAM,eACP,CAAC,MAAM,QAAQ,WAAW,KAC1B,gBAAgB,gBAChB,CAAC,gBAAgB,UAAU;AAC3B;AAAA,IACJ;AAKA,QAAI,YAAY;AAChB,QAAI,OAAO,wBAAwB;AAC/B,YAAM,WAAW,qBAAqB,aAAa;AACnD,UAAI,UAAU;AACV,cAAM,YAAY,OAAO,uBAAuB,UAAU,KAAK,KAAK;AACpE,YAAI,cAAc,MAAM;AACpB,0BAAgB,YAAY;AAC5B,sBAAY;AAAA,QAChB;AAAA,MACJ;AAAA,IACJ;AACA,yBAAqB,eAAe,GAAG;AACvC,UAAM,qBAAqB,gBAAgB,cAAc;AACzD,UAAM,MAAM,mBAAmB,KAAK,OAAO,aAAa,sBAAsB,eAAe,IAAI,GAAG,IAC9F,EAAE,MAAM,MAAK,IACb,iBAAiB,eAAe,SAAS,CAAC;AAChD,UAAM,YAAY,MAAM;AACxB,QAAI,WAAW;AACX,iBAAW,KAAK,SAAS;AAAA,IAC7B;AAAA,EACJ;AACA,MAAI,eAAe;AACf,UAAM,qBAAqB,MAAM,MAAM,OAAO,MAAM;AAChD,uBAAiB,UAAU,eAAe,aAAa;AAAA,IAC3D,CAAC;AACD,QAAI,WAAW,QAAQ;AACnB,cAAQ,IAAI,UAAU,EAAE,KAAK,kBAAkB;AAAA,IACnD,OACK;AACD,yBAAkB;AAAA,IACtB;AAAA,EACJ;AACA,SAAO;AACX;","x_google_ignoreList":[0]}