@tamagui/react-native-web-lite 1.116.0 → 1.116.2

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedAddition.js

@@ -0,0 +1,57 @@
+"use strict";
+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 AnimatedAddition_exports = {};
+__export(AnimatedAddition_exports, {
+  default: () => AnimatedAddition_default
+});
+module.exports = __toCommonJS(AnimatedAddition_exports);
+var import_AnimatedInterpolation = __toESM(require("./AnimatedInterpolation")), import_AnimatedValue = __toESM(require("./AnimatedValue")), import_AnimatedWithChildren = __toESM(require("./AnimatedWithChildren"));
+class AnimatedAddition extends import_AnimatedWithChildren.default {
+  constructor(a, b) {
+    super(), this._a = typeof a == "number" ? new import_AnimatedValue.default(a) : a, this._b = typeof b == "number" ? new import_AnimatedValue.default(b) : b;
+  }
+  __makeNative(platformConfig) {
+    this._a.__makeNative(platformConfig), this._b.__makeNative(platformConfig), super.__makeNative(platformConfig);
+  }
+  __getValue() {
+    return this._a.__getValue() + this._b.__getValue();
+  }
+  interpolate(config) {
+    return new import_AnimatedInterpolation.default(this, config);
+  }
+  __attach() {
+    this._a.__addChild(this), this._b.__addChild(this);
+  }
+  __detach() {
+    this._a.__removeChild(this), this._b.__removeChild(this), super.__detach();
+  }
+  __getNativeConfig() {
+    return {
+      type: "addition",
+      input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
+    };
+  }
+}
+var AnimatedAddition_default = AnimatedAddition;
+//# sourceMappingURL=AnimatedAddition.js.map

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedColor.js

