@tamagui/react-native-web-lite 1.112.5

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

@@ -0,0 +1,70 @@
+"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 SpringConfig_exports = {};
+__export(SpringConfig_exports, {
+  default: () => SpringConfig_default
+});
+module.exports = __toCommonJS(SpringConfig_exports);
+function stiffnessFromOrigamiValue(oValue) {
+  return (oValue - 30) * 3.62 + 194;
+}
+function dampingFromOrigamiValue(oValue) {
+  return (oValue - 8) * 3 + 25;
+}
+function fromOrigamiTensionAndFriction(tension, friction) {
+  return {
+    stiffness: stiffnessFromOrigamiValue(tension),
+    damping: dampingFromOrigamiValue(friction)
+  };
+}
+function fromBouncinessAndSpeed(bounciness, speed) {
+  function normalize(value, startValue, endValue) {
+    return (value - startValue) / (endValue - startValue);
+  }
+  function projectNormal(n, start, end) {
+    return start + n * (end - start);
+  }
+  function linearInterpolation(t, start, end) {
+    return t * end + (1 - t) * start;
+  }
+  function quadraticOutInterpolation(t, start, end) {
+    return linearInterpolation(2 * t - t * t, start, end);
+  }
+  function b3Friction1(x) {
+    return 7e-4 * Math.pow(x, 3) - 0.031 * Math.pow(x, 2) + 0.64 * x + 1.28;
+  }
+  function b3Friction2(x) {
+    return 44e-6 * Math.pow(x, 3) - 6e-3 * Math.pow(x, 2) + 0.36 * x + 2;
+  }
+  function b3Friction3(x) {
+    return 45e-8 * Math.pow(x, 3) - 332e-6 * Math.pow(x, 2) + 0.1078 * x + 5.84;
+  }
+  function b3Nobounce(tension) {
+    return tension <= 18 ? b3Friction1(tension) : tension > 18 && tension <= 44 ? b3Friction2(tension) : b3Friction3(tension);
+  }
+  var b = normalize(bounciness / 1.7, 0, 20);
+  b = projectNormal(b, 0, 0.8);
+  var s = normalize(speed / 1.7, 0, 20), bouncyTension = projectNormal(s, 0.5, 200), bouncyFriction = quadraticOutInterpolation(b, b3Nobounce(bouncyTension), 0.01);
+  return {
+    stiffness: stiffnessFromOrigamiValue(bouncyTension),
+    damping: dampingFromOrigamiValue(bouncyFriction)
+  };
+}
+var SpringConfig_default = {
+  fromOrigamiTensionAndFriction,
+  fromBouncinessAndSpeed
+};
+//# sourceMappingURL=SpringConfig.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/vendor/react-native/Animated/Users/n8/tamagui/code/packages/react-native-web-lite/src/vendor/react-native/Animated/SpringConfig.js"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;;;;;AAWA,SAASA,0BAA0BC,QAAM;AACvC,UAAQA,SAAS,MAAM,OAAO;AAChC;AAEA,SAASC,wBAAwBD,QAAM;AACrC,UAAQA,SAAS,KAAK,IAAI;AAC5B;AAEA,SAASE,8BAA8BC,SAASC,UAAQ;AACtD,SAAO;IACLC,WAAWN,0BAA0BI,OAAAA;IACrCG,SAASL,wBAAwBG,QAAAA;EACnC;AACF;AAEA,SAASG,uBAAuBC,YAAYC,OAAK;AAC/C,WAASC,UAAUC,OAAOC,YAAYC,UAAQ;AAC5C,YAAQF,QAAQC,eAAeC,WAAWD;EAC5C;AAEA,WAASE,cAAcC,GAAGC,OAAOC,KAAG;AAClC,WAAOD,QAAQD,KAAKE,MAAMD;EAC5B;AAEA,WAASE,oBAAoBC,GAAGH,OAAOC,KAAG;AACxC,WAAOE,IAAIF,OAAO,IAAIE,KAAKH;EAC7B;AAEA,WAASI,0BAA0BD,GAAGH,OAAOC,KAAG;AAC9C,WAAOC,oBAAoB,IAAIC,IAAIA,IAAIA,GAAGH,OAAOC,GAAAA;EACnD;AAEA,WAASI,YAAYC,GAAC;AACpB,WAAO,OAASC,KAAKC,IAAIF,GAAG,CAAA,IAAK,QAAQC,KAAKC,IAAIF,GAAG,CAAA,IAAK,OAAOA,IAAI;EACvE;AAEA,WAASG,YAAYH,GAAC;AACpB,WAAO,QAAWC,KAAKC,IAAIF,GAAG,CAAA,IAAK,OAAQC,KAAKC,IAAIF,GAAG,CAAA,IAAK,OAAOA,IAAI;EACzE;AAEA,WAASI,YAAYJ,GAAC;AACpB,WAAO,QAAaC,KAAKC,IAAIF,GAAG,CAAA,IAAK,SAAWC,KAAKC,IAAIF,GAAG,CAAA,IAAK,SAASA,IAAI;EAChF;AAEA,WAASK,WAAWxB,SAAO;AACzB,WAAIA,WAAW,KACNkB,YAAYlB,OAAAA,IACVA,UAAU,MAAMA,WAAW,KAC7BsB,YAAYtB,OAAAA,IAEZuB,YAAYvB,OAAAA;EAEvB;AAEA,MAAIyB,IAAIlB,UAAUF,aAAa,KAAK,GAAG,EAAA;AACvCoB,MAAId,cAAcc,GAAG,GAAG,GAAA;AACxB,MAAIC,IAAInB,UAAUD,QAAQ,KAAK,GAAG,EAAA,GAC9BqB,gBAAgBhB,cAAce,GAAG,KAAK,GAAA,GACtCE,iBAAiBX,0BAA0BQ,GAAGD,WAAWG,aAAAA,GAAgB,IAAA;AAC7E,SAAO;IACLzB,WAAWN,0BAA0B+B,aAAAA;IACrCxB,SAASL,wBAAwB8B,cAAAA;EACnC;AACF;AAEA,IAAA,uBAAe;EACb7B;EACAK;AACF;",
+  "names": ["stiffnessFromOrigamiValue", "oValue", "dampingFromOrigamiValue", "fromOrigamiTensionAndFriction", "tension", "friction", "stiffness", "damping", "fromBouncinessAndSpeed", "bounciness", "speed", "normalize", "value", "startValue", "endValue", "projectNormal", "n", "start", "end", "linearInterpolation", "t", "quadraticOutInterpolation", "b3Friction1", "x", "Math", "pow", "b3Friction2", "b3Friction3", "b3Nobounce", "b", "s", "bouncyTension", "bouncyFriction"]
+}

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

