@tamagui/react-native-web-lite 2.0.0-rc.4 → 2.0.0-rc.40

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

@@ -1,4 +1,7 @@
 import { AnimatedEvent, attachNativeEvent } from "./AnimatedEvent.mjs";
+import { DecayAnimation } from "./animations/DecayAnimation.mjs";
+import { SpringAnimation } from "./animations/SpringAnimation.mjs";
+import { TimingAnimation } from "./animations/TimingAnimation.mjs";
 import { AnimatedAddition } from "./nodes/AnimatedAddition.mjs";
 import { AnimatedDiffClamp } from "./nodes/AnimatedDiffClamp.mjs";
 import { AnimatedDivision } from "./nodes/AnimatedDivision.mjs";
@@ -6,476 +9,550 @@ import { AnimatedInterpolation } from "./nodes/AnimatedInterpolation.mjs";
 import { AnimatedModulo } from "./nodes/AnimatedModulo.mjs";
 import { AnimatedMultiplication } from "./nodes/AnimatedMultiplication.mjs";
 import { AnimatedNode } from "./nodes/AnimatedNode.mjs";
-import "./nodes/AnimatedProps.mjs";
 import { AnimatedSubtraction } from "./nodes/AnimatedSubtraction.mjs";
 import { AnimatedTracking } from "./nodes/AnimatedTracking.mjs";
 import { AnimatedValue } from "./nodes/AnimatedValue.mjs";
 import { AnimatedValueXY } from "./nodes/AnimatedValueXY.mjs";
-import { DecayAnimation } from "./animations/DecayAnimation.mjs";
-import { SpringAnimation } from "./animations/SpringAnimation.mjs";
-import { TimingAnimation } from "./animations/TimingAnimation.mjs";
 import { createAnimatedComponent } from "./createAnimatedComponent.mjs";
-import "./animations/Animation.mjs";
 import { AnimatedColor } from "./nodes/AnimatedColor.mjs";
 const 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 ? (...args) => {
-      config.onComplete && config.onComplete(...args), callback && callback(...args);
-    } : callback || config.onComplete;
-  },
-  maybeVectorAnim = function (value, config, anim) {
-    if (value instanceof AnimatedValueXY) {
-      const configX = {
-          ...config
-        },
-        configY = {
-          ...config
-        };
-      for (const key in config) {
-        const {
-          x,
-          y
-        } = config[key];
-        x !== void 0 && y !== void 0 && (configX[key] = x, configY[key] = y);
-      }
-      const aX = anim(value.x, configX),
-        aY = anim(value.y, configY);
-      return parallel([aX, aY], {
-        stopTogether: !1
-      });
-    } else if (value instanceof AnimatedColor) {
-      const configR = {
-          ...config
-        },
-        configG = {
-          ...config
-        },
-        configB = {
-          ...config
-        },
-        configA = {
-          ...config
-        };
-      for (const key in config) {
-        const {
-          r,
-          g,
-          b,
-          a
-        } = config[key];
-        r !== void 0 && g !== void 0 && b !== void 0 && a !== void 0 && (configR[key] = r, configG[key] = g, configB[key] = b, configA[key] = a);
-      }
-      const 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 (value, config) {
-    const start = function (animatedValue, configuration, callback) {
-      callback = _combineCallbacks(callback, configuration);
-      const 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 new AnimatedAddition(a, b);
+};
+const subtract = function (a, b) {
+  return new AnimatedSubtraction(a, b);
+};
+const divide = function (a, b) {
+  return new AnimatedDivision(a, b);
+};
+const multiply = function (a, b) {
+  return new AnimatedMultiplication(a, b);
+};
+const modulo = function (a, modulus) {
+  return new AnimatedModulo(a, modulus);
+};
+const diffClamp = function (a, min, max) {
+  return new AnimatedDiffClamp(a, min, max);
+};
+const _combineCallbacks = function (callback, config) {
+  if (callback && config.onComplete) {
+    return (...args) => {
+      config.onComplete && config.onComplete(...args);
+      callback && callback(...args);
     };
-    return maybeVectorAnim(value, config, spring) || {
-      start: function (callback) {
-        start(value, config, callback);
-      },
-      stop: function () {
-        value.stopAnimation();
-      },
-      reset: function () {
-        value.resetAnimation();
-      },
-      _startNativeLoop: function (iterations) {
-        const singleConfig = {
-          ...config,
-          iterations
-        };
-        start(value, singleConfig);
-      },
-      _isUsingNativeDriver: function () {
-        return config.useNativeDriver || !1;
-      }
+  } else {
+    return callback || config.onComplete;
+  }
+};
+const maybeVectorAnim = function (value, config, anim) {
+  if (value instanceof AnimatedValueXY) {
+    const configX = {
+      ...config
     };
-  },
-  timing = function (value, config) {
-    const start = function (animatedValue, configuration, callback) {
-      callback = _combineCallbacks(callback, configuration);
-      const 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);
+    const configY = {
+      ...config
     };
-    return maybeVectorAnim(value, config, timing) || {
-      start: function (callback) {
-        start(value, config, callback);
-      },
-      stop: function () {
-        value.stopAnimation();
-      },
-      reset: function () {
-        value.resetAnimation();
-      },
-      _startNativeLoop: function (iterations) {
-        const singleConfig = {
-          ...config,
-          iterations
-        };
-        start(value, singleConfig);
-      },
-      _isUsingNativeDriver: function () {
-        return config.useNativeDriver || !1;
+    for (const key in config) {
+      const {
+        x,
+        y
+      } = config[key];
+      if (x !== void 0 && y !== void 0) {
+        configX[key] = x;
+        configY[key] = y;
       }
+    }
+    const aX = anim(value.x, configX);
+    const aY = anim(value.y, configY);
+    return parallel([aX, aY], {
+      stopTogether: false
+    });
+  } else if (value instanceof AnimatedColor) {
+    const configR = {
+      ...config
     };
-  },
-  decay = function (value, config) {
-    const start = function (animatedValue, configuration, callback) {
-      callback = _combineCallbacks(callback, configuration);
-      const singleValue = animatedValue,
-        singleConfig = configuration;
-      singleValue.stopTracking(), singleValue.animate(new DecayAnimation(singleConfig), callback);
+    const configG = {
+      ...config
     };
-    return maybeVectorAnim(value, config, decay) || {
-      start: function (callback) {
-        start(value, config, callback);
-      },
-      stop: function () {
-        value.stopAnimation();
-      },
-      reset: function () {
-        value.resetAnimation();
-      },
-      _startNativeLoop: function (iterations) {
-        const singleConfig = {
-          ...config,
-          iterations
-        };
-        start(value, singleConfig);
-      },
-      _isUsingNativeDriver: function () {
-        return config.useNativeDriver || !1;
-      }
+    const configB = {
+      ...config
     };
-  },
-  sequence = function (animations) {
-    let current = 0;
-    return {
-      start: function (callback) {
-        const onComplete = function (result) {
-          if (!result.finished) {
-            callback && callback(result);
-            return;
-          }
-          if (current++, current === animations.length) {
-            callback && callback(result);
-            return;
-          }
-          animations[current].start(onComplete);
-        };
-        animations.length === 0 ? callback && callback({
-          finished: !0
-        }) : animations[current].start(onComplete);
-      },
-      stop: function () {
-        current < animations.length && animations[current].stop();
-      },
-      reset: function () {
-        animations.forEach((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;
-      }
+    const configA = {
+      ...config
     };
-  },
-  parallel = function (animations, config) {
-    let doneCount = 0;
-    const hasEnded = {},
-      stopTogether = !(config && config.stopTogether === !1),
-      result = {
-        start: function (callback) {
+    for (const key in config) {
+      const {
+        r,
+        g,
+        b,
+        a
+      } = config[key];
+      if (r !== void 0 && g !== void 0 && b !== void 0 && a !== void 0) {
+        configR[key] = r;
+        configG[key] = g;
+        configB[key] = b;
+        configA[key] = a;
+      }
+    }
+    const aR = anim(value.r, configR);
+    const aG = anim(value.g, configG);
+    const aB = anim(value.b, configB);
+    const aA = anim(value.a, configA);
+    return parallel([aR, aG, aB, aA], {
+      stopTogether: false
+    });
+  }
+  return null;
+};
+const spring = function (value, config) {
+  const start = function (animatedValue, configuration, callback) {
+    callback = _combineCallbacks(callback, configuration);
+    const singleValue = animatedValue;
+    const singleConfig = configuration;
+    singleValue.stopTracking();
+    if (configuration.toValue instanceof AnimatedNode) {
+      singleValue.track(new AnimatedTracking(singleValue, configuration.toValue, SpringAnimation, singleConfig, callback));
+    } else {
+      singleValue.animate(new SpringAnimation(singleConfig), callback);
+    }
+  };
+  return maybeVectorAnim(value, config, spring) || {
+    start: function (callback) {
+      start(value, config, callback);
+    },
+    stop: function () {
+      value.stopAnimation();
+    },
+    reset: function () {
+      value.resetAnimation();
+    },
+    _startNativeLoop: function (iterations) {
+      const singleConfig = {
+        ...config,
+        iterations
+      };
+      start(value, singleConfig);
+    },
+    _isUsingNativeDriver: function () {
+      return config.useNativeDriver || false;
+    }
+  };
+};
+const timing = function (value, config) {
+  const start = function (animatedValue, configuration, callback) {
+    callback = _combineCallbacks(callback, configuration);
+    const singleValue = animatedValue;
+    const singleConfig = configuration;
+    singleValue.stopTracking();
+    if (configuration.toValue instanceof AnimatedNode) {
+      singleValue.track(new AnimatedTracking(singleValue, configuration.toValue, TimingAnimation, singleConfig, callback));
+    } else {
+      singleValue.animate(new TimingAnimation(singleConfig), callback);
+    }
+  };
+  return maybeVectorAnim(value, config, timing) || {
+    start: function (callback) {
+      start(value, config, callback);
+    },
+    stop: function () {
+      value.stopAnimation();
+    },
+    reset: function () {
+      value.resetAnimation();
+    },
+    _startNativeLoop: function (iterations) {
+      const singleConfig = {
+        ...config,
+        iterations
+      };
+      start(value, singleConfig);
+    },
+    _isUsingNativeDriver: function () {
+      return config.useNativeDriver || false;
+    }
+  };
+};
+const decay = function (value, config) {
+  const start = function (animatedValue, configuration, callback) {
+    callback = _combineCallbacks(callback, configuration);
+    const singleValue = animatedValue;
+    const singleConfig = configuration;
+    singleValue.stopTracking();
+    singleValue.animate(new DecayAnimation(singleConfig), callback);
+  };
+  return maybeVectorAnim(value, config, decay) || {
+    start: function (callback) {
+      start(value, config, callback);
+    },
+    stop: function () {
+      value.stopAnimation();
+    },
+    reset: function () {
+      value.resetAnimation();
+    },
+    _startNativeLoop: function (iterations) {
+      const singleConfig = {
+        ...config,
+        iterations
+      };
+      start(value, singleConfig);
+    },
+    _isUsingNativeDriver: function () {
+      return config.useNativeDriver || false;
+    }
+  };
+};
+const sequence = function (animations) {
+  let current = 0;
+  return {
+    start: function (callback) {
+      const onComplete = function (result) {
+        if (!result.finished) {
+          callback && callback(result);
+          return;
+        }
+        current++;
+        if (current === animations.length) {
+          callback && callback(result);
+          return;
+        }
+        animations[current].start(onComplete);
+      };
+      if (animations.length === 0) {
+        callback && callback({
+          finished: true
+        });
+      } else {
+        animations[current].start(onComplete);
+      }
+    },
+    stop: function () {
+      if (current < animations.length) {
+        animations[current].stop();
+      }
+    },
+    reset: function () {
+      animations.forEach((animation, idx) => {
+        if (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 false;
+    }
+  };
+};
+const parallel = function (animations, config) {
+  let doneCount = 0;
+  const hasEnded = {};
+  const stopTogether = !(config && config.stopTogether === false);
+  const result = {
+    start: function (callback) {
+      if (doneCount === animations.length) {
+        callback && callback({
+          finished: true
+        });
+        return;
+      }
+      animations.forEach((animation, idx) => {
+        const cb = function (endResult) {
+          hasEnded[idx] = true;
+          doneCount++;
           if (doneCount === animations.length) {
-            callback && callback({
-              finished: !0
-            });
+            doneCount = 0;
+            callback && callback(endResult);
             return;
           }
-          animations.forEach((animation, idx) => {
-            const 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((animation, idx) => {
-            !hasEnded[idx] && animation.stop(), hasEnded[idx] = !0;
-          });
-        },
-        reset: function () {
-          animations.forEach((animation, idx) => {
-            animation.reset(), hasEnded[idx] = !1, doneCount = 0;
+          if (!endResult.finished && stopTogether) {
+            result.stop();
+          }
+        };
+        if (!animation) {
+          cb({
+            finished: true
           });
-        },
-        _startNativeLoop: function () {
-          throw new Error("Loops run using the native driver cannot contain Animated.parallel animations");
-        },
-        _isUsingNativeDriver: function () {
-          return !1;
+        } else {
+          animation.start(cb);
+        }
+      });
+    },
+    stop: function () {
+      animations.forEach((animation, idx) => {
+        !hasEnded[idx] && animation.stop();
+        hasEnded[idx] = true;
+      });
+    },
+    reset: function () {
+      animations.forEach((animation, idx) => {
+        animation.reset();
+        hasEnded[idx] = false;
+        doneCount = 0;
+      });
+    },
+    _startNativeLoop: function () {
+      throw new Error("Loops run using the native driver cannot contain Animated.parallel animations");
+    },
+    _isUsingNativeDriver: function () {
+      return false;
+    }
+  };
+  return result;
+};
+const delay = function (time) {
+  return timing(new AnimatedValue(0), {
+    toValue: 0,
+    delay: time,
+    duration: 0,
+    useNativeDriver: false
+  });
+};
+const stagger = function (time, animations) {
+  return parallel(animations.map((animation, i) => {
+    return sequence([delay(time * i), animation]);
+  }));
+};
+const loop = function (animation, {
+  iterations = -1,
+  resetBeforeIteration = true
+} = {}) {
+  let isFinished = false;
+  let iterationsSoFar = 0;
+  return {
+    start: function (callback) {
+      const restart = function (result = {
+        finished: true
+      }) {
+        if (isFinished || iterationsSoFar === iterations || result.finished === false) {
+          callback && callback(result);
+        } else {
+          iterationsSoFar++;
+          resetBeforeIteration && animation.reset();
+          animation.start(restart);
         }
       };
-    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((animation, i) => sequence([delay(time * i), animation])));
-  },
-  loop = function (animation, {
-    iterations = -1,
-    resetBeforeIteration = !0
-  } = {}) {
-    let isFinished = !1,
-      iterationsSoFar = 0;
-    return {
-      start: function (callback) {
-        const restart = function (result = {
-          finished: !0
-        }) {
-          isFinished || iterationsSoFar === iterations || result.finished === !1 ? callback && callback(result) : (iterationsSoFar++, resetBeforeIteration && animation.reset(), animation.start(restart));
-        };
-        !animation || iterations === 0 ? callback && callback({
-          finished: !0
-        }) : animation._isUsingNativeDriver() ? animation._startNativeLoop(iterations) : restart();
-      },
-      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();
+      if (!animation || iterations === 0) {
+        callback && callback({
+          finished: true
+        });
+      } else {
+        if (animation._isUsingNativeDriver()) {
+          animation._startNativeLoop(iterations);
+        } else {
+          restart();
+        }
       }
-    };
+    },
+    stop: function () {
+      isFinished = true;
+      animation.stop();
+    },
+    reset: function () {
+      iterationsSoFar = 0;
+      isFinished = false;
+      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(event2, listener) {
-  return event2 ? event2 instanceof AnimatedEvent ? (event2.__addListener(listener), event2) : (...args) => {
-    typeof event2 == "function" && event2(...args), listener(...args);
-  } : listener;
+  if (!event2) {
+    return listener;
+  } else if (event2 instanceof AnimatedEvent) {
+    event2.__addListener(listener);
+    return event2;
+  } else {
+    return (...args) => {
+      typeof event2 === "function" && event2(...args);
+      listener(...args);
+    };
+  }
 }
 function unforkEvent(event2, listener) {
-  event2 && event2 instanceof AnimatedEvent && event2.__removeListener(listener);
+  if (event2 && event2 instanceof AnimatedEvent) {
+    event2.__removeListener(listener);
+  }
 }
 const event = function (argMapping, config) {
-    const animatedEvent = new AnimatedEvent(argMapping, config);
-    return animatedEvent.__isNative ? animatedEvent : animatedEvent.__getHandler();
-  },
-  AnimatedImplementationExports = {
-    /**
-     * 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
-  };
+  const animatedEvent = new AnimatedEvent(argMapping, config);
+  if (animatedEvent.__isNative) {
+    return animatedEvent;
+  } else {
+    return animatedEvent.__getHandler();
+  }
+};
+const AnimatedImplementationExports = {
+  /**
+   * 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
+};
 var AnimatedImplementation_default = AnimatedImplementationExports;
 export { AnimatedImplementationExports as AnimatedImplementation, AnimatedImplementationExports, AnimatedImplementation_default as default };
 //# sourceMappingURL=AnimatedImplementation.mjs.map