@@ -0,0 +1,197 @@
+"use strict";
+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 AnimatedColor_exports = {};
+__export(AnimatedColor_exports, {
+  default: () => AnimatedColor
+});
+module.exports = __toCommonJS(AnimatedColor_exports);
+var import_normalize_css_color = __toESM(require("@tamagui/normalize-css-color")), import_NativeAnimatedHelper = __toESM(require("../NativeAnimatedHelper")), import_AnimatedValue = __toESM(require("./AnimatedValue")), import_AnimatedWithChildren = __toESM(require("./AnimatedWithChildren")), NativeAnimatedAPI = import_NativeAnimatedHelper.default.API, defaultColor = {
+  r: 0,
+  g: 0,
+  b: 0,
+  a: 1
+}, _uniqueId = 1, processColorObject = (color) => color;
+function processColor(color) {
+  if (color == null)
+    return null;
+  if (isRgbaValue(color))
+    return color;
+  var normalizedColor = (0, import_normalize_css_color.default)(
+    // $FlowIgnore[incompatible-cast] - Type is verified above
+    color
+  );
+  if (normalizedColor == null)
+    return null;
+  if (typeof normalizedColor == "object") {
+    var processedColorObj = processColorObject(normalizedColor);
+    if (processedColorObj != null)
+      return processedColorObj;
+  } else if (typeof normalizedColor == "number") {
+    var r = (normalizedColor & 4278190080) >>> 24, g = (normalizedColor & 16711680) >>> 16, b = (normalizedColor & 65280) >>> 8, a = (normalizedColor & 255) / 255;
+    return {
+      r,
+      g,
+      b,
+      a
+    };
+  }
+  return null;
+}
+function isRgbaValue(value) {
+  return value && typeof value.r == "number" && typeof value.g == "number" && typeof value.b == "number" && typeof value.a == "number";
+}
+function isRgbaAnimatedValue(value) {
+  return value && value.r instanceof import_AnimatedValue.default && value.g instanceof import_AnimatedValue.default && value.b instanceof import_AnimatedValue.default && value.a instanceof import_AnimatedValue.default;
+}
+class AnimatedColor extends import_AnimatedWithChildren.default {
+  constructor(valueIn, config) {
+    super(), this._listeners = {};
+    var value = valueIn ?? defaultColor;
+    if (isRgbaAnimatedValue(value)) {
+      var rgbaAnimatedValue = value;
+      this.r = rgbaAnimatedValue.r, this.g = rgbaAnimatedValue.g, this.b = rgbaAnimatedValue.b, this.a = rgbaAnimatedValue.a;
+    } else {
+      var _processColor, processedColor = (
+        // $FlowIgnore[incompatible-cast] - Type is verified above
+        (_processColor = processColor(value)) !== null && _processColor !== void 0 ? _processColor : defaultColor
+      ), initColor = defaultColor;
+      isRgbaValue(processedColor) ? initColor = processedColor : this.nativeColor = processedColor, this.r = new import_AnimatedValue.default(initColor.r), this.g = new import_AnimatedValue.default(initColor.g), this.b = new import_AnimatedValue.default(initColor.b), this.a = new import_AnimatedValue.default(initColor.a);
+    }
+    (this.nativeColor || config && config.useNativeDriver) && this.__makeNative();
+  }
+  /**
+   * Directly set the value. This will stop any animations running on the value
+   * and update all the bound properties.
+   */
+  setValue(value) {
+    var _processColor2, shouldUpdateNodeConfig = !1;
+    if (this.__isNative) {
+      var nativeTag = this.__getNativeTag();
+      NativeAnimatedAPI.setWaitingForIdentifier(nativeTag.toString());
+    }
+    var processedColor = (_processColor2 = processColor(value)) !== null && _processColor2 !== void 0 ? _processColor2 : defaultColor;
+    if (isRgbaValue(processedColor)) {
+      var rgbaValue = processedColor;
+      this.r.setValue(rgbaValue.r), this.g.setValue(rgbaValue.g), this.b.setValue(rgbaValue.b), this.a.setValue(rgbaValue.a), this.nativeColor != null && (this.nativeColor = null, shouldUpdateNodeConfig = !0);
+    } else {
+      var nativeColor = processedColor;
+      this.nativeColor !== nativeColor && (this.nativeColor = nativeColor, shouldUpdateNodeConfig = !0);
+    }
+    if (this.__isNative) {
+      var _nativeTag = this.__getNativeTag();
+      shouldUpdateNodeConfig && NativeAnimatedAPI.updateAnimatedNodeConfig(_nativeTag, this.__getNativeConfig()), NativeAnimatedAPI.unsetWaitingForIdentifier(_nativeTag.toString());
+    }
+  }
+  /**
+   * Sets an offset that is applied on top of whatever value is set, whether
+   * via `setValue`, an animation, or `Animated.event`. Useful for compensating
+   * things like the start of a pan gesture.
+   */
+  setOffset(offset) {
+    this.r.setOffset(offset.r), this.g.setOffset(offset.g), this.b.setOffset(offset.b), this.a.setOffset(offset.a);
+  }
+  /**
+   * Merges the offset value into the base value and resets the offset to zero.
+   * The final output of the value is unchanged.
+   */
+  flattenOffset() {
+    this.r.flattenOffset(), this.g.flattenOffset(), this.b.flattenOffset(), this.a.flattenOffset();
+  }
+  /**
+   * Sets the offset value to the base value, and resets the base value to
+   * zero. The final output of the value is unchanged.
+   */
+  extractOffset() {
+    this.r.extractOffset(), this.g.extractOffset(), this.b.extractOffset(), this.a.extractOffset();
+  }
+  /**
+   * Adds an asynchronous listener to the value so you can observe updates from
+   * animations.  This is useful because there is no way to synchronously read
+   * the value because it might be driven natively.
+   *
+   * Returns a string that serves as an identifier for the listener.
+   */
+  addListener(callback) {
+    var id = String(_uniqueId++), jointCallback = (_ref) => {
+      var number = _ref.value;
+      callback(this.__getValue());
+    };
+    return this._listeners[id] = {
+      r: this.r.addListener(jointCallback),
+      g: this.g.addListener(jointCallback),
+      b: this.b.addListener(jointCallback),
+      a: this.a.addListener(jointCallback)
+    }, id;
+  }
+  /**
+   * Unregister a listener. The `id` param shall match the identifier
+   * previously returned by `addListener()`.
+   */
+  removeListener(id) {
+    this.r.removeListener(this._listeners[id].r), this.g.removeListener(this._listeners[id].g), this.b.removeListener(this._listeners[id].b), this.a.removeListener(this._listeners[id].a), delete this._listeners[id];
+  }
+  /**
+   * Remove all registered listeners.
+   */
+  removeAllListeners() {
+    this.r.removeAllListeners(), this.g.removeAllListeners(), this.b.removeAllListeners(), this.a.removeAllListeners(), this._listeners = {};
+  }
+  /**
+   * Stops any running animation or tracking. `callback` is invoked with the
+   * final value after stopping the animation, which is useful for updating
+   * state to match the animation position with layout.
+   */
+  stopAnimation(callback) {
+    this.r.stopAnimation(), this.g.stopAnimation(), this.b.stopAnimation(), this.a.stopAnimation(), callback && callback(this.__getValue());
+  }
+  /**
+   * Stops any animation and resets the value to its original.
+   */
+  resetAnimation(callback) {
+    this.r.resetAnimation(), this.g.resetAnimation(), this.b.resetAnimation(), this.a.resetAnimation(), callback && callback(this.__getValue());
+  }
+  __getValue() {
+    return this.nativeColor != null ? this.nativeColor : "rgba(" + this.r.__getValue() + ", " + this.g.__getValue() + ", " + this.b.__getValue() + ", " + this.a.__getValue() + ")";
+  }
+  __attach() {
+    this.r.__addChild(this), this.g.__addChild(this), this.b.__addChild(this), this.a.__addChild(this), super.__attach();
+  }
+  __detach() {
+    this.r.__removeChild(this), this.g.__removeChild(this), this.b.__removeChild(this), this.a.__removeChild(this), super.__detach();
+  }
+  __makeNative(platformConfig) {
+    this.r.__makeNative(platformConfig), this.g.__makeNative(platformConfig), this.b.__makeNative(platformConfig), this.a.__makeNative(platformConfig), super.__makeNative(platformConfig);
+  }
+  __getNativeConfig() {
+    return {
+      type: "color",
+      r: this.r.__getNativeTag(),
+      g: this.g.__getNativeTag(),
+      b: this.b.__getNativeTag(),
+      a: this.a.__getNativeTag(),
+      nativeColor: this.nativeColor
+    };
+  }
+}
+//# sourceMappingURL=AnimatedColor.js.map

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedDiffClamp.js