@@ -0,0 +1,64 @@
+"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 Animation_exports = {};
+__export(Animation_exports, {
+  default: () => Animation_default
+});
+module.exports = __toCommonJS(Animation_exports);
+var import_NativeAnimatedHelper = __toESM(require("../NativeAnimatedHelper")), startNativeAnimationNextId = 1;
+class Animation {
+  start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
+  }
+  stop() {
+    this.__nativeId && import_NativeAnimatedHelper.default.API.stopAnimation(this.__nativeId);
+  }
+  __getNativeAnimationConfig() {
+    throw new Error("This animation type cannot be offloaded to native");
+  }
+  // Helper function for subclasses to make sure onEnd is only called once.
+  __debouncedOnEnd(result) {
+    var onEnd = this.__onEnd;
+    this.__onEnd = null, onEnd && onEnd(result);
+  }
+  __startNativeAnimation(animatedValue) {
+    var startNativeAnimationWaitId = startNativeAnimationNextId + ":startAnimation";
+    startNativeAnimationNextId += 1, import_NativeAnimatedHelper.default.API.setWaitingForIdentifier(startNativeAnimationWaitId);
+    try {
+      var config = this.__getNativeAnimationConfig();
+      animatedValue.__makeNative(config.platformConfig), this.__nativeId = import_NativeAnimatedHelper.default.generateNewAnimationId(), import_NativeAnimatedHelper.default.API.startAnimatingNode(
+        this.__nativeId,
+        animatedValue.__getNativeTag(),
+        config,
+        // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+        this.__debouncedOnEnd.bind(this)
+      );
+    } catch (e) {
+      throw e;
+    } finally {
+      import_NativeAnimatedHelper.default.API.unsetWaitingForIdentifier(startNativeAnimationWaitId);
+    }
+  }
+}
+var Animation_default = Animation;
+//# sourceMappingURL=Animation.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/vendor/react-native/Animated/animations/Animation.js"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,kCAAiC,6CAC7B,6BAA6B;AAIjC,MAAM,UAAU;AAAA,EACd,MAAM,WAAW,UAAU,OAAO,mBAAmB,eAAe;AAAA,EAAC;AAAA,EAErE,OAAO;AACL,IAAI,KAAK,cACP,4BAAAA,QAAqB,IAAI,cAAc,KAAK,UAAU;AAAA,EAE1D;AAAA,EAEA,6BAA6B;AAG3B,UAAM,IAAI,MAAM,mDAAmD;AAAA,EACrE;AAAA;AAAA,EAEA,iBAAiB,QAAQ;AACvB,QAAI,QAAQ,KAAK;AACjB,SAAK,UAAU,MACf,SAAS,MAAM,MAAM;AAAA,EACvB;AAAA,EAEA,uBAAuB,eAAe;AACpC,QAAI,6BAA6B,6BAA6B;AAC9D,kCAA8B,GAC9B,4BAAAA,QAAqB,IAAI,wBAAwB,0BAA0B;AAE3E,QAAI;AACF,UAAI,SAAS,KAAK,2BAA2B;AAE7C,oBAAc,aAAa,OAAO,cAAc,GAEhD,KAAK,aAAa,4BAAAA,QAAqB,uBAAuB,GAC9D,4BAAAA,QAAqB,IAAI;AAAA,QACvB,KAAK;AAAA,QACL,cAAc,eAAe;AAAA,QAC7B;AAAA;AAAA,QACA,KAAK,iBAAiB,KAAK,IAAI;AAAA,MACjC;AAAA,IACF,SAAS,GAAG;AACV,YAAM;AAAA,IACR,UAAE;AACA,kCAAAA,QAAqB,IAAI,0BAA0B,0BAA0B;AAAA,IAC/E;AAAA,EACF;AACF;AAEA,IAAO,oBAAQ;",
+  "names": ["NativeAnimatedHelper"]
+}

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

@@ -0,0 +1,96 @@
+"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 Animation_exports = {};
+__export(Animation_exports, {
+  default: () => Animation_default
+});
+module.exports = __toCommonJS(Animation_exports);
+var import_NativeAnimatedHelper = __toESM(require("../NativeAnimatedHelper"));
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor))
+    throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+  return protoProps && _defineProperties(Constructor.prototype, protoProps), staticProps && _defineProperties(Constructor, staticProps), Constructor;
+}
+var startNativeAnimationNextId = 1, Animation = /* @__PURE__ */ function() {
+  function Animation2() {
+    _class_call_check(this, Animation2);
+  }
+  return _create_class(Animation2, [
+    {
+      key: "start",
+      value: function(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
+      }
+    },
+    {
+      key: "stop",
+      value: function() {
+        this.__nativeId && import_NativeAnimatedHelper.default.API.stopAnimation(this.__nativeId);
+      }
+    },
+    {
+      key: "__getNativeAnimationConfig",
+      value: function() {
+        throw new Error("This animation type cannot be offloaded to native");
+      }
+    },
+    {
+      // Helper function for subclasses to make sure onEnd is only called once.
+      key: "__debouncedOnEnd",
+      value: function(result) {
+        var onEnd = this.__onEnd;
+        this.__onEnd = null, onEnd && onEnd(result);
+      }
+    },
+    {
+      key: "__startNativeAnimation",
+      value: function(animatedValue) {
+        var startNativeAnimationWaitId = startNativeAnimationNextId + ":startAnimation";
+        startNativeAnimationNextId += 1, import_NativeAnimatedHelper.default.API.setWaitingForIdentifier(startNativeAnimationWaitId);
+        try {
+          var config = this.__getNativeAnimationConfig();
+          animatedValue.__makeNative(config.platformConfig), this.__nativeId = import_NativeAnimatedHelper.default.generateNewAnimationId(), import_NativeAnimatedHelper.default.API.startAnimatingNode(
+            this.__nativeId,
+            animatedValue.__getNativeTag(),
+            config,
+            // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+            this.__debouncedOnEnd.bind(this)
+          );
+        } catch (e) {
+          throw e;
+        } finally {
+          import_NativeAnimatedHelper.default.API.unsetWaitingForIdentifier(startNativeAnimationWaitId);
+        }
+      }
+    }
+  ]), Animation2;
+}(), Animation_default = Animation;
+//# sourceMappingURL=Animation.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/vendor/react-native/Animated/animations/Users/n8/tamagui/code/packages/react-native-web-lite/src/vendor/react-native/Animated/animations/Animation.js"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AAWA,kCAAiC;;;;;;;;;;;;;;AACjC,IAAIA,6BAA6B,GAI3BC,YAAN,2BAAA;WAAMA,aAAAA;4BAAAA,UAAAA;;uBAAAA,YAAAA;;MACJC,KAAAA;aAAAA,SAAMC,WAAWC,UAAUC,OAAOC,mBAAmBC,eAAa;MAAG;;;MAErEC,KAAAA;aAAAA,WAAAA;AACE,QAAI,KAAKC,cACPC,4BAAAA,QAAqBC,IAAIC,cAAc,KAAKH,UAAU;MAE1D;;;MAEAI,KAAAA;aAAAA,WAAAA;AAGE,cAAM,IAAIC,MAAM,mDAAA;MAClB;;;;MAEAC,KAAAA;aAAAA,SAAiBC,QAAM;AACrB,YAAIX,QAAQ,KAAKY;AACjB,aAAKA,UAAU,MACfZ,SAASA,MAAMW,MAAAA;MACjB;;;MAEAE,KAAAA;aAAAA,SAAuBX,eAAa;AAClC,YAAIY,6BAA6BnB,6BAA6B;AAC9DA,sCAA8B,GAC9BU,4BAAAA,QAAqBC,IAAIS,wBAAwBD,0BAAAA;AAEjD,YAAI;AACF,cAAIE,SAAS,KAAKR,2BAA0B;AAE5CN,wBAAce,aAAaD,OAAOE,cAAc,GAEhD,KAAKd,aAAaC,4BAAAA,QAAqBc,uBAAsB,GAC7Dd,4BAAAA,QAAqBC,IAAIc;YACvB,KAAKhB;YACLF,cAAcmB,eAAc;YAC5BL;;YACA,KAAKN,iBAAiBY,KAAK,IAAI;UAAA;QAEnC,SAASC,GAAG;AACV,gBAAMA;QACR,UAAA;AACElB,sCAAAA,QAAqBC,IAAIkB,0BAA0BV,0BAAAA;QACrD;MACF;;MA3CIlB;KA8CN,oBAAeA;",
+  "names": ["startNativeAnimationNextId", "Animation", "start", "fromValue", "onUpdate", "onEnd", "previousAnimation", "animatedValue", "stop", "__nativeId", "NativeAnimatedHelper", "API", "stopAnimation", "__getNativeAnimationConfig", "Error", "__debouncedOnEnd", "result", "__onEnd", "__startNativeAnimation", "startNativeAnimationWaitId", "setWaitingForIdentifier", "config", "__makeNative", "platformConfig", "generateNewAnimationId", "startAnimatingNode", "__getNativeTag", "bind", "e", "unsetWaitingForIdentifier"]
+}

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

@@ -0,0 +1,63 @@
+"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 DecayAnimation_exports = {};
+__export(DecayAnimation_exports, {
+  default: () => DecayAnimation_default
+});
+module.exports = __toCommonJS(DecayAnimation_exports);
+var import_NativeAnimatedHelper = require("../NativeAnimatedHelper"), import_Animation = __toESM(require("./Animation"));
+class DecayAnimation extends import_Animation.default {
+  constructor(config) {
+    var _config$deceleration, _config$isInteraction, _config$iterations;
+    super(), this._deceleration = (_config$deceleration = config.deceleration) !== null && _config$deceleration !== void 0 ? _config$deceleration : 0.998, this._velocity = config.velocity, this._useNativeDriver = (0, import_NativeAnimatedHelper.shouldUseNativeDriver)(config), this.__isInteraction = (_config$isInteraction = config.isInteraction) !== null && _config$isInteraction !== void 0 ? _config$isInteraction : !this._useNativeDriver, this.__iterations = (_config$iterations = config.iterations) !== null && _config$iterations !== void 0 ? _config$iterations : 1;
+  }
+  __getNativeAnimationConfig() {
+    return {
+      type: "decay",
+      deceleration: this._deceleration,
+      velocity: this._velocity,
+      iterations: this.__iterations
+    };
+  }
+  start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
+    this.__active = !0, this._lastValue = fromValue, this._fromValue = fromValue, this._onUpdate = onUpdate, this.__onEnd = onEnd, this._startTime = Date.now(), this._useNativeDriver ? this.__startNativeAnimation(animatedValue) : this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
+  }
+  onUpdate() {
+    var now = Date.now(), value = this._fromValue + this._velocity / (1 - this._deceleration) * (1 - Math.exp(-(1 - this._deceleration) * (now - this._startTime)));
+    if (this._onUpdate(value), Math.abs(this._lastValue - value) < 0.1) {
+      this.__debouncedOnEnd({
+        finished: !0
+      });
+      return;
+    }
+    this._lastValue = value, this.__active && (this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this)));
+  }
+  stop() {
+    super.stop(), this.__active = !1, global.cancelAnimationFrame(this._animationFrame), this.__debouncedOnEnd({
+      finished: !1
+    });
+  }
+}
+var DecayAnimation_default = DecayAnimation;
+//# sourceMappingURL=DecayAnimation.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/vendor/react-native/Animated/animations/DecayAnimation.js"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,kCAAsC,oCACtC,mBAAsB;AAEtB,MAAM,uBAAuB,iBAAAA,QAAU;AAAA,EACrC,YAAY,QAAQ;AAClB,QAAI,sBAAsB,uBAAuB;AAEjD,UAAM,GACN,KAAK,iBACF,uBAAuB,OAAO,kBAAkB,QACjD,yBAAyB,SACrB,uBACA,OACN,KAAK,YAAY,OAAO,UACxB,KAAK,uBAAmB,mDAAsB,MAAM,GACpD,KAAK,mBACF,wBAAwB,OAAO,mBAAmB,QACnD,0BAA0B,SACtB,wBACA,CAAC,KAAK,kBACZ,KAAK,gBACF,qBAAqB,OAAO,gBAAgB,QAAQ,uBAAuB,SACxE,qBACA;AAAA,EACR;AAAA,EAEA,6BAA6B;AAC3B,WAAO;AAAA,MACL,MAAM;AAAA,MACN,cAAc,KAAK;AAAA,MACnB,UAAU,KAAK;AAAA,MACf,YAAY,KAAK;AAAA,IACnB;AAAA,EACF;AAAA,EAEA,MAAM,WAAW,UAAU,OAAO,mBAAmB,eAAe;AAClE,SAAK,WAAW,IAChB,KAAK,aAAa,WAClB,KAAK,aAAa,WAClB,KAAK,YAAY,UACjB,KAAK,UAAU,OACf,KAAK,aAAa,KAAK,IAAI,GAEvB,KAAK,mBACP,KAAK,uBAAuB,aAAa,IAEzC,KAAK,kBAAkB,sBAAsB,KAAK,SAAS,KAAK,IAAI,CAAC;AAAA,EAEzE;AAAA,EAEA,WAAW;AACT,QAAI,MAAM,KAAK,IAAI,GACf,QACF,KAAK,aACJ,KAAK,aAAa,IAAI,KAAK,kBACzB,IAAI,KAAK,IAAI,EAAE,IAAI,KAAK,kBAAkB,MAAM,KAAK,WAAW;AAIrE,QAFA,KAAK,UAAU,KAAK,GAEhB,KAAK,IAAI,KAAK,aAAa,KAAK,IAAI,KAAK;AAC3C,WAAK,iBAAiB;AAAA,QACpB,UAAU;AAAA,MACZ,CAAC;AAED;AAAA,IACF;AAEA,SAAK,aAAa,OAEd,KAAK,aACP,KAAK,kBAAkB,sBAAsB,KAAK,SAAS,KAAK,IAAI,CAAC;AAAA,EAEzE;AAAA,EAEA,OAAO;AACL,UAAM,KAAK,GACX,KAAK,WAAW,IAChB,OAAO,qBAAqB,KAAK,eAAe,GAEhD,KAAK,iBAAiB;AAAA,MACpB,UAAU;AAAA,IACZ,CAAC;AAAA,EACH;AACF;AAEA,IAAO,yBAAQ;",
+  "names": ["Animation"]
+}

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

@@ -0,0 +1,187 @@
+"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 DecayAnimation_exports = {};
+__export(DecayAnimation_exports, {
+  default: () => DecayAnimation_default
+});
+module.exports = __toCommonJS(DecayAnimation_exports);
+var import_NativeAnimatedHelper = require("../NativeAnimatedHelper"), import_Animation = __toESM(require("./Animation"));
+function _assert_this_initialized(self) {
+  if (self === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return self;
+}
+function _call_super(_this, derived, args) {
+  return derived = _get_prototype_of(derived), _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor))
+    throw new TypeError("Cannot call a class as a function");
+}
+function _construct(Parent, args, Class) {
+  return _is_native_reflect_construct() ? _construct = Reflect.construct : _construct = function(Parent2, args2, Class2) {
+    var a = [
+      null
+    ];
+    a.push.apply(a, args2);
+    var Constructor = Function.bind.apply(Parent2, a), instance = new Constructor();
+    return Class2 && _set_prototype_of(instance, Class2.prototype), instance;
+  }, _construct.apply(null, arguments);
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+  return protoProps && _defineProperties(Constructor.prototype, protoProps), staticProps && _defineProperties(Constructor, staticProps), Constructor;
+}
+function _get(target, property, receiver) {
+  return typeof Reflect < "u" && Reflect.get ? _get = Reflect.get : _get = function(target2, property2, receiver2) {
+    var base = _super_prop_base(target2, property2);
+    if (base) {
+      var desc = Object.getOwnPropertyDescriptor(base, property2);
+      return desc.get ? desc.get.call(receiver2 || target2) : desc.value;
+    }
+  }, _get(target, property, receiver || target);
+}
+function _get_prototype_of(o) {
+  return _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function(o2) {
+    return o2.__proto__ || Object.getPrototypeOf(o2);
+  }, _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+  if (typeof superClass != "function" && superClass !== null)
+    throw new TypeError("Super expression must either be null or a function");
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: !0,
+      configurable: !0
+    }
+  }), superClass && _set_prototype_of(subClass, superClass);
+}
+function _is_native_function(fn) {
+  return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _possible_constructor_return(self, call) {
+  return call && (_type_of(call) === "object" || typeof call == "function") ? call : _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+  return _set_prototype_of = Object.setPrototypeOf || function(o2, p2) {
+    return o2.__proto__ = p2, o2;
+  }, _set_prototype_of(o, p);
+}
+function _super_prop_base(object, property) {
+  for (; !Object.prototype.hasOwnProperty.call(object, property) && (object = _get_prototype_of(object), object !== null); )
+    ;
+  return object;
+}
+function _type_of(obj) {
+  "@swc/helpers - typeof";
+  return obj && typeof Symbol < "u" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_native_super(Class) {
+  var _cache = typeof Map == "function" ? /* @__PURE__ */ new Map() : void 0;
+  return _wrap_native_super = function(Class2) {
+    if (Class2 === null || !_is_native_function(Class2)) return Class2;
+    if (typeof Class2 != "function")
+      throw new TypeError("Super expression must either be null or a function");
+    if (typeof _cache < "u") {
+      if (_cache.has(Class2)) return _cache.get(Class2);
+      _cache.set(Class2, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class2, arguments, _get_prototype_of(this).constructor);
+    }
+    return Wrapper.prototype = Object.create(Class2.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: !1,
+        writable: !0,
+        configurable: !0
+      }
+    }), _set_prototype_of(Wrapper, Class2);
+  }, _wrap_native_super(Class);
+}
+function _is_native_reflect_construct() {
+  try {
+    var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch {
+  }
+  return (_is_native_reflect_construct = function() {
+    return !!result;
+  })();
+}
+var DecayAnimation = /* @__PURE__ */ function(Animation2) {
+  _inherits(DecayAnimation2, Animation2);
+  function DecayAnimation2(config) {
+    _class_call_check(this, DecayAnimation2);
+    var _this, _config$deceleration, _config$isInteraction, _config$iterations;
+    return _this = _call_super(this, DecayAnimation2), _this._deceleration = (_config$deceleration = config.deceleration) !== null && _config$deceleration !== void 0 ? _config$deceleration : 0.998, _this._velocity = config.velocity, _this._useNativeDriver = (0, import_NativeAnimatedHelper.shouldUseNativeDriver)(config), _this.__isInteraction = (_config$isInteraction = config.isInteraction) !== null && _config$isInteraction !== void 0 ? _config$isInteraction : !_this._useNativeDriver, _this.__iterations = (_config$iterations = config.iterations) !== null && _config$iterations !== void 0 ? _config$iterations : 1, _this;
+  }
+  return _create_class(DecayAnimation2, [
+    {
+      key: "__getNativeAnimationConfig",
+      value: function() {
+        return {
+          type: "decay",
+          deceleration: this._deceleration,
+          velocity: this._velocity,
+          iterations: this.__iterations
+        };
+      }
+    },
+    {
+      key: "start",
+      value: function(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
+        this.__active = !0, this._lastValue = fromValue, this._fromValue = fromValue, this._onUpdate = onUpdate, this.__onEnd = onEnd, this._startTime = Date.now(), this._useNativeDriver ? this.__startNativeAnimation(animatedValue) : this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
+      }
+    },
+    {
+      key: "onUpdate",
+      value: function() {
+        var now = Date.now(), value = this._fromValue + this._velocity / (1 - this._deceleration) * (1 - Math.exp(-(1 - this._deceleration) * (now - this._startTime)));
+        if (this._onUpdate(value), Math.abs(this._lastValue - value) < 0.1) {
+          this.__debouncedOnEnd({
+            finished: !0
+          });
+          return;
+        }
+        this._lastValue = value, this.__active && (this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this)));
+      }
+    },
+    {
+      key: "stop",
+      value: function() {
+        _get(_get_prototype_of(DecayAnimation2.prototype), "stop", this).call(this), this.__active = !1, global.cancelAnimationFrame(this._animationFrame), this.__debouncedOnEnd({
+          finished: !1
+        });
+      }
+    }
+  ]), DecayAnimation2;
+}(_wrap_native_super(import_Animation.default)), DecayAnimation_default = DecayAnimation;
+//# sourceMappingURL=DecayAnimation.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/vendor/react-native/Animated/animations/Users/n8/tamagui/code/packages/react-native-web-lite/src/vendor/react-native/Animated/animations/DecayAnimation.js"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AAWA,kCAAsC,oCACtC,mBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEtB,IAAMA,iBAAN,yBAAAC,YAAA;YAAMD,iBAAAA,UAAAA;WAAAA,gBACQE,QAAM;4BADdF,eAAAA;eAEEG,sBAAsBC,uBAAuBC;mBAEjD,YAAA,MAJEL,eAAAA,GAKF,MAAKM,iBACFH,uBAAuBD,OAAOK,kBAAkB,QACjDJ,yBAAyB,SACrBA,uBACA,OACN,MAAKK,YAAYN,OAAOO,UACxB,MAAKC,uBAAmBC,mDAAsBT,MAAAA,GAC9C,MAAKU,mBACFR,wBAAwBF,OAAOW,mBAAmB,QACnDT,0BAA0B,SACtBA,wBACA,CAAC,MAAKM,kBACZ,MAAKI,gBACFT,qBAAqBH,OAAOa,gBAAgB,QAAQV,uBAAuB,SACxEA,qBACA;;uBApBJL,iBAAAA;;MAuBJgB,KAAAA;aAAAA,WAAAA;AACE,eAAO;UACLC,MAAM;UACNV,cAAc,KAAKD;UACnBG,UAAU,KAAKD;UACfO,YAAY,KAAKD;QACnB;MACF;;;MAEAI,KAAAA;aAAAA,SAAMC,WAAWC,UAAUC,OAAOC,mBAAmBC,eAAa;AAChE,aAAKC,WAAW,IAChB,KAAKC,aAAaN,WAClB,KAAKO,aAAaP,WAClB,KAAKQ,YAAYP,UACjB,KAAKQ,UAAUP,OACf,KAAKQ,aAAaC,KAAKC,IAAG,GAEtB,KAAKrB,mBACP,KAAKsB,uBAAuBT,aAAAA,IAE5B,KAAKU,kBAAkBC,sBAAsB,KAAKd,SAASe,KAAK,IAAI,CAAA;MAExE;;;MAEAf,KAAAA;aAAAA,WAAAA;AACE,YAAIW,MAAMD,KAAKC,IAAG,GACdK,QACF,KAAKV,aACJ,KAAKlB,aAAa,IAAI,KAAKF,kBACzB,IAAI+B,KAAKC,IAAI,EAAE,IAAI,KAAKhC,kBAAkByB,MAAM,KAAKF,WAAS;AAInE,YAFA,KAAKF,UAAUS,KAAAA,GAEXC,KAAKE,IAAI,KAAKd,aAAaW,KAAAA,IAAS,KAAK;AAC3C,eAAKI,iBAAiB;YACpBC,UAAU;UACZ,CAAA;AAEA;QACF;AAEA,aAAKhB,aAAaW,OAEd,KAAKZ,aACP,KAAKS,kBAAkBC,sBAAsB,KAAKd,SAASe,KAAK,IAAI,CAAA;MAExE;;;MAEAO,KAAAA;aAAAA,WAAAA;AACE,aAAA,kBAxEE1C,gBAAAA,SAAAA,GAwEI0C,QAAN,IAAK,EAAA,KAAA,IAAA,GACL,KAAKlB,WAAW,IAChBmB,OAAOC,qBAAqB,KAAKX,eAAe,GAEhD,KAAKO,iBAAiB;UACpBC,UAAU;QACZ,CAAA;MACF;;MA/EIzC;qBAAuBC,iBAAAA,OAAAA,CAAAA,GAkF7B,yBAAeD;",
+  "names": ["DecayAnimation", "Animation", "config", "_config$deceleration", "_config$isInteraction", "_config$iterations", "_deceleration", "deceleration", "_velocity", "velocity", "_useNativeDriver", "shouldUseNativeDriver", "__isInteraction", "isInteraction", "__iterations", "iterations", "__getNativeAnimationConfig", "type", "start", "fromValue", "onUpdate", "onEnd", "previousAnimation", "animatedValue", "__active", "_lastValue", "_fromValue", "_onUpdate", "__onEnd", "_startTime", "Date", "now", "__startNativeAnimation", "_animationFrame", "requestAnimationFrame", "bind", "value", "Math", "exp", "abs", "__debouncedOnEnd", "finished", "stop", "global", "cancelAnimationFrame"]
+}