@hanzogui/react-native-web-lite 2.0.0

package/dist/cjs/vendor/react-native/Animated/NativeAnimatedModule.cjs

@@ -0,0 +1,78 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var NativeAnimatedModule_exports = {};
+__export(NativeAnimatedModule_exports, {
+  AnimatedNodeConfig: () => AnimatedNodeConfig,
+  AnimatingNodeConfig: () => AnimatingNodeConfig,
+  EndCallback: () => EndCallback,
+  EventMapping: () => EventMapping,
+  NativeAnimatedNonTurboModule: () => NativeAnimatedNonTurboModule,
+  SaveValueCallback: () => SaveValueCallback,
+  default: () => NativeAnimatedModule_default
+});
+module.exports = __toCommonJS(NativeAnimatedModule_exports);
+var TurboModuleRegistry = __toESM(require("../TurboModule/TurboModuleRegistry.cjs"), 1);
+const EventMapping = {},
+  AnimatedNodeConfig = {},
+  AnimatingNodeConfig = {},
+  SaveValueCallback = () => {},
+  EndCallback = () => {},
+  spec = {
+    startOperationBatch: () => {},
+    finishOperationBatch: () => {},
+    createAnimatedNode: (tag, config) => {},
+    updateAnimatedNodeConfig: (tag, config) => {},
+    getValue: (tag, saveValueCallback) => {},
+    startListeningToAnimatedNodeValue: tag => {},
+    stopListeningToAnimatedNodeValue: tag => {},
+    connectAnimatedNodes: (parentTag, childTag) => {},
+    disconnectAnimatedNodes: (parentTag, childTag) => {},
+    startAnimatingNode: (animationId, nodeTag, config, endCallback) => {},
+    stopAnimation: animationId => {},
+    setAnimatedNodeValue: (nodeTag, value) => {},
+    setAnimatedNodeOffset: (nodeTag, offset) => {},
+    flattenAnimatedNodeOffset: nodeTag => {},
+    extractAnimatedNodeOffset: nodeTag => {},
+    connectAnimatedNodeToView: (nodeTag, viewTag) => {},
+    disconnectAnimatedNodeFromView: (nodeTag, viewTag) => {},
+    restoreDefaultValues: nodeTag => {},
+    dropAnimatedNode: tag => {},
+    addAnimatedEventToView: (viewTag, eventName, eventMapping) => {},
+    removeAnimatedEventFromView: (viewTag, eventName, animatedNodeTag) => {},
+    // Events
+    addListener: eventName => {},
+    removeListeners: count => {},
+    // All of the above in a batched mode
+    queueAndExecuteBatchedOperations: operationsAndArgs => {}
+  },
+  NativeAnimatedNonTurboModule = TurboModuleRegistry.get("NativeAnimatedModule") || spec;
+var NativeAnimatedModule_default = NativeAnimatedNonTurboModule;

package/dist/cjs/vendor/react-native/Animated/NativeAnimatedTurboModule.cjs

@@ -0,0 +1,75 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var NativeAnimatedTurboModule_exports = {};
+__export(NativeAnimatedTurboModule_exports, {
+  AnimatedNodeConfig: () => AnimatedNodeConfig,
+  AnimatingNodeConfig: () => AnimatingNodeConfig,
+  EndCallback: () => EndCallback,
+  EventMapping: () => EventMapping,
+  NativeAnimatedTurboModule: () => NativeAnimatedTurboModule,
+  SaveValueCallback: () => SaveValueCallback,
+  default: () => NativeAnimatedTurboModule_default
+});
+module.exports = __toCommonJS(NativeAnimatedTurboModule_exports);
+var TurboModuleRegistry = __toESM(require("../TurboModule/TurboModuleRegistry.cjs"), 1);
+const EventMapping = {},
+  AnimatedNodeConfig = {},
+  AnimatingNodeConfig = {},
+  SaveValueCallback = () => {},
+  EndCallback = () => {},
+  spec = {
+    startOperationBatch: () => {},
+    finishOperationBatch: () => {},
+    createAnimatedNode: (tag, config) => {},
+    getValue: (tag, saveValueCallback) => {},
+    startListeningToAnimatedNodeValue: tag => {},
+    stopListeningToAnimatedNodeValue: tag => {},
+    connectAnimatedNodes: (parentTag, childTag) => {},
+    disconnectAnimatedNodes: (parentTag, childTag) => {},
+    startAnimatingNode: (animationId, nodeTag, config, endCallback) => {},
+    stopAnimation: animationId => {},
+    setAnimatedNodeValue: (nodeTag, value) => {},
+    setAnimatedNodeOffset: (nodeTag, offset) => {},
+    flattenAnimatedNodeOffset: nodeTag => {},
+    extractAnimatedNodeOffset: nodeTag => {},
+    connectAnimatedNodeToView: (nodeTag, viewTag) => {},
+    disconnectAnimatedNodeFromView: (nodeTag, viewTag) => {},
+    restoreDefaultValues: nodeTag => {},
+    dropAnimatedNode: tag => {},
+    addAnimatedEventToView: (viewTag, eventName, eventMapping) => {},
+    removeAnimatedEventFromView: (viewTag, eventName, animatedNodeTag) => {},
+    // Events
+    addListener: eventName => {},
+    removeListeners: count => {}
+  },
+  NativeAnimatedTurboModule = TurboModuleRegistry.get("NativeAnimatedTurboModule") || spec;
+var NativeAnimatedTurboModule_default = NativeAnimatedTurboModule;

package/dist/cjs/vendor/react-native/Animated/SpringConfig.cjs

@@ -0,0 +1,78 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var SpringConfig_exports = {};
+__export(SpringConfig_exports, {
+  SpringConfig: () => SpringConfig,
+  default: () => SpringConfig_default
+});
+module.exports = __toCommonJS(SpringConfig_exports);
+function stiffnessFromOrigamiValue(oValue) {
+  return (oValue - 30) * 3.62 + 194;
+}
+function dampingFromOrigamiValue(oValue) {
+  return (oValue - 8) * 3 + 25;
+}
+function fromOrigamiTensionAndFriction(tension, friction) {
+  return {
+    stiffness: stiffnessFromOrigamiValue(tension),
+    damping: dampingFromOrigamiValue(friction)
+  };
+}
+function fromBouncinessAndSpeed(bounciness, speed) {
+  function normalize(value, startValue, endValue) {
+    return (value - startValue) / (endValue - startValue);
+  }
+  function projectNormal(n, start, end) {
+    return start + n * (end - start);
+  }
+  function linearInterpolation(t, start, end) {
+    return t * end + (1 - t) * start;
+  }
+  function quadraticOutInterpolation(t, start, end) {
+    return linearInterpolation(2 * t - t * t, start, end);
+  }
+  function b3Friction1(x) {
+    return 7e-4 * x ** 3 - 0.031 * x ** 2 + 0.64 * x + 1.28;
+  }
+  function b3Friction2(x) {
+    return 44e-6 * x ** 3 - 6e-3 * x ** 2 + 0.36 * x + 2;
+  }
+  function b3Friction3(x) {
+    return 45e-8 * x ** 3 - 332e-6 * x ** 2 + 0.1078 * x + 5.84;
+  }
+  function b3Nobounce(tension) {
+    return tension <= 18 ? b3Friction1(tension) : tension > 18 && tension <= 44 ? b3Friction2(tension) : b3Friction3(tension);
+  }
+  let b = normalize(bounciness / 1.7, 0, 20);
+  b = projectNormal(b, 0, 0.8);
+  const s = normalize(speed / 1.7, 0, 20),
+    bouncyTension = projectNormal(s, 0.5, 200),
+    bouncyFriction = quadraticOutInterpolation(b, b3Nobounce(bouncyTension), 0.01);
+  return {
+    stiffness: stiffnessFromOrigamiValue(bouncyTension),
+    damping: dampingFromOrigamiValue(bouncyFriction)
+  };
+}
+const SpringConfig = {
+  fromOrigamiTensionAndFriction,
+  fromBouncinessAndSpeed
+};
+var SpringConfig_default = SpringConfig;

package/dist/cjs/vendor/react-native/Animated/animations/Animation.cjs

@@ -0,0 +1,64 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var Animation_exports = {};
+__export(Animation_exports, {
+  Animation: () => Animation,
+  default: () => Animation_default
+});
+module.exports = __toCommonJS(Animation_exports);
+var import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs");
+let startNativeAnimationNextId = 1;
+class Animation {
+  __active;
+  __isInteraction;
+  __nativeId;
+  __onEnd;
+  __iterations;
+  start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {}
+  stop() {
+    this.__nativeId && import_NativeAnimatedHelper.NativeAnimatedHelper.API.stopAnimation(this.__nativeId);
+  }
+  __getNativeAnimationConfig() {
+    throw new Error("This animation type cannot be offloaded to native");
+  }
+  // Helper function for subclasses to make sure onEnd is only called once.
+  __debouncedOnEnd(result) {
+    const onEnd = this.__onEnd;
+    this.__onEnd = null, onEnd && onEnd(result);
+  }
+  __startNativeAnimation(animatedValue) {
+    const startNativeAnimationWaitId = `${startNativeAnimationNextId}:startAnimation`;
+    startNativeAnimationNextId += 1, import_NativeAnimatedHelper.NativeAnimatedHelper.API.setWaitingForIdentifier(startNativeAnimationWaitId);
+    try {
+      const config = this.__getNativeAnimationConfig();
+      animatedValue.__makeNative(config.platformConfig), this.__nativeId = import_NativeAnimatedHelper.NativeAnimatedHelper.generateNewAnimationId(), import_NativeAnimatedHelper.NativeAnimatedHelper.API.startAnimatingNode(this.__nativeId, animatedValue.__getNativeTag(), config,
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      this.__debouncedOnEnd.bind(this));
+    } catch (e) {
+      throw e;
+    } finally {
+      import_NativeAnimatedHelper.NativeAnimatedHelper.API.unsetWaitingForIdentifier(startNativeAnimationWaitId);
+    }
+  }
+}
+var Animation_default = Animation;

package/dist/cjs/vendor/react-native/Animated/animations/DecayAnimation.cjs

@@ -0,0 +1,71 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var DecayAnimation_exports = {};
+__export(DecayAnimation_exports, {
+  DecayAnimation: () => DecayAnimation,
+  default: () => DecayAnimation_default
+});
+module.exports = __toCommonJS(DecayAnimation_exports);
+var import_Animation = require("./Animation.cjs"),
+  import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs");
+class DecayAnimation extends import_Animation.Animation {
+  _startTime;
+  _lastValue;
+  _fromValue;
+  _deceleration;
+  _velocity;
+  _onUpdate;
+  _animationFrame;
+  _useNativeDriver;
+  constructor(config) {
+    super(), this._deceleration = config.deceleration ?? 0.998, this._velocity = config.velocity, this._useNativeDriver = (0, import_NativeAnimatedHelper.shouldUseNativeDriver)(config), this.__isInteraction = config.isInteraction ?? !this._useNativeDriver, this.__iterations = config.iterations ?? 1;
+  }
+  __getNativeAnimationConfig() {
+    return {
+      type: "decay",
+      deceleration: this._deceleration,
+      velocity: this._velocity,
+      iterations: this.__iterations
+    };
+  }
+  start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
+    this.__active = !0, this._lastValue = fromValue, this._fromValue = fromValue, this._onUpdate = onUpdate, this.__onEnd = onEnd, this._startTime = Date.now(), this._useNativeDriver ? this.__startNativeAnimation(animatedValue) : this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
+  }
+  onUpdate() {
+    const now = Date.now(),
+      value = this._fromValue + this._velocity / (1 - this._deceleration) * (1 - Math.exp(-(1 - this._deceleration) * (now - this._startTime)));
+    if (this._onUpdate(value), Math.abs(this._lastValue - value) < 0.1) {
+      this.__debouncedOnEnd({
+        finished: !0
+      });
+      return;
+    }
+    this._lastValue = value, this.__active && (this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this)));
+  }
+  stop() {
+    super.stop(), this.__active = !1, global.cancelAnimationFrame(this._animationFrame), this.__debouncedOnEnd({
+      finished: !1
+    });
+  }
+}
+var DecayAnimation_default = DecayAnimation;

package/dist/cjs/vendor/react-native/Animated/animations/SpringAnimation.cjs

@@ -0,0 +1,161 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var SpringAnimation_exports = {};
+__export(SpringAnimation_exports, {
+  SpringAnimation: () => SpringAnimation,
+  default: () => SpringAnimation_default
+});
+module.exports = __toCommonJS(SpringAnimation_exports);
+var import_Animation = require("./Animation.cjs"),
+  import_SpringConfig = require("../SpringConfig.cjs"),
+  import_react_native_web_internals = require("@hanzogui/react-native-web-internals"),
+  import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs");
+class SpringAnimation extends import_Animation.Animation {
+  _overshootClamping;
+  _restDisplacementThreshold;
+  _restSpeedThreshold;
+  _lastVelocity;
+  _startPosition;
+  _lastPosition;
+  _fromValue;
+  _toValue;
+  _stiffness;
+  _damping;
+  _mass;
+  _initialVelocity;
+  _delay;
+  _timeout;
+  _startTime;
+  _lastTime;
+  _frameTime;
+  _onUpdate;
+  _animationFrame;
+  _useNativeDriver;
+  _platformConfig;
+  constructor(config) {
+    if (super(), this._overshootClamping = config.overshootClamping ?? !1, this._restDisplacementThreshold = config.restDisplacementThreshold ?? 1e-3, this._restSpeedThreshold = config.restSpeedThreshold ?? 1e-3, this._initialVelocity = config.velocity ?? 0, this._lastVelocity = config.velocity ?? 0, this._toValue = config.toValue, this._delay = config.delay ?? 0, this._useNativeDriver = (0, import_NativeAnimatedHelper.shouldUseNativeDriver)(config), this._platformConfig = config.platformConfig, this.__isInteraction = config.isInteraction ?? !this._useNativeDriver, this.__iterations = config.iterations ?? 1, config.stiffness !== void 0 || config.damping !== void 0 || config.mass !== void 0) (0, import_react_native_web_internals.invariant)(config.bounciness === void 0 && config.speed === void 0 && config.tension === void 0 && config.friction === void 0, "You can define one of bounciness/speed, tension/friction, or stiffness/damping/mass, but not more than one"), this._stiffness = config.stiffness ?? 100, this._damping = config.damping ?? 10, this._mass = config.mass ?? 1;else if (config.bounciness !== void 0 || config.speed !== void 0) {
+      (0, import_react_native_web_internals.invariant)(config.tension === void 0 && config.friction === void 0 && config.stiffness === void 0 && config.damping === void 0 && config.mass === void 0, "You can define one of bounciness/speed, tension/friction, or stiffness/damping/mass, but not more than one");
+      const springConfig = import_SpringConfig.SpringConfig.fromBouncinessAndSpeed(config.bounciness ?? 8, config.speed ?? 12);
+      this._stiffness = springConfig.stiffness, this._damping = springConfig.damping, this._mass = 1;
+    } else {
+      const springConfig = import_SpringConfig.SpringConfig.fromOrigamiTensionAndFriction(config.tension ?? 40, config.friction ?? 7);
+      this._stiffness = springConfig.stiffness, this._damping = springConfig.damping, this._mass = 1;
+    }
+    (0, import_react_native_web_internals.invariant)(this._stiffness > 0, "Stiffness value must be greater than 0"), (0, import_react_native_web_internals.invariant)(this._damping > 0, "Damping value must be greater than 0"), (0, import_react_native_web_internals.invariant)(this._mass > 0, "Mass value must be greater than 0");
+  }
+  __getNativeAnimationConfig() {
+    return {
+      type: "spring",
+      overshootClamping: this._overshootClamping,
+      restDisplacementThreshold: this._restDisplacementThreshold,
+      restSpeedThreshold: this._restSpeedThreshold,
+      stiffness: this._stiffness,
+      damping: this._damping,
+      mass: this._mass,
+      initialVelocity: this._initialVelocity ?? this._lastVelocity,
+      toValue: this._toValue,
+      iterations: this.__iterations,
+      platformConfig: this._platformConfig
+    };
+  }
+  start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
+    if (this.__active = !0, this._startPosition = fromValue, this._lastPosition = this._startPosition, this._onUpdate = onUpdate, this.__onEnd = onEnd, this._lastTime = Date.now(), this._frameTime = 0, previousAnimation instanceof SpringAnimation) {
+      const internalState = previousAnimation.getInternalState();
+      this._lastPosition = internalState.lastPosition, this._lastVelocity = internalState.lastVelocity, this._initialVelocity = this._lastVelocity, this._lastTime = internalState.lastTime;
+    }
+    const start = () => {
+      this._useNativeDriver ? this.__startNativeAnimation(animatedValue) : this.onUpdate();
+    };
+    this._delay ? this._timeout = setTimeout(start, this._delay) : start();
+  }
+  getInternalState() {
+    return {
+      lastPosition: this._lastPosition,
+      lastVelocity: this._lastVelocity,
+      lastTime: this._lastTime
+    };
+  }
+  /**
+   * This spring model is based off of a damped harmonic oscillator
+   * (https://en.wikipedia.org/wiki/Harmonic_oscillator#Damped_harmonic_oscillator).
+   *
+   * We use the closed form of the second order differential equation:
+   *
+   * x'' + (2ζ⍵_0)x' + ⍵^2x = 0
+   *
+   * where
+   *    ⍵_0 = √(k / m) (undamped angular frequency of the oscillator),
+   *    ζ = c / 2√mk (damping ratio),
+   *    c = damping constant
+   *    k = stiffness
+   *    m = mass
+   *
+   * The derivation of the closed form is described in detail here:
+   * http://planetmath.org/sites/default/files/texpdf/39745.pdf
+   *
+   * This algorithm happens to match the algorithm used by CASpringAnimation,
+   * a QuartzCore (iOS) API that creates spring animations.
+   */
+  onUpdate() {
+    let now = Date.now();
+    now > this._lastTime + 64 && (now = this._lastTime + 64);
+    const deltaTime = (now - this._lastTime) / 1e3;
+    this._frameTime += deltaTime;
+    const c = this._damping,
+      m = this._mass,
+      k = this._stiffness,
+      v0 = -this._initialVelocity,
+      zeta = c / (2 * Math.sqrt(k * m)),
+      omega0 = Math.sqrt(k / m),
+      omega1 = omega0 * Math.sqrt(1 - zeta * zeta),
+      x0 = this._toValue - this._startPosition;
+    let position = 0,
+      velocity = 0;
+    const t = this._frameTime;
+    if (zeta < 1) {
+      const envelope = Math.exp(-zeta * omega0 * t);
+      position = this._toValue - envelope * ((v0 + zeta * omega0 * x0) / omega1 * Math.sin(omega1 * t) + x0 * Math.cos(omega1 * t)), velocity = zeta * omega0 * envelope * (Math.sin(omega1 * t) * (v0 + zeta * omega0 * x0) / omega1 + x0 * Math.cos(omega1 * t)) - envelope * (Math.cos(omega1 * t) * (v0 + zeta * omega0 * x0) - omega1 * x0 * Math.sin(omega1 * t));
+    } else {
+      const envelope = Math.exp(-omega0 * t);
+      position = this._toValue - envelope * (x0 + (v0 + omega0 * x0) * t), velocity = envelope * (v0 * (t * omega0 - 1) + t * x0 * (omega0 * omega0));
+    }
+    if (this._lastTime = now, this._lastPosition = position, this._lastVelocity = velocity, this._onUpdate(position), !this.__active) return;
+    let isOvershooting = !1;
+    this._overshootClamping && this._stiffness !== 0 && (this._startPosition < this._toValue ? isOvershooting = position > this._toValue : isOvershooting = position < this._toValue);
+    const isVelocity = Math.abs(velocity) <= this._restSpeedThreshold;
+    let isDisplacement = !0;
+    if (this._stiffness !== 0 && (isDisplacement = Math.abs(this._toValue - position) <= this._restDisplacementThreshold), isOvershooting || isVelocity && isDisplacement) {
+      this._stiffness !== 0 && (this._lastPosition = this._toValue, this._lastVelocity = 0, this._onUpdate(this._toValue)), this.__debouncedOnEnd({
+        finished: !0
+      });
+      return;
+    }
+    this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
+  }
+  stop() {
+    super.stop(), this.__active = !1, clearTimeout(this._timeout), global.cancelAnimationFrame(this._animationFrame), this.__debouncedOnEnd({
+      finished: !1
+    });
+  }
+}
+var SpringAnimation_default = SpringAnimation;

package/dist/cjs/vendor/react-native/Animated/animations/TimingAnimation.cjs

@@ -0,0 +1,89 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var TimingAnimation_exports = {};
+__export(TimingAnimation_exports, {
+  TimingAnimation: () => TimingAnimation,
+  default: () => TimingAnimation_default
+});
+module.exports = __toCommonJS(TimingAnimation_exports);
+var import_Easing = require("../Easing.cjs"),
+  import_Animation = require("./Animation.cjs"),
+  import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs");
+let _easeInOut;
+function easeInOut() {
+  return _easeInOut || (_easeInOut = import_Easing.Easing.inOut(import_Easing.Easing.ease)), _easeInOut;
+}
+class TimingAnimation extends import_Animation.Animation {
+  _startTime;
+  _fromValue;
+  _toValue;
+  _duration;
+  _delay;
+  _easing;
+  _onUpdate;
+  _animationFrame;
+  _timeout;
+  _useNativeDriver;
+  _platformConfig;
+  constructor(config) {
+    super(), this._toValue = config.toValue, this._easing = config.easing ?? easeInOut(), this._duration = config.duration ?? 500, this._delay = config.delay ?? 0, this.__iterations = config.iterations ?? 1, this._useNativeDriver = (0, import_NativeAnimatedHelper.shouldUseNativeDriver)(config), this._platformConfig = config.platformConfig, this.__isInteraction = config.isInteraction ?? !this._useNativeDriver;
+  }
+  __getNativeAnimationConfig() {
+    const frameDuration = 16.666666666666668,
+      frames = [],
+      numFrames = Math.round(this._duration / frameDuration);
+    for (let frame = 0; frame < numFrames; frame++) frames.push(this._easing(frame / numFrames));
+    return frames.push(this._easing(1)), {
+      type: "frames",
+      frames,
+      toValue: this._toValue,
+      iterations: this.__iterations,
+      platformConfig: this._platformConfig
+    };
+  }
+  start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
+    this.__active = !0, this._fromValue = fromValue, this._onUpdate = onUpdate, this.__onEnd = onEnd;
+    const start = () => {
+      this._duration === 0 && !this._useNativeDriver ? (this._onUpdate(this._toValue), this.__debouncedOnEnd({
+        finished: !0
+      })) : (this._startTime = Date.now(), this._useNativeDriver ? this.__startNativeAnimation(animatedValue) : this._animationFrame = requestAnimationFrame(
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      this.onUpdate.bind(this)));
+    };
+    this._delay ? this._timeout = setTimeout(start, this._delay) : start();
+  }
+  onUpdate() {
+    const now = Date.now();
+    if (now >= this._startTime + this._duration) {
+      this._duration === 0 ? this._onUpdate(this._toValue) : this._onUpdate(this._fromValue + this._easing(1) * (this._toValue - this._fromValue)), this.__debouncedOnEnd({
+        finished: !0
+      });
+      return;
+    }
+    this._onUpdate(this._fromValue + this._easing((now - this._startTime) / this._duration) * (this._toValue - this._fromValue)), this.__active && (this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this)));
+  }
+  stop() {
+    super.stop(), this.__active = !1, clearTimeout(this._timeout), global.cancelAnimationFrame(this._animationFrame), this.__debouncedOnEnd({
+      finished: !1
+    });
+  }
+}
+var TimingAnimation_default = TimingAnimation;