@@ -0,0 +1,60 @@
+"use strict";
+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 AnimatedDiffClamp_exports = {};
+__export(AnimatedDiffClamp_exports, {
+  default: () => AnimatedDiffClamp_default
+});
+module.exports = __toCommonJS(AnimatedDiffClamp_exports);
+var import_AnimatedInterpolation = __toESM(require("./AnimatedInterpolation")), import_AnimatedWithChildren = __toESM(require("./AnimatedWithChildren"));
+class AnimatedDiffClamp extends import_AnimatedWithChildren.default {
+  constructor(a, min, max) {
+    super(), this._a = a, this._min = min, this._max = max, this._value = this._lastValue = this._a.__getValue();
+  }
+  __makeNative(platformConfig) {
+    this._a.__makeNative(platformConfig), super.__makeNative(platformConfig);
+  }
+  interpolate(config) {
+    return new import_AnimatedInterpolation.default(this, config);
+  }
+  __getValue() {
+    var value = this._a.__getValue(), diff = value - this._lastValue;
+    return this._lastValue = value, this._value = Math.min(Math.max(this._value + diff, this._min), this._max), this._value;
+  }
+  __attach() {
+    this._a.__addChild(this);
+  }
+  __detach() {
+    this._a.__removeChild(this), super.__detach();
+  }
+  __getNativeConfig() {
+    return {
+      type: "diffclamp",
+      input: this._a.__getNativeTag(),
+      min: this._min,
+      max: this._max
+    };
+  }
+}
+var AnimatedDiffClamp_default = AnimatedDiffClamp;
+//# sourceMappingURL=AnimatedDiffClamp.js.map

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedDivision.js

@@ -0,0 +1,58 @@
+"use strict";
+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 AnimatedDivision_exports = {};
+__export(AnimatedDivision_exports, {
+  default: () => AnimatedDivision_default
+});
+module.exports = __toCommonJS(AnimatedDivision_exports);
+var import_AnimatedInterpolation = __toESM(require("./AnimatedInterpolation")), import_AnimatedNode = __toESM(require("./AnimatedNode")), import_AnimatedValue = __toESM(require("./AnimatedValue")), import_AnimatedWithChildren = __toESM(require("./AnimatedWithChildren"));
+class AnimatedDivision extends import_AnimatedWithChildren.default {
+  constructor(a, b) {
+    super(), this._warnedAboutDivideByZero = !1, (b === 0 || b instanceof import_AnimatedNode.default && b.__getValue() === 0) && console.error("Detected potential division by zero in AnimatedDivision"), this._a = typeof a == "number" ? new import_AnimatedValue.default(a) : a, this._b = typeof b == "number" ? new import_AnimatedValue.default(b) : b;
+  }
+  __makeNative(platformConfig) {
+    this._a.__makeNative(platformConfig), this._b.__makeNative(platformConfig), super.__makeNative(platformConfig);
+  }
+  __getValue() {
+    var a = this._a.__getValue(), b = this._b.__getValue();
+    return b === 0 ? (this._warnedAboutDivideByZero || (console.error("Detected division by zero in AnimatedDivision"), this._warnedAboutDivideByZero = !0), 0) : (this._warnedAboutDivideByZero = !1, a / b);
+  }
+  interpolate(config) {
+    return new import_AnimatedInterpolation.default(this, config);
+  }
+  __attach() {
+    this._a.__addChild(this), this._b.__addChild(this);
+  }
+  __detach() {
+    this._a.__removeChild(this), this._b.__removeChild(this), super.__detach();
+  }
+  __getNativeConfig() {
+    return {
+      type: "division",
+      input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
+    };
+  }
+}
+var AnimatedDivision_default = AnimatedDivision;
+//# sourceMappingURL=AnimatedDivision.js.map

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedInterpolation.js

@@ -0,0 +1,175 @@
+"use strict";
+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 AnimatedInterpolation_exports = {};
+__export(AnimatedInterpolation_exports, {
+  default: () => AnimatedInterpolation_default
+});
+module.exports = __toCommonJS(AnimatedInterpolation_exports);
+var import_normalize_css_color = __toESM(require("@tamagui/normalize-css-color")), import_react_native_web_internals = require("@tamagui/react-native-web-internals"), import_NativeAnimatedHelper = __toESM(require("../NativeAnimatedHelper")), import_AnimatedWithChildren = __toESM(require("./AnimatedWithChildren")), __DEV__ = process.env.NODE_ENV !== "production", linear = (t) => t;
+function createInterpolation(config) {
+  if (config.outputRange && typeof config.outputRange[0] == "string")
+    return createInterpolationFromStringOutputRange(config);
+  var outputRange = config.outputRange, inputRange = config.inputRange;
+  __DEV__ && (checkInfiniteRange("outputRange", outputRange), checkInfiniteRange("inputRange", inputRange), checkValidInputRange(inputRange), (0, import_react_native_web_internals.invariant)(
+    inputRange.length === outputRange.length,
+    "inputRange (" + inputRange.length + ") and outputRange (" + outputRange.length + ") must have the same length"
+  ));
+  var easing = config.easing || linear, extrapolateLeft = "extend";
+  config.extrapolateLeft !== void 0 ? extrapolateLeft = config.extrapolateLeft : config.extrapolate !== void 0 && (extrapolateLeft = config.extrapolate);
+  var extrapolateRight = "extend";
+  return config.extrapolateRight !== void 0 ? extrapolateRight = config.extrapolateRight : config.extrapolate !== void 0 && (extrapolateRight = config.extrapolate), (input) => {
+    (0, import_react_native_web_internals.invariant)(
+      typeof input == "number",
+      "Cannot interpolation an input which is not a number"
+    );
+    var range = findRange(input, inputRange);
+    return interpolate(
+      input,
+      inputRange[range],
+      inputRange[range + 1],
+      outputRange[range],
+      outputRange[range + 1],
+      easing,
+      extrapolateLeft,
+      extrapolateRight
+    );
+  };
+}
+function interpolate(input, inputMin, inputMax, outputMin, outputMax, easing, extrapolateLeft, extrapolateRight) {
+  var result = input;
+  if (result < inputMin) {
+    if (extrapolateLeft === "identity")
+      return result;
+    extrapolateLeft === "clamp" && (result = inputMin);
+  }
+  if (result > inputMax) {
+    if (extrapolateRight === "identity")
+      return result;
+    extrapolateRight === "clamp" && (result = inputMax);
+  }
+  return outputMin === outputMax ? outputMin : inputMin === inputMax ? input <= inputMin ? outputMin : outputMax : (inputMin === -1 / 0 ? result = -result : inputMax === 1 / 0 ? result = result - inputMin : result = (result - inputMin) / (inputMax - inputMin), result = easing(result), outputMin === -1 / 0 ? result = -result : outputMax === 1 / 0 ? result = result + outputMin : result = result * (outputMax - outputMin) + outputMin, result);
+}
+function colorToRgba(input) {
+  var normalizedColor = (0, import_normalize_css_color.default)(input);
+  if (normalizedColor === null || typeof normalizedColor != "number")
+    return input;
+  normalizedColor = normalizedColor || 0;
+  var r = (normalizedColor & 4278190080) >>> 24, g = (normalizedColor & 16711680) >>> 16, b = (normalizedColor & 65280) >>> 8, a = (normalizedColor & 255) / 255;
+  return "rgba(" + r + ", " + g + ", " + b + ", " + a + ")";
+}
+var stringShapeRegex = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/g;
+function createInterpolationFromStringOutputRange(config) {
+  var outputRange = config.outputRange;
+  (0, import_react_native_web_internals.invariant)(outputRange.length >= 2, "Bad output range"), outputRange = outputRange.map(colorToRgba), checkPattern(outputRange);
+  var outputRanges = outputRange[0].match(stringShapeRegex).map(() => []);
+  outputRange.forEach((value) => {
+    value.match(stringShapeRegex).forEach((number, i) => {
+      outputRanges[i].push(+number);
+    });
+  });
+  var interpolations = outputRange[0].match(stringShapeRegex).map((value, i) => createInterpolation({
+    ...config,
+    outputRange: outputRanges[i]
+  })), shouldRound = isRgbOrRgba(outputRange[0]);
+  return (input) => {
+    var i = 0;
+    return outputRange[0].replace(stringShapeRegex, () => {
+      var val = +interpolations[i++](input);
+      return shouldRound && (val = i < 4 ? Math.round(val) : Math.round(val * 1e3) / 1e3), String(val);
+    });
+  };
+}
+function isRgbOrRgba(range) {
+  return typeof range == "string" && range.startsWith("rgb");
+}
+function checkPattern(arr) {
+  for (var pattern = arr[0].replace(stringShapeRegex, ""), i = 1; i < arr.length; ++i)
+    (0, import_react_native_web_internals.invariant)(
+      pattern === arr[i].replace(stringShapeRegex, ""),
+      "invalid pattern " + arr[0] + " and " + arr[i]
+    );
+}
+function findRange(input, inputRange) {
+  var i;
+  for (i = 1; i < inputRange.length - 1 && !(inputRange[i] >= input); ++i)
+    ;
+  return i - 1;
+}
+function checkValidInputRange(arr) {
+  (0, import_react_native_web_internals.invariant)(arr.length >= 2, "inputRange must have at least 2 elements");
+  for (var message = "inputRange must be monotonically non-decreasing " + String(arr), i = 1; i < arr.length; ++i)
+    (0, import_react_native_web_internals.invariant)(arr[i] >= arr[i - 1], message);
+}
+function checkInfiniteRange(name, arr) {
+  (0, import_react_native_web_internals.invariant)(arr.length >= 2, name + " must have at least 2 elements"), (0, import_react_native_web_internals.invariant)(
+    arr.length !== 2 || arr[0] !== -1 / 0 || arr[1] !== 1 / 0,
+    /* $FlowFixMe[incompatible-type] (>=0.13.0) - In the addition expression
+     * below this comment, one or both of the operands may be something that
+     * doesn't cleanly convert to a string, like undefined, null, and object,
+     * etc. If you really mean this implicit string conversion, you can do
+     * something like String(myThing) */
+    name + "cannot be ]-infinity;+infinity[ " + arr
+  );
+}
+class AnimatedInterpolation extends import_AnimatedWithChildren.default {
+  // Export for testing.
+  constructor(parent, config) {
+    super(), this._parent = parent, this._config = config, this._interpolation = createInterpolation(config);
+  }
+  __makeNative(platformConfig) {
+    this._parent.__makeNative(platformConfig), super.__makeNative(platformConfig);
+  }
+  __getValue() {
+    var parentValue = this._parent.__getValue();
+    return (0, import_react_native_web_internals.invariant)(
+      typeof parentValue == "number",
+      "Cannot interpolate an input which is not a number."
+    ), this._interpolation(parentValue);
+  }
+  interpolate(config) {
+    return new AnimatedInterpolation(this, config);
+  }
+  __attach() {
+    this._parent.__addChild(this);
+  }
+  __detach() {
+    this._parent.__removeChild(this), super.__detach();
+  }
+  __transformDataType(range) {
+    return range.map(import_NativeAnimatedHelper.default.transformDataType);
+  }
+  __getNativeConfig() {
+    return __DEV__ && import_NativeAnimatedHelper.default.validateInterpolation(this._config), {
+      inputRange: this._config.inputRange,
+      // Only the `outputRange` can contain strings so we don't need to transform `inputRange` here
+      outputRange: this.__transformDataType(this._config.outputRange),
+      extrapolateLeft: this._config.extrapolateLeft || this._config.extrapolate || "extend",
+      extrapolateRight: this._config.extrapolateRight || this._config.extrapolate || "extend",
+      type: "interpolation"
+    };
+  }
+}
+AnimatedInterpolation.__createInterpolation = createInterpolation;
+var AnimatedInterpolation_default = AnimatedInterpolation;
+//# sourceMappingURL=AnimatedInterpolation.js.map

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedModulo.js

@@ -0,0 +1,58 @@
+"use strict";
+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 AnimatedModulo_exports = {};
+__export(AnimatedModulo_exports, {
+  default: () => AnimatedModulo_default
+});
+module.exports = __toCommonJS(AnimatedModulo_exports);
+var import_AnimatedInterpolation = __toESM(require("./AnimatedInterpolation")), import_AnimatedWithChildren = __toESM(require("./AnimatedWithChildren"));
+class AnimatedModulo extends import_AnimatedWithChildren.default {
+  constructor(a, modulus) {
+    super(), this._a = a, this._modulus = modulus;
+  }
+  __makeNative(platformConfig) {
+    this._a.__makeNative(platformConfig), super.__makeNative(platformConfig);
+  }
+  __getValue() {
+    return (this._a.__getValue() % this._modulus + this._modulus) % this._modulus;
+  }
+  interpolate(config) {
+    return new import_AnimatedInterpolation.default(this, config);
+  }
+  __attach() {
+    this._a.__addChild(this);
+  }
+  __detach() {
+    this._a.__removeChild(this), super.__detach();
+  }
+  __getNativeConfig() {
+    return {
+      type: "modulus",
+      input: this._a.__getNativeTag(),
+      modulus: this._modulus
+    };
+  }
+}
+var AnimatedModulo_default = AnimatedModulo;
+//# sourceMappingURL=AnimatedModulo.js.map

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedMultiplication.js

@@ -0,0 +1,57 @@
+"use strict";
+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 AnimatedMultiplication_exports = {};
+__export(AnimatedMultiplication_exports, {
+  default: () => AnimatedMultiplication_default
+});
+module.exports = __toCommonJS(AnimatedMultiplication_exports);
+var import_AnimatedInterpolation = __toESM(require("./AnimatedInterpolation")), import_AnimatedValue = __toESM(require("./AnimatedValue")), import_AnimatedWithChildren = __toESM(require("./AnimatedWithChildren"));
+class AnimatedMultiplication extends import_AnimatedWithChildren.default {
+  constructor(a, b) {
+    super(), this._a = typeof a == "number" ? new import_AnimatedValue.default(a) : a, this._b = typeof b == "number" ? new import_AnimatedValue.default(b) : b;
+  }
+  __makeNative(platformConfig) {
+    this._a.__makeNative(platformConfig), this._b.__makeNative(platformConfig), super.__makeNative(platformConfig);
+  }
+  __getValue() {
+    return this._a.__getValue() * this._b.__getValue();
+  }
+  interpolate(config) {
+    return new import_AnimatedInterpolation.default(this, config);
+  }
+  __attach() {
+    this._a.__addChild(this), this._b.__addChild(this);
+  }
+  __detach() {
+    this._a.__removeChild(this), this._b.__removeChild(this), super.__detach();
+  }
+  __getNativeConfig() {
+    return {
+      type: "multiplication",
+      input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
+    };
+  }
+}
+var AnimatedMultiplication_default = AnimatedMultiplication;
+//# sourceMappingURL=AnimatedMultiplication.js.map