@tamagui/react-native-web-lite 1.113.0 → 1.113.2

package/dist/esm/vendor/react-native/Animated/AnimatedImplementation.native.js

@@ -1,481 +1,452 @@
-import { AnimatedEvent, attachNativeEvent } from "./AnimatedEvent.native.js";
-import DecayAnimation from "./animations/DecayAnimation.native.js";
-import SpringAnimation from "./animations/SpringAnimation.native.js";
-import TimingAnimation from "./animations/TimingAnimation.native.js";
-import createAnimatedComponent from "./createAnimatedComponent.native.js";
-import AnimatedAddition from "./nodes/AnimatedAddition.native.js";
-import AnimatedColor from "./nodes/AnimatedColor.native.js";
-import AnimatedDiffClamp from "./nodes/AnimatedDiffClamp.native.js";
-import AnimatedDivision from "./nodes/AnimatedDivision.native.js";
-import AnimatedInterpolation from "./nodes/AnimatedInterpolation.native.js";
-import AnimatedModulo from "./nodes/AnimatedModulo.native.js";
-import AnimatedMultiplication from "./nodes/AnimatedMultiplication.native.js";
-import AnimatedNode from "./nodes/AnimatedNode.native.js";
-import AnimatedSubtraction from "./nodes/AnimatedSubtraction.native.js";
-import AnimatedTracking from "./nodes/AnimatedTracking.native.js";
-import AnimatedValue from "./nodes/AnimatedValue.native.js";
-import AnimatedValueXY from "./nodes/AnimatedValueXY.native.js";
-var add = function (a, b) {
-    return new AnimatedAddition(a, b);
-  },
-  subtract = function (a, b) {
-    return new AnimatedSubtraction(a, b);
-  },
-  divide = function (a, b) {
-    return new AnimatedDivision(a, b);
-  },
-  multiply = function (a, b) {
-    return new AnimatedMultiplication(a, b);
-  },
-  modulo = function (a, modulus) {
-    return new AnimatedModulo(a, modulus);
-  },
-  diffClamp = function (a, min, max) {
-    return new AnimatedDiffClamp(a, min, max);
-  },
-  _combineCallbacks = function (callback, config) {
-    return callback && config.onComplete ? function () {
-      config.onComplete && config.onComplete(...arguments), callback && callback(...arguments);
-    } : callback || config.onComplete;
-  },
-  maybeVectorAnim = function (value, config, anim) {
-    if (value instanceof AnimatedValueXY) {
-      var configX = {
-          ...config
-        },
-        configY = {
-          ...config
-        };
-      for (var key in config) {
-        var _config$key = config[key],
-          x = _config$key.x,
-          y = _config$key.y;
-        x !== void 0 && y !== void 0 && (configX[key] = x, configY[key] = y);
-      }
-      var aX = anim(value.x, configX),
-        aY = anim(value.y, configY);
-      return parallel([aX, aY], {
-        stopTogether: !1
-      });
-    } else if (value instanceof AnimatedColor) {
-      var configR = {
-          ...config
-        },
-        configG = {
-          ...config
-        },
-        configB = {
-          ...config
-        },
-        configA = {
-          ...config
-        };
-      for (var _key in config) {
-        var _config$_key = config[_key],
-          r = _config$_key.r,
-          g = _config$_key.g,
-          b = _config$_key.b,
-          a = _config$_key.a;
-        r !== void 0 && g !== void 0 && b !== void 0 && a !== void 0 && (configR[_key] = r, configG[_key] = g, configB[_key] = b, configA[_key] = a);
-      }
-      var aR = anim(value.r, configR),
-        aG = anim(value.g, configG),
-        aB = anim(value.b, configB),
-        aA = anim(value.a, configA);
-      return parallel([aR, aG, aB, aA], {
-        stopTogether: !1
-      });
-    }
-    return null;
-  },
-  spring = function spring2(value, config) {
-    var _start = function (animatedValue, configuration, callback) {
-      callback = _combineCallbacks(callback, configuration);
-      var singleValue = animatedValue,
-        singleConfig = configuration;
-      singleValue.stopTracking(), configuration.toValue instanceof AnimatedNode ? singleValue.track(new AnimatedTracking(singleValue, configuration.toValue, SpringAnimation, singleConfig, callback)) : singleValue.animate(new SpringAnimation(singleConfig), callback);
-    };
-    return maybeVectorAnim(value, config, spring2) || {
-      start: function (callback) {
-        _start(value, config, callback);
-      },
-      stop: function () {
-        value.stopAnimation();
-      },
-      reset: function () {
-        value.resetAnimation();
-      },
-      _startNativeLoop: function (iterations) {
-        var singleConfig = {
-          ...config,
-          iterations
-        };
-        _start(value, singleConfig);
-      },
-      _isUsingNativeDriver: function () {
-        return config.useNativeDriver || !1;
-      }
-    };
-  },
-  timing = function timing2(value, config) {
-    var _start2 = function (animatedValue, configuration, callback) {
-      callback = _combineCallbacks(callback, configuration);
-      var singleValue = animatedValue,
-        singleConfig = configuration;
-      singleValue.stopTracking(), configuration.toValue instanceof AnimatedNode ? singleValue.track(new AnimatedTracking(singleValue, configuration.toValue, TimingAnimation, singleConfig, callback)) : singleValue.animate(new TimingAnimation(singleConfig), callback);
-    };
-    return maybeVectorAnim(value, config, timing2) || {
-      start: function (callback) {
-        _start2(value, config, callback);
-      },
-      stop: function () {
-        value.stopAnimation();
-      },
-      reset: function () {
-        value.resetAnimation();
-      },
-      _startNativeLoop: function (iterations) {
-        var singleConfig = {
-          ...config,
-          iterations
-        };
-        _start2(value, singleConfig);
-      },
-      _isUsingNativeDriver: function () {
-        return config.useNativeDriver || !1;
-      }
-    };
-  },
-  decay = function decay2(value, config) {
-    var _start3 = function (animatedValue, configuration, callback) {
-      callback = _combineCallbacks(callback, configuration);
-      var singleValue = animatedValue,
-        singleConfig = configuration;
-      singleValue.stopTracking(), singleValue.animate(new DecayAnimation(singleConfig), callback);
+import { AnimatedEvent, attachNativeEvent } from "./AnimatedEvent";
+import DecayAnimation from "./animations/DecayAnimation";
+import SpringAnimation from "./animations/SpringAnimation";
+import TimingAnimation from "./animations/TimingAnimation";
+import createAnimatedComponent from "./createAnimatedComponent";
+import AnimatedAddition from "./nodes/AnimatedAddition";
+import AnimatedColor from "./nodes/AnimatedColor";
+import AnimatedDiffClamp from "./nodes/AnimatedDiffClamp";
+import AnimatedDivision from "./nodes/AnimatedDivision";
+import AnimatedInterpolation from "./nodes/AnimatedInterpolation";
+import AnimatedModulo from "./nodes/AnimatedModulo";
+import AnimatedMultiplication from "./nodes/AnimatedMultiplication";
+import AnimatedNode from "./nodes/AnimatedNode";
+import AnimatedSubtraction from "./nodes/AnimatedSubtraction";
+import AnimatedTracking from "./nodes/AnimatedTracking";
+import AnimatedValue from "./nodes/AnimatedValue";
+import AnimatedValueXY from "./nodes/AnimatedValueXY";
+var add = function(a, b) {
+  return new AnimatedAddition(a, b);
+}, subtract = function(a, b) {
+  return new AnimatedSubtraction(a, b);
+}, divide = function(a, b) {
+  return new AnimatedDivision(a, b);
+}, multiply = function(a, b) {
+  return new AnimatedMultiplication(a, b);
+}, modulo = function(a, modulus) {
+  return new AnimatedModulo(a, modulus);
+}, diffClamp = function(a, min, max) {
+  return new AnimatedDiffClamp(a, min, max);
+}, _combineCallbacks = function(callback, config) {
+  return callback && config.onComplete ? function() {
+    config.onComplete && config.onComplete(...arguments), callback && callback(...arguments);
+  } : callback || config.onComplete;
+}, maybeVectorAnim = function(value, config, anim) {
+  if (value instanceof AnimatedValueXY) {
+    var configX = {
+      ...config
+    }, configY = {
+      ...config
     };
-    return maybeVectorAnim(value, config, decay2) || {
-      start: function (callback) {
-        _start3(value, config, callback);
-      },
-      stop: function () {
-        value.stopAnimation();
-      },
-      reset: function () {
-        value.resetAnimation();
-      },
-      _startNativeLoop: function (iterations) {
-        var singleConfig = {
-          ...config,
-          iterations
-        };
-        _start3(value, singleConfig);
-      },
-      _isUsingNativeDriver: function () {
-        return config.useNativeDriver || !1;
-      }
+    for (var key in config) {
+      var _config$key = config[key], x = _config$key.x, y = _config$key.y;
+      x !== void 0 && y !== void 0 && (configX[key] = x, configY[key] = y);
+    }
+    var aX = anim(value.x, configX), aY = anim(value.y, configY);
+    return parallel([
+      aX,
+      aY
+    ], {
+      stopTogether: !1
+    });
+  } else if (value instanceof AnimatedColor) {
+    var configR = {
+      ...config
+    }, configG = {
+      ...config
+    }, configB = {
+      ...config
+    }, configA = {
+      ...config
     };
-  },
-  sequence = function (animations) {
-    var current = 0;
-    return {
-      start: function (callback) {
-        var onComplete = function onComplete2(result) {
-          if (!result.finished) {
-            callback && callback(result);
-            return;
-          }
-          if (current++, current === animations.length) {
-            callback && callback(result);
-            return;
-          }
-          animations[current].start(onComplete2);
-        };
-        animations.length === 0 ? callback && callback({
+    for (var _key in config) {
+      var _config$_key = config[_key], r = _config$_key.r, g = _config$_key.g, b = _config$_key.b, a = _config$_key.a;
+      r !== void 0 && g !== void 0 && b !== void 0 && a !== void 0 && (configR[_key] = r, configG[_key] = g, configB[_key] = b, configA[_key] = a);
+    }
+    var aR = anim(value.r, configR), aG = anim(value.g, configG), aB = anim(value.b, configB), aA = anim(value.a, configA);
+    return parallel([
+      aR,
+      aG,
+      aB,
+      aA
+    ], {
+      stopTogether: !1
+    });
+  }
+  return null;
+}, spring = function spring2(value, config) {
+  var _start = function(animatedValue, configuration, callback) {
+    callback = _combineCallbacks(callback, configuration);
+    var singleValue = animatedValue, singleConfig = configuration;
+    singleValue.stopTracking(), configuration.toValue instanceof AnimatedNode ? singleValue.track(new AnimatedTracking(singleValue, configuration.toValue, SpringAnimation, singleConfig, callback)) : singleValue.animate(new SpringAnimation(singleConfig), callback);
+  };
+  return maybeVectorAnim(value, config, spring2) || {
+    start: function(callback) {
+      _start(value, config, callback);
+    },
+    stop: function() {
+      value.stopAnimation();
+    },
+    reset: function() {
+      value.resetAnimation();
+    },
+    _startNativeLoop: function(iterations) {
+      var singleConfig = {
+        ...config,
+        iterations
+      };
+      _start(value, singleConfig);
+    },
+    _isUsingNativeDriver: function() {
+      return config.useNativeDriver || !1;
+    }
+  };
+}, timing = function timing2(value, config) {
+  var _start2 = function(animatedValue, configuration, callback) {
+    callback = _combineCallbacks(callback, configuration);
+    var singleValue = animatedValue, singleConfig = configuration;
+    singleValue.stopTracking(), configuration.toValue instanceof AnimatedNode ? singleValue.track(new AnimatedTracking(singleValue, configuration.toValue, TimingAnimation, singleConfig, callback)) : singleValue.animate(new TimingAnimation(singleConfig), callback);
+  };
+  return maybeVectorAnim(value, config, timing2) || {
+    start: function(callback) {
+      _start2(value, config, callback);
+    },
+    stop: function() {
+      value.stopAnimation();
+    },
+    reset: function() {
+      value.resetAnimation();
+    },
+    _startNativeLoop: function(iterations) {
+      var singleConfig = {
+        ...config,
+        iterations
+      };
+      _start2(value, singleConfig);
+    },
+    _isUsingNativeDriver: function() {
+      return config.useNativeDriver || !1;
+    }
+  };
+}, decay = function decay2(value, config) {
+  var _start3 = function(animatedValue, configuration, callback) {
+    callback = _combineCallbacks(callback, configuration);
+    var singleValue = animatedValue, singleConfig = configuration;
+    singleValue.stopTracking(), singleValue.animate(new DecayAnimation(singleConfig), callback);
+  };
+  return maybeVectorAnim(value, config, decay2) || {
+    start: function(callback) {
+      _start3(value, config, callback);
+    },
+    stop: function() {
+      value.stopAnimation();
+    },
+    reset: function() {
+      value.resetAnimation();
+    },
+    _startNativeLoop: function(iterations) {
+      var singleConfig = {
+        ...config,
+        iterations
+      };
+      _start3(value, singleConfig);
+    },
+    _isUsingNativeDriver: function() {
+      return config.useNativeDriver || !1;
+    }
+  };
+}, sequence = function(animations) {
+  var current = 0;
+  return {
+    start: function(callback) {
+      var onComplete = function onComplete2(result) {
+        if (!result.finished) {
+          callback && callback(result);
+          return;
+        }
+        if (current++, current === animations.length) {
+          callback && callback(result);
+          return;
+        }
+        animations[current].start(onComplete2);
+      };
+      animations.length === 0 ? callback && callback({
+        finished: !0
+      }) : animations[current].start(onComplete);
+    },
+    stop: function() {
+      current < animations.length && animations[current].stop();
+    },
+    reset: function() {
+      animations.forEach(function(animation, idx) {
+        idx <= current && animation.reset();
+      }), current = 0;
+    },
+    _startNativeLoop: function() {
+      throw new Error("Loops run using the native driver cannot contain Animated.sequence animations");
+    },
+    _isUsingNativeDriver: function() {
+      return !1;
+    }
+  };
+}, parallel = function(animations, config) {
+  var doneCount = 0, hasEnded = {}, stopTogether = !(config && config.stopTogether === !1), result = {
+    start: function(callback) {
+      if (doneCount === animations.length) {
+        callback && callback({
           finished: !0
-        }) : animations[current].start(onComplete);
-      },
-      stop: function () {
-        current < animations.length && animations[current].stop();
-      },
-      reset: function () {
-        animations.forEach(function (animation, idx) {
-          idx <= current && animation.reset();
-        }), current = 0;
-      },
-      _startNativeLoop: function () {
-        throw new Error("Loops run using the native driver cannot contain Animated.sequence animations");
-      },
-      _isUsingNativeDriver: function () {
-        return !1;
+        });
+        return;
       }
-    };
-  },
-  parallel = function (animations, config) {
-    var doneCount = 0,
-      hasEnded = {},
-      stopTogether = !(config && config.stopTogether === !1),
-      result = {
-        start: function (callback) {
-          if (doneCount === animations.length) {
-            callback && callback({
-              finished: !0
-            });
+      animations.forEach(function(animation, idx) {
+        var cb = function(endResult) {
+          if (hasEnded[idx] = !0, doneCount++, doneCount === animations.length) {
+            doneCount = 0, callback && callback(endResult);
             return;
           }
-          animations.forEach(function (animation, idx) {
-            var cb = function (endResult) {
-              if (hasEnded[idx] = !0, doneCount++, doneCount === animations.length) {
-                doneCount = 0, callback && callback(endResult);
-                return;
-              }
-              !endResult.finished && stopTogether && result.stop();
-            };
-            animation ? animation.start(cb) : cb({
-              finished: !0
-            });
-          });
-        },
-        stop: function () {
-          animations.forEach(function (animation, idx) {
-            !hasEnded[idx] && animation.stop(), hasEnded[idx] = !0;
-          });
-        },
-        reset: function () {
-          animations.forEach(function (animation, idx) {
-            animation.reset(), hasEnded[idx] = !1, doneCount = 0;
-          });
-        },
-        _startNativeLoop: function () {
-          throw new Error("Loops run using the native driver cannot contain Animated.parallel animations");
-        },
-        _isUsingNativeDriver: function () {
-          return !1;
-        }
-      };
-    return result;
-  },
-  delay = function (time) {
-    return timing(new AnimatedValue(0), {
-      toValue: 0,
-      delay: time,
-      duration: 0,
-      useNativeDriver: !1
-    });
-  },
-  stagger = function (time, animations) {
-    return parallel(animations.map(function (animation, i) {
-      return sequence([delay(time * i), animation]);
-    }));
-  },
-  loop = function (animation, _temp) {
-    var _ref = _temp === void 0 ? {} : _temp,
-      _ref$iterations = _ref.iterations,
-      iterations = _ref$iterations === void 0 ? -1 : _ref$iterations,
-      _ref$resetBeforeItera = _ref.resetBeforeIteration,
-      resetBeforeIteration = _ref$resetBeforeItera === void 0 ? !0 : _ref$resetBeforeItera,
-      isFinished = !1,
-      iterationsSoFar = 0;
-    return {
-      start: function (callback) {
-        var restart = function restart2(result) {
-          result === void 0 && (result = {
-            finished: !0
-          }), isFinished || iterationsSoFar === iterations || result.finished === !1 ? callback && callback(result) : (iterationsSoFar++, resetBeforeIteration && animation.reset(), animation.start(restart2));
+          !endResult.finished && stopTogether && result.stop();
         };
-        !animation || iterations === 0 ? callback && callback({
+        animation ? animation.start(cb) : cb({
           finished: !0
-        }) : animation._isUsingNativeDriver() ? animation._startNativeLoop(iterations) : restart();
-      },
-      // Start looping recursively on the js thread
-      stop: function () {
-        isFinished = !0, animation.stop();
-      },
-      reset: function () {
-        iterationsSoFar = 0, isFinished = !1, animation.reset();
-      },
-      _startNativeLoop: function () {
-        throw new Error("Loops run using the native driver cannot contain Animated.loop animations");
-      },
-      _isUsingNativeDriver: function () {
-        return animation._isUsingNativeDriver();
-      }
-    };
+        });
+      });
+    },
+    stop: function() {
+      animations.forEach(function(animation, idx) {
+        !hasEnded[idx] && animation.stop(), hasEnded[idx] = !0;
+      });
+    },
+    reset: function() {
+      animations.forEach(function(animation, idx) {
+        animation.reset(), hasEnded[idx] = !1, doneCount = 0;
+      });
+    },
+    _startNativeLoop: function() {
+      throw new Error("Loops run using the native driver cannot contain Animated.parallel animations");
+    },
+    _isUsingNativeDriver: function() {
+      return !1;
+    }
   };
+  return result;
+}, delay = function(time) {
+  return timing(new AnimatedValue(0), {
+    toValue: 0,
+    delay: time,
+    duration: 0,
+    useNativeDriver: !1
+  });
+}, stagger = function(time, animations) {
+  return parallel(animations.map(function(animation, i) {
+    return sequence([
+      delay(time * i),
+      animation
+    ]);
+  }));
+}, loop = function(animation, _temp) {
+  var _ref = _temp === void 0 ? {} : _temp, _ref$iterations = _ref.iterations, iterations = _ref$iterations === void 0 ? -1 : _ref$iterations, _ref$resetBeforeItera = _ref.resetBeforeIteration, resetBeforeIteration = _ref$resetBeforeItera === void 0 ? !0 : _ref$resetBeforeItera, isFinished = !1, iterationsSoFar = 0;
+  return {
+    start: function(callback) {
+      var restart = function restart2(result) {
+        result === void 0 && (result = {
+          finished: !0
+        }), isFinished || iterationsSoFar === iterations || result.finished === !1 ? callback && callback(result) : (iterationsSoFar++, resetBeforeIteration && animation.reset(), animation.start(restart2));
+      };
+      !animation || iterations === 0 ? callback && callback({
+        finished: !0
+      }) : animation._isUsingNativeDriver() ? animation._startNativeLoop(iterations) : restart();
+    },
+    // Start looping recursively on the js thread
+    stop: function() {
+      isFinished = !0, animation.stop();
+    },
+    reset: function() {
+      iterationsSoFar = 0, isFinished = !1, animation.reset();
+    },
+    _startNativeLoop: function() {
+      throw new Error("Loops run using the native driver cannot contain Animated.loop animations");
+    },
+    _isUsingNativeDriver: function() {
+      return animation._isUsingNativeDriver();
+    }
+  };
+};
 function forkEvent(event3, listener) {
-  return event3 ? event3 instanceof AnimatedEvent ? (event3.__addListener(listener), event3) : function () {
+  return event3 ? event3 instanceof AnimatedEvent ? (event3.__addListener(listener), event3) : function() {
     typeof event3 == "function" && event3(...arguments), listener(...arguments);
   } : listener;
 }
 function unforkEvent(event3, listener) {
   event3 && event3 instanceof AnimatedEvent && event3.__removeListener(listener);
 }
-var event = function (argMapping, config) {
-    var animatedEvent = new AnimatedEvent(argMapping, config);
-    return animatedEvent.__isNative ? animatedEvent : animatedEvent.__getHandler();
-  },
-  AnimatedImplementation_default = {
-    /**
-    * Standard value class for driving animations.  Typically initialized with
-    * `new Animated.Value(0);`
-    *
-    * See https://reactnative.dev/docs/animated#value
-    */
-    Value: AnimatedValue,
-    /**
-    * 2D value class for driving 2D animations, such as pan gestures.
-    *
-    * See https://reactnative.dev/docs/animatedvaluexy
-    */
-    ValueXY: AnimatedValueXY,
-    /**
-    * Value class for driving color animations.
-    */
-    Color: AnimatedColor,
-    /**
-    * Exported to use the Interpolation type in flow.
-    *
-    * See https://reactnative.dev/docs/animated#interpolation
-    */
-    Interpolation: AnimatedInterpolation,
-    /**
-    * Exported for ease of type checking. All animated values derive from this
-    * class.
-    *
-    * See https://reactnative.dev/docs/animated#node
-    */
-    Node: AnimatedNode,
-    /**
-    * Animates a value from an initial velocity to zero based on a decay
-    * coefficient.
-    *
-    * See https://reactnative.dev/docs/animated#decay
-    */
-    decay,
-    /**
-    * Animates a value along a timed easing curve. The Easing module has tons of
-    * predefined curves, or you can use your own function.
-    *
-    * See https://reactnative.dev/docs/animated#timing
-    */
-    timing,
-    /**
-    * Animates a value according to an analytical spring model based on
-    * damped harmonic oscillation.
-    *
-    * See https://reactnative.dev/docs/animated#spring
-    */
-    spring,
-    /**
-    * Creates a new Animated value composed from two Animated values added
-    * together.
-    *
-    * See https://reactnative.dev/docs/animated#add
-    */
-    add,
-    /**
-    * Creates a new Animated value composed by subtracting the second Animated
-    * value from the first Animated value.
-    *
-    * See https://reactnative.dev/docs/animated#subtract
-    */
-    subtract,
-    /**
-    * Creates a new Animated value composed by dividing the first Animated value
-    * by the second Animated value.
-    *
-    * See https://reactnative.dev/docs/animated#divide
-    */
-    divide,
-    /**
-    * Creates a new Animated value composed from two Animated values multiplied
-    * together.
-    *
-    * See https://reactnative.dev/docs/animated#multiply
-    */
-    multiply,
-    /**
-    * Creates a new Animated value that is the (non-negative) modulo of the
-    * provided Animated value.
-    *
-    * See https://reactnative.dev/docs/animated#modulo
-    */
-    modulo,
-    /**
-    * Create a new Animated value that is limited between 2 values. It uses the
-    * difference between the last value so even if the value is far from the
-    * bounds it will start changing when the value starts getting closer again.
-    *
-    * See https://reactnative.dev/docs/animated#diffclamp
-    */
-    diffClamp,
-    /**
-    * Starts an animation after the given delay.
-    *
-    * See https://reactnative.dev/docs/animated#delay
-    */
-    delay,
-    /**
-    * Starts an array of animations in order, waiting for each to complete
-    * before starting the next. If the current running animation is stopped, no
-    * following animations will be started.
-    *
-    * See https://reactnative.dev/docs/animated#sequence
-    */
-    sequence,
-    /**
-    * Starts an array of animations all at the same time. By default, if one
-    * of the animations is stopped, they will all be stopped. You can override
-    * this with the `stopTogether` flag.
-    *
-    * See https://reactnative.dev/docs/animated#parallel
-    */
-    parallel,
-    /**
-    * Array of animations may run in parallel (overlap), but are started in
-    * sequence with successive delays.  Nice for doing trailing effects.
-    *
-    * See https://reactnative.dev/docs/animated#stagger
-    */
-    stagger,
-    /**
-    * Loops a given animation continuously, so that each time it reaches the
-    * end, it resets and begins again from the start.
-    *
-    * See https://reactnative.dev/docs/animated#loop
-    */
-    loop,
-    /**
-    * Takes an array of mappings and extracts values from each arg accordingly,
-    * then calls `setValue` on the mapped outputs.
-    *
-    * See https://reactnative.dev/docs/animated#event
-    */
-    event,
-    /**
-    * Make any React component Animatable.  Used to create `Animated.View`, etc.
-    *
-    * See https://reactnative.dev/docs/animated#createanimatedcomponent
-    */
-    createAnimatedComponent,
-    /**
-    * Imperative API to attach an animated value to an event on a view. Prefer
-    * using `Animated.event` with `useNativeDrive: true` if possible.
-    *
-    * See https://reactnative.dev/docs/animated#attachnativeevent
-    */
-    attachNativeEvent,
-    /**
-    * Advanced imperative API for snooping on animated events that are passed in
-    * through props. Use values directly where possible.
-    *
-    * See https://reactnative.dev/docs/animated#forkevent
-    */
-    forkEvent,
-    unforkEvent,
-    /**
-    * Expose Event class, so it can be used as a type for type checkers.
-    */
-    Event: AnimatedEvent
-  };
-export { AnimatedImplementation_default as default };
-//# sourceMappingURL=AnimatedImplementation.native.js.map
+var event = function(argMapping, config) {
+  var animatedEvent = new AnimatedEvent(argMapping, config);
+  return animatedEvent.__isNative ? animatedEvent : animatedEvent.__getHandler();
+}, AnimatedImplementation_default = {
+  /**
+  * Standard value class for driving animations.  Typically initialized with
+  * `new Animated.Value(0);`
+  *
+  * See https://reactnative.dev/docs/animated#value
+  */
+  Value: AnimatedValue,
+  /**
+  * 2D value class for driving 2D animations, such as pan gestures.
+  *
+  * See https://reactnative.dev/docs/animatedvaluexy
+  */
+  ValueXY: AnimatedValueXY,
+  /**
+  * Value class for driving color animations.
+  */
+  Color: AnimatedColor,
+  /**
+  * Exported to use the Interpolation type in flow.
+  *
+  * See https://reactnative.dev/docs/animated#interpolation
+  */
+  Interpolation: AnimatedInterpolation,
+  /**
+  * Exported for ease of type checking. All animated values derive from this
+  * class.
+  *
+  * See https://reactnative.dev/docs/animated#node
+  */
+  Node: AnimatedNode,
+  /**
+  * Animates a value from an initial velocity to zero based on a decay
+  * coefficient.
+  *
+  * See https://reactnative.dev/docs/animated#decay
+  */
+  decay,
+  /**
+  * Animates a value along a timed easing curve. The Easing module has tons of
+  * predefined curves, or you can use your own function.
+  *
+  * See https://reactnative.dev/docs/animated#timing
+  */
+  timing,
+  /**
+  * Animates a value according to an analytical spring model based on
+  * damped harmonic oscillation.
+  *
+  * See https://reactnative.dev/docs/animated#spring
+  */
+  spring,
+  /**
+  * Creates a new Animated value composed from two Animated values added
+  * together.
+  *
+  * See https://reactnative.dev/docs/animated#add
+  */
+  add,
+  /**
+  * Creates a new Animated value composed by subtracting the second Animated
+  * value from the first Animated value.
+  *
+  * See https://reactnative.dev/docs/animated#subtract
+  */
+  subtract,
+  /**
+  * Creates a new Animated value composed by dividing the first Animated value
+  * by the second Animated value.
+  *
+  * See https://reactnative.dev/docs/animated#divide
+  */
+  divide,
+  /**
+  * Creates a new Animated value composed from two Animated values multiplied
+  * together.
+  *
+  * See https://reactnative.dev/docs/animated#multiply
+  */
+  multiply,
+  /**
+  * Creates a new Animated value that is the (non-negative) modulo of the
+  * provided Animated value.
+  *
+  * See https://reactnative.dev/docs/animated#modulo
+  */
+  modulo,
+  /**
+  * Create a new Animated value that is limited between 2 values. It uses the
+  * difference between the last value so even if the value is far from the
+  * bounds it will start changing when the value starts getting closer again.
+  *
+  * See https://reactnative.dev/docs/animated#diffclamp
+  */
+  diffClamp,
+  /**
+  * Starts an animation after the given delay.
+  *
+  * See https://reactnative.dev/docs/animated#delay
+  */
+  delay,
+  /**
+  * Starts an array of animations in order, waiting for each to complete
+  * before starting the next. If the current running animation is stopped, no
+  * following animations will be started.
+  *
+  * See https://reactnative.dev/docs/animated#sequence
+  */
+  sequence,
+  /**
+  * Starts an array of animations all at the same time. By default, if one
+  * of the animations is stopped, they will all be stopped. You can override
+  * this with the `stopTogether` flag.
+  *
+  * See https://reactnative.dev/docs/animated#parallel
+  */
+  parallel,
+  /**
+  * Array of animations may run in parallel (overlap), but are started in
+  * sequence with successive delays.  Nice for doing trailing effects.
+  *
+  * See https://reactnative.dev/docs/animated#stagger
+  */
+  stagger,
+  /**
+  * Loops a given animation continuously, so that each time it reaches the
+  * end, it resets and begins again from the start.
+  *
+  * See https://reactnative.dev/docs/animated#loop
+  */
+  loop,
+  /**
+  * Takes an array of mappings and extracts values from each arg accordingly,
+  * then calls `setValue` on the mapped outputs.
+  *
+  * See https://reactnative.dev/docs/animated#event
+  */
+  event,
+  /**
+  * Make any React component Animatable.  Used to create `Animated.View`, etc.
+  *
+  * See https://reactnative.dev/docs/animated#createanimatedcomponent
+  */
+  createAnimatedComponent,
+  /**
+  * Imperative API to attach an animated value to an event on a view. Prefer
+  * using `Animated.event` with `useNativeDrive: true` if possible.
+  *
+  * See https://reactnative.dev/docs/animated#attachnativeevent
+  */
+  attachNativeEvent,
+  /**
+  * Advanced imperative API for snooping on animated events that are passed in
+  * through props. Use values directly where possible.
+  *
+  * See https://reactnative.dev/docs/animated#forkevent
+  */
+  forkEvent,
+  unforkEvent,
+  /**
+  * Expose Event class, so it can be used as a type for type checkers.
+  */
+  Event: AnimatedEvent
+};
+export {
+  AnimatedImplementation_default as default
+};
+//# sourceMappingURL=AnimatedImplementation.js.map