@hanzogui/react-native-web-lite 2.0.0

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

@@ -0,0 +1,140 @@
+"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 AnimatedMock_exports = {};
+__export(AnimatedMock_exports, {
+  AnimatedMock: () => AnimatedMockExports,
+  AnimatedMockExports: () => AnimatedMockExports,
+  default: () => AnimatedMock_default
+});
+module.exports = __toCommonJS(AnimatedMock_exports);
+var import_AnimatedEvent = require("./AnimatedEvent.cjs"),
+  import_AnimatedImplementation = require("./AnimatedImplementation.cjs"),
+  import_AnimatedInterpolation = require("./nodes/AnimatedInterpolation.cjs"),
+  import_AnimatedNode = require("./nodes/AnimatedNode.cjs"),
+  import_AnimatedValue = require("./nodes/AnimatedValue.cjs"),
+  import_AnimatedValueXY = require("./nodes/AnimatedValueXY.cjs"),
+  import_createAnimatedComponent = require("./createAnimatedComponent.cjs"),
+  import_AnimatedColor = require("./nodes/AnimatedColor.cjs");
+let inAnimationCallback = !1;
+function mockAnimationStart(start) {
+  return callback => {
+    const guardedCallback = callback == null ? callback : (...args) => {
+      if (inAnimationCallback) {
+        console.warn("Ignoring recursive animation callback when running mock animations");
+        return;
+      }
+      inAnimationCallback = !0;
+      try {
+        callback(...args);
+      } finally {
+        inAnimationCallback = !1;
+      }
+    };
+    start(guardedCallback);
+  };
+}
+const emptyAnimation = {
+    start: () => {},
+    stop: () => {},
+    reset: () => {},
+    _startNativeLoop: () => {},
+    _isUsingNativeDriver: () => !1
+  },
+  mockCompositeAnimation = animations => ({
+    ...emptyAnimation,
+    start: mockAnimationStart(callback => {
+      animations.forEach(animation => animation.start()), callback?.({
+        finished: !0
+      });
+    })
+  }),
+  spring = function (value, config) {
+    const anyValue = value;
+    return {
+      ...emptyAnimation,
+      start: mockAnimationStart(callback => {
+        anyValue.setValue(config.toValue), callback?.({
+          finished: !0
+        });
+      })
+    };
+  },
+  timing = function (value, config) {
+    const anyValue = value;
+    return {
+      ...emptyAnimation,
+      start: mockAnimationStart(callback => {
+        anyValue.setValue(config.toValue), callback?.({
+          finished: !0
+        });
+      })
+    };
+  },
+  decay = function (value, config) {
+    return emptyAnimation;
+  },
+  sequence = function (animations) {
+    return mockCompositeAnimation(animations);
+  },
+  parallel = function (animations, config) {
+    return mockCompositeAnimation(animations);
+  },
+  delay = function (time) {
+    return emptyAnimation;
+  },
+  stagger = function (time, animations) {
+    return mockCompositeAnimation(animations);
+  },
+  loop = function (animation, {
+    iterations = -1
+  } = {}) {
+    return emptyAnimation;
+  },
+  AnimatedMockExports = {
+    Value: import_AnimatedValue.AnimatedValue,
+    ValueXY: import_AnimatedValueXY.AnimatedValueXY,
+    Color: import_AnimatedColor.AnimatedColor,
+    Interpolation: import_AnimatedInterpolation.AnimatedInterpolation,
+    Node: import_AnimatedNode.AnimatedNode,
+    decay,
+    timing,
+    spring,
+    add: import_AnimatedImplementation.AnimatedImplementation.add,
+    subtract: import_AnimatedImplementation.AnimatedImplementation.subtract,
+    divide: import_AnimatedImplementation.AnimatedImplementation.divide,
+    multiply: import_AnimatedImplementation.AnimatedImplementation.multiply,
+    modulo: import_AnimatedImplementation.AnimatedImplementation.modulo,
+    diffClamp: import_AnimatedImplementation.AnimatedImplementation.diffClamp,
+    delay,
+    sequence,
+    parallel,
+    stagger,
+    loop,
+    event: import_AnimatedImplementation.AnimatedImplementation.event,
+    createAnimatedComponent: import_createAnimatedComponent.createAnimatedComponent,
+    attachNativeEvent: import_AnimatedEvent.attachNativeEvent,
+    forkEvent: import_AnimatedImplementation.AnimatedImplementation.forkEvent,
+    unforkEvent: import_AnimatedImplementation.AnimatedImplementation.unforkEvent,
+    Event: import_AnimatedEvent.AnimatedEvent
+  };
+var AnimatedMock_default = AnimatedMockExports;

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

@@ -0,0 +1 @@
+"use strict";

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

@@ -0,0 +1,187 @@
+"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 Easing_exports = {};
+__export(Easing_exports, {
+  Easing: () => Easing,
+  default: () => Easing_default
+});
+module.exports = __toCommonJS(Easing_exports);
+var import_bezier = require("./bezier.cjs");
+let ease;
+class Easing {
+  /**
+   * A stepping function, returns 1 for any positive value of `n`.
+   */
+  static step0(n) {
+    return n > 0 ? 1 : 0;
+  }
+  /**
+   * A stepping function, returns 1 if `n` is greater than or equal to 1.
+   */
+  static step1(n) {
+    return n >= 1 ? 1 : 0;
+  }
+  /**
+   * A linear function, `f(t) = t`. Position correlates to elapsed time one to
+   * one.
+   *
+   * http://cubic-bezier.com/#0,0,1,1
+   */
+  static linear(t) {
+    return t;
+  }
+  /**
+   * A simple inertial interaction, similar to an object slowly accelerating to
+   * speed.
+   *
+   * http://cubic-bezier.com/#.42,0,1,1
+   */
+  static ease(t) {
+    return ease || (ease = Easing.bezier(0.42, 0, 1, 1)), ease(t);
+  }
+  /**
+   * A quadratic function, `f(t) = t * t`. Position equals the square of elapsed
+   * time.
+   *
+   * http://easings.net/#easeInQuad
+   */
+  static quad(t) {
+    return t * t;
+  }
+  /**
+   * A cubic function, `f(t) = t * t * t`. Position equals the cube of elapsed
+   * time.
+   *
+   * http://easings.net/#easeInCubic
+   */
+  static cubic(t) {
+    return t * t * t;
+  }
+  /**
+   * A power function. Position is equal to the Nth power of elapsed time.
+   *
+   * n = 4: http://easings.net/#easeInQuart
+   * n = 5: http://easings.net/#easeInQuint
+   */
+  static poly(n) {
+    return t => Math.pow(t, n);
+  }
+  /**
+   * A sinusoidal function.
+   *
+   * http://easings.net/#easeInSine
+   */
+  static sin(t) {
+    return 1 - Math.cos(t * Math.PI / 2);
+  }
+  /**
+   * A circular function.
+   *
+   * http://easings.net/#easeInCirc
+   */
+  static circle(t) {
+    return 1 - Math.sqrt(1 - t * t);
+  }
+  /**
+   * An exponential function.
+   *
+   * http://easings.net/#easeInExpo
+   */
+  static exp(t) {
+    return Math.pow(2, 10 * (t - 1));
+  }
+  /**
+   * A simple elastic interaction, similar to a spring oscillating back and
+   * forth.
+   *
+   * Default bounciness is 1, which overshoots a little bit once. 0 bounciness
+   * doesn't overshoot at all, and bounciness of N > 1 will overshoot about N
+   * times.
+   *
+   * http://easings.net/#easeInElastic
+   */
+  static elastic(bounciness = 1) {
+    const p = bounciness * Math.PI;
+    return t => 1 - Math.pow(Math.cos(t * Math.PI / 2), 3) * Math.cos(t * p);
+  }
+  /**
+   * Use with `Animated.parallel()` to create a simple effect where the object
+   * animates back slightly as the animation starts.
+   *
+   * Wolfram Plot:
+   *
+   * - http://tiny.cc/back_default (s = 1.70158, default)
+   */
+  static back(s = 1.70158) {
+    return t => t * t * ((s + 1) * t - s);
+  }
+  /**
+   * Provides a simple bouncing effect.
+   *
+   * http://easings.net/#easeInBounce
+   */
+  static bounce(t) {
+    if (t < 1 / 2.75) return 7.5625 * t * t;
+    if (t < 2 / 2.75) {
+      const t22 = t - 0.5454545454545454;
+      return 7.5625 * t22 * t22 + 0.75;
+    }
+    if (t < 2.5 / 2.75) {
+      const t22 = t - 0.8181818181818182;
+      return 7.5625 * t22 * t22 + 0.9375;
+    }
+    const t2 = t - 2.625 / 2.75;
+    return 7.5625 * t2 * t2 + 0.984375;
+  }
+  /**
+   * Provides a cubic bezier curve, equivalent to CSS Transitions'
+   * `transition-timing-function`.
+   *
+   * A useful tool to visualize cubic bezier curves can be found at
+   * http://cubic-bezier.com/
+   */
+  static bezier(x1, y1, x2, y2) {
+    return (0, import_bezier.bezier)(x1, y1, x2, y2);
+  }
+  /**
+   * Runs an easing function forwards.
+   */
+  static in(easing) {
+    return easing;
+  }
+  /**
+   * Runs an easing function backwards.
+   */
+  static out(easing) {
+    return t => 1 - easing(1 - t);
+  }
+  /**
+   * Makes any easing function symmetrical. The easing function will run
+   * forwards for half of the duration, then backwards for the rest of the
+   * duration.
+   */
+  static inOut(easing) {
+    return t => t < 0.5 ? easing(t * 2) / 2 : 1 - easing((1 - t) * 2) / 2;
+  }
+}
+var Easing_default = Easing;

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

@@ -0,0 +1,314 @@
+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 NativeAnimatedHelper_exports = {};
+__export(NativeAnimatedHelper_exports, {
+  API: () => API,
+  NativeAnimatedHelper: () => NativeAnimatedHelper,
+  addWhitelistedInterpolationParam: () => addWhitelistedInterpolationParam,
+  addWhitelistedStyleProp: () => addWhitelistedStyleProp,
+  addWhitelistedTransformProp: () => addWhitelistedTransformProp,
+  assertNativeAnimatedModule: () => assertNativeAnimatedModule,
+  default: () => NativeAnimatedHelper_default,
+  generateNewAnimationId: () => generateNewAnimationId,
+  generateNewNodeTag: () => generateNewNodeTag,
+  isSupportedColorStyleProp: () => isSupportedColorStyleProp,
+  isSupportedInterpolationParam: () => isSupportedInterpolationParam,
+  isSupportedStyleProp: () => isSupportedStyleProp,
+  isSupportedTransformProp: () => isSupportedTransformProp,
+  shouldUseNativeDriver: () => shouldUseNativeDriver,
+  transformDataType: () => transformDataType,
+  validateInterpolation: () => validateInterpolation,
+  validateStyles: () => validateStyles,
+  validateTransform: () => validateTransform
+});
+module.exports = __toCommonJS(NativeAnimatedHelper_exports);
+var import_NativeAnimatedModule = require("./NativeAnimatedModule.cjs"),
+  import_NativeAnimatedTurboModule = require("./NativeAnimatedTurboModule.cjs"),
+  import_NativeEventEmitter = require("../EventEmitter/NativeEventEmitter.cjs"),
+  import_Platform = require("../Utilities/Platform.cjs"),
+  import_ReactNativeFeatureFlags = require("../ReactNative/ReactNativeFeatureFlags.cjs"),
+  import_react_native_web_internals = require("@hanzogui/react-native-web-internals"),
+  import_RCTDeviceEventEmitter = require("../EventEmitter/RCTDeviceEventEmitter.cjs");
+const NativeAnimatedModule = import_Platform.Platform.OS === "ios" && global.RN$Bridgeless === !0 ? import_NativeAnimatedTurboModule.NativeAnimatedTurboModule : import_NativeAnimatedModule.NativeAnimatedNonTurboModule;
+let __nativeAnimatedNodeTagCount = 1,
+  __nativeAnimationIdCount = 1,
+  nativeEventEmitter,
+  waitingForQueuedOperations = /* @__PURE__ */new Set(),
+  queueOperations = !1,
+  queue = [],
+  singleOpQueue = [];
+const useSingleOpBatching = !1;
+import_Platform.Platform.OS === "android" && NativeAnimatedModule?.queueAndExecuteBatchedOperations && import_ReactNativeFeatureFlags.ReactNativeFeatureFlags.animatedShouldUseSingleOp();
+let flushQueueTimeout = null;
+const eventListenerGetValueCallbacks = {},
+  eventListenerAnimationFinishedCallbacks = {};
+const nativeOps = useSingleOpBatching ? function () {
+    return ["createAnimatedNode",
+    // 1
+    "updateAnimatedNodeConfig",
+    // 2
+    "getValue",
+    // 3
+    "startListeningToAnimatedNodeValue",
+    // 4
+    "stopListeningToAnimatedNodeValue",
+    // 5
+    "connectAnimatedNodes",
+    // 6
+    "disconnectAnimatedNodes",
+    // 7
+    "startAnimatingNode",
+    // 8
+    "stopAnimation",
+    // 9
+    "setAnimatedNodeValue",
+    // 10
+    "setAnimatedNodeOffset",
+    // 11
+    "flattenAnimatedNodeOffset",
+    // 12
+    "extractAnimatedNodeOffset",
+    // 13
+    "connectAnimatedNodeToView",
+    // 14
+    "disconnectAnimatedNodeFromView",
+    // 15
+    "restoreDefaultValues",
+    // 16
+    "dropAnimatedNode",
+    // 17
+    "addAnimatedEventToView",
+    // 18
+    "removeAnimatedEventFromView",
+    // 19
+    "addListener",
+    // 20
+    "removeListener"
+    // 21
+    ].reduce((acc, functionName, i) => (acc[functionName] = i + 1, acc), {});
+  }() : NativeAnimatedModule,
+  API = {
+    getValue: function (tag, saveValueCallback) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), useSingleOpBatching ? (saveValueCallback && (eventListenerGetValueCallbacks[tag] = saveValueCallback), API.queueOperation(nativeOps.getValue, tag)) : API.queueOperation(nativeOps.getValue, tag, saveValueCallback);
+    },
+    setWaitingForIdentifier: function (id) {
+      waitingForQueuedOperations.add(id), queueOperations = !0, import_ReactNativeFeatureFlags.ReactNativeFeatureFlags.animatedShouldDebounceQueueFlush() && flushQueueTimeout && clearTimeout(flushQueueTimeout);
+    },
+    unsetWaitingForIdentifier: function (id) {
+      waitingForQueuedOperations.delete(id), waitingForQueuedOperations.size === 0 && (queueOperations = !1, API.disableQueue());
+    },
+    disableQueue: function () {
+      if ((0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), import_ReactNativeFeatureFlags.ReactNativeFeatureFlags.animatedShouldDebounceQueueFlush()) {
+        const prevTimeout = flushQueueTimeout;
+        clearImmediate(prevTimeout), flushQueueTimeout = setImmediate(API.flushQueue);
+      } else API.flushQueue();
+    },
+    flushQueue: function () {},
+    queueOperation: (fn, ...args) => {
+      if (useSingleOpBatching) {
+        singleOpQueue.push(fn, ...args);
+        return;
+      }
+      queueOperations || queue.length !== 0 ? queue.push(() => fn(...args)) : fn(...args);
+    },
+    createAnimatedNode: function (tag, config) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), API.queueOperation(nativeOps.createAnimatedNode, tag, config);
+    },
+    updateAnimatedNodeConfig: function (tag, config) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available");
+    },
+    startListeningToAnimatedNodeValue: function (tag) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), API.queueOperation(nativeOps.startListeningToAnimatedNodeValue, tag);
+    },
+    stopListeningToAnimatedNodeValue: function (tag) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), API.queueOperation(nativeOps.stopListeningToAnimatedNodeValue, tag);
+    },
+    connectAnimatedNodes: function (parentTag, childTag) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), API.queueOperation(nativeOps.connectAnimatedNodes, parentTag, childTag);
+    },
+    disconnectAnimatedNodes: function (parentTag, childTag) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), API.queueOperation(nativeOps.disconnectAnimatedNodes, parentTag, childTag);
+    },
+    startAnimatingNode: function (animationId, nodeTag, config, endCallback) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), useSingleOpBatching ? (endCallback && (eventListenerAnimationFinishedCallbacks[animationId] = endCallback), API.queueOperation(nativeOps.startAnimatingNode, animationId, nodeTag, config)) : API.queueOperation(nativeOps.startAnimatingNode, animationId, nodeTag, config, endCallback);
+    },
+    stopAnimation: function (animationId) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), API.queueOperation(nativeOps.stopAnimation, animationId);
+    },
+    setAnimatedNodeValue: function (nodeTag, value) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), API.queueOperation(nativeOps.setAnimatedNodeValue, nodeTag, value);
+    },
+    setAnimatedNodeOffset: function (nodeTag, offset) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), API.queueOperation(nativeOps.setAnimatedNodeOffset, nodeTag, offset);
+    },
+    flattenAnimatedNodeOffset: function (nodeTag) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), API.queueOperation(nativeOps.flattenAnimatedNodeOffset, nodeTag);
+    },
+    extractAnimatedNodeOffset: function (nodeTag) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), API.queueOperation(nativeOps.extractAnimatedNodeOffset, nodeTag);
+    },
+    connectAnimatedNodeToView: function (nodeTag, viewTag) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), API.queueOperation(nativeOps.connectAnimatedNodeToView, nodeTag, viewTag);
+    },
+    disconnectAnimatedNodeFromView: function (nodeTag, viewTag) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), API.queueOperation(nativeOps.disconnectAnimatedNodeFromView, nodeTag, viewTag);
+    },
+    restoreDefaultValues: function (nodeTag) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), nativeOps.restoreDefaultValues != null && API.queueOperation(nativeOps.restoreDefaultValues, nodeTag);
+    },
+    dropAnimatedNode: function (tag) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), API.queueOperation(nativeOps.dropAnimatedNode, tag);
+    },
+    addAnimatedEventToView: function (viewTag, eventName, eventMapping) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), API.queueOperation(nativeOps.addAnimatedEventToView, viewTag, eventName, eventMapping);
+    },
+    removeAnimatedEventFromView(viewTag, eventName, animatedNodeTag) {
+      (0, import_react_native_web_internals.invariant)(nativeOps, "Native animated module is not available"), API.queueOperation(nativeOps.removeAnimatedEventFromView, viewTag, eventName, animatedNodeTag);
+    }
+  };
+const SUPPORTED_COLOR_STYLES = {
+    backgroundColor: !0,
+    borderBottomColor: !0,
+    borderColor: !0,
+    borderEndColor: !0,
+    borderLeftColor: !0,
+    borderRightColor: !0,
+    borderStartColor: !0,
+    borderTopColor: !0,
+    color: !0,
+    tintColor: !0
+  },
+  SUPPORTED_STYLES = {
+    ...SUPPORTED_COLOR_STYLES,
+    borderBottomEndRadius: !0,
+    borderBottomLeftRadius: !0,
+    borderBottomRightRadius: !0,
+    borderBottomStartRadius: !0,
+    borderRadius: !0,
+    borderTopEndRadius: !0,
+    borderTopLeftRadius: !0,
+    borderTopRightRadius: !0,
+    borderTopStartRadius: !0,
+    elevation: !0,
+    opacity: !0,
+    transform: !0,
+    zIndex: !0,
+    /* ios styles */
+    shadowOpacity: !0,
+    shadowRadius: !0,
+    /* legacy android transform properties */
+    scaleX: !0,
+    scaleY: !0,
+    translateX: !0,
+    translateY: !0
+  },
+  SUPPORTED_TRANSFORMS = {
+    translateX: !0,
+    translateY: !0,
+    scale: !0,
+    scaleX: !0,
+    scaleY: !0,
+    rotate: !0,
+    rotateX: !0,
+    rotateY: !0,
+    rotateZ: !0,
+    perspective: !0
+  },
+  SUPPORTED_INTERPOLATION_PARAMS = {
+    inputRange: !0,
+    outputRange: !0,
+    extrapolate: !0,
+    extrapolateRight: !0,
+    extrapolateLeft: !0
+  };
+function addWhitelistedStyleProp(prop) {
+  SUPPORTED_STYLES[prop] = !0;
+}
+function addWhitelistedTransformProp(prop) {
+  SUPPORTED_TRANSFORMS[prop] = !0;
+}
+function addWhitelistedInterpolationParam(param) {
+  SUPPORTED_INTERPOLATION_PARAMS[param] = !0;
+}
+function isSupportedColorStyleProp(prop) {
+  return SUPPORTED_COLOR_STYLES.hasOwnProperty(prop);
+}
+function isSupportedStyleProp(prop) {
+  return SUPPORTED_STYLES.hasOwnProperty(prop);
+}
+function isSupportedTransformProp(prop) {
+  return SUPPORTED_TRANSFORMS.hasOwnProperty(prop);
+}
+function isSupportedInterpolationParam(param) {
+  return SUPPORTED_INTERPOLATION_PARAMS.hasOwnProperty(param);
+}
+function validateTransform(configs) {
+  configs.forEach(config => {
+    if (!isSupportedTransformProp(config.property)) throw new Error(`Property '${config.property}' is not supported by native animated module`);
+  });
+}
+function validateStyles(styles) {
+  for (const key in styles) if (!isSupportedStyleProp(key)) throw new Error(`Style property '${key}' is not supported by native animated module`);
+}
+function validateInterpolation(config) {
+  for (const key in config) if (!isSupportedInterpolationParam(key)) throw new Error(`Interpolation property '${key}' is not supported by native animated module`);
+}
+function generateNewNodeTag() {
+  return __nativeAnimatedNodeTagCount++;
+}
+function generateNewAnimationId() {
+  return __nativeAnimationIdCount++;
+}
+function assertNativeAnimatedModule() {
+  (0, import_react_native_web_internals.invariant)(NativeAnimatedModule, "Native animated module is not available");
+}
+let _warnedMissingNativeAnimated = !1;
+function shouldUseNativeDriver(config) {
+  return config.useNativeDriver == null && console.warn("Animated: `useNativeDriver` was not specified. This is a required option and must be explicitly set to `true` or `false`"), config.useNativeDriver === !0 && !NativeAnimatedModule ? (_warnedMissingNativeAnimated || (console.warn("Animated: `useNativeDriver` is not supported because the native animated module is missing. Falling back to JS-based animation. To resolve this, add `RCTAnimation` module to this app, or remove `useNativeDriver`. Make sure to run `bundle exec pod install` first. Read more about autolinking: https://github.com/react-native-community/cli/blob/master/docs/autolinking.md"), _warnedMissingNativeAnimated = !0), !1) : config.useNativeDriver || !1;
+}
+function transformDataType(value) {
+  return typeof value != "string" ? value : /deg$/.test(value) ? (parseFloat(value) || 0) * Math.PI / 180 : value;
+}
+const NativeAnimatedHelper = {
+  API,
+  isSupportedColorStyleProp,
+  isSupportedStyleProp,
+  isSupportedTransformProp,
+  isSupportedInterpolationParam,
+  addWhitelistedStyleProp,
+  addWhitelistedTransformProp,
+  addWhitelistedInterpolationParam,
+  validateStyles,
+  validateTransform,
+  validateInterpolation,
+  generateNewNodeTag,
+  generateNewAnimationId,
+  assertNativeAnimatedModule,
+  shouldUseNativeDriver,
+  transformDataType,
+  get nativeEventEmitter() {
+    return nativeEventEmitter || (nativeEventEmitter = new import_NativeEventEmitter.NativeEventEmitter(
+    // T88715063: NativeEventEmitter only used this parameter on iOS. Now it uses it on all platforms, so this code was modified automatically to preserve its behavior
+    // If you want to use the native module on other platforms, please remove this condition and test its behavior
+    import_Platform.Platform.OS !== "ios" ? null : NativeAnimatedModule)), nativeEventEmitter;
+  }
+};
+var NativeAnimatedHelper_default = NativeAnimatedHelper;