@tamagui/react-native-web-lite 1.112.5

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

@@ -0,0 +1,162 @@
+"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 AnimatedTracking_exports = {};
+__export(AnimatedTracking_exports, {
+  default: () => AnimatedTracking_default
+});
+module.exports = __toCommonJS(AnimatedTracking_exports);
+var import_NativeAnimatedHelper = require("../NativeAnimatedHelper"), import_AnimatedNode = __toESM(require("./AnimatedNode"));
+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 _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 _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 _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 AnimatedTracking = /* @__PURE__ */ function(AnimatedNode2) {
+  _inherits(AnimatedTracking2, AnimatedNode2);
+  function AnimatedTracking2(value, parent, animationClass, animationConfig, callback) {
+    _class_call_check(this, AnimatedTracking2);
+    var _this;
+    return _this = _call_super(this, AnimatedTracking2), _this._value = value, _this._parent = parent, _this._animationClass = animationClass, _this._animationConfig = animationConfig, _this._useNativeDriver = (0, import_NativeAnimatedHelper.shouldUseNativeDriver)(animationConfig), _this._callback = callback, _this.__attach(), _this;
+  }
+  return _create_class(AnimatedTracking2, [
+    {
+      key: "__makeNative",
+      value: function() {
+        this.__isNative = !0, this._parent.__makeNative(), _get(_get_prototype_of(AnimatedTracking2.prototype), "__makeNative", this).call(this), this._value.__makeNative();
+      }
+    },
+    {
+      key: "__getValue",
+      value: function() {
+        return this._parent.__getValue();
+      }
+    },
+    {
+      key: "__attach",
+      value: function() {
+        this._parent.__addChild(this), this._useNativeDriver && this.__makeNative();
+      }
+    },
+    {
+      key: "__detach",
+      value: function() {
+        this._parent.__removeChild(this), _get(_get_prototype_of(AnimatedTracking2.prototype), "__detach", this).call(this);
+      }
+    },
+    {
+      key: "update",
+      value: function() {
+        this._value.animate(new this._animationClass({
+          ...this._animationConfig,
+          toValue: this._animationConfig.toValue.__getValue()
+        }), this._callback);
+      }
+    },
+    {
+      key: "__getNativeConfig",
+      value: function() {
+        var animation = new this._animationClass(_objectSpread(_objectSpread({}, this._animationConfig), {}, {
+          // remove toValue from the config as it's a ref to Animated.Value
+          toValue: void 0
+        })), animationConfig = animation.__getNativeAnimationConfig();
+        return {
+          type: "tracking",
+          animationId: (0, import_NativeAnimatedHelper.generateNewAnimationId)(),
+          animationConfig,
+          toValue: this._parent.__getNativeTag(),
+          value: this._value.__getNativeTag()
+        };
+      }
+    }
+  ]), AnimatedTracking2;
+}(import_AnimatedNode.default), AnimatedTracking_default = AnimatedTracking;
+//# sourceMappingURL=AnimatedTracking.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/vendor/react-native/Animated/nodes/Users/n8/tamagui/code/packages/react-native-web-lite/src/vendor/react-native/Animated/nodes/AnimatedTracking.js"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AAWA,kCAA8D,oCAC9D,sBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEzB,IAAMA,mBAAN,yBAAAC,eAAA;YAAMD,mBAAAA,aAAAA;WAAAA,kBACQE,OAAOC,QAAQC,gBAAgBC,iBAAiBC,UAAQ;4BADhEN,iBAAAA;;mBAEF,YAAA,MAFEA,iBAAAA,GAGF,MAAKO,SAASL,OACd,MAAKM,UAAUL,QACf,MAAKM,kBAAkBL,gBACvB,MAAKM,mBAAmBL,iBACxB,MAAKM,uBAAmBC,mDAAsBP,eAAAA,GAC9C,MAAKQ,YAAYP,UAEjB,MAAKQ,SAAQ;;uBAVXd,mBAAAA;;MAaJe,KAAAA;aAAAA,WAAAA;AACE,aAAKC,aAAa,IAElB,KAAKR,QAAQO,aAAY,GAEzB,KAAA,kBAlBEf,kBAAAA,SAAAA,GAkBIe,gBAAN,IAAK,EAAA,KAAA,IAAA,GAEL,KAAKR,OAAOQ,aAAY;MAC1B;;;MAEAE,KAAAA;aAAAA,WAAAA;AACE,eAAO,KAAKT,QAAQS,WAAU;MAChC;;;MAEAH,KAAAA;aAAAA,WAAAA;AACE,aAAKN,QAAQU,WAAW,IAAI,GAExB,KAAKP,oBAMP,KAAKI,aAAY;MAErB;;;MAEAI,KAAAA;aAAAA,WAAAA;AACE,aAAKX,QAAQY,cAAc,IAAI,GAE/B,KAAA,kBA3CEpB,kBAAAA,SAAAA,GA2CImB,YAAN,IAAK,EAAA,KAAA,IAAA;MACP;;;MAEAE,KAAAA;aAAAA,WAAAA;AACE,aAAKd,OAAOe,QACV,IAAI,KAAKb,gBAAgB;UACvB,GAAG,KAAKC;UACRa,SAAS,KAAKb,iBAAiBa,QAAQN,WAAU;QACnD,CAAA,GACA,KAAKJ,SAAS;MAElB;;;MAEAW,KAAAA;aAAAA,WAAAA;AACE,YAAIC,YAAY,IAAI,KAAKhB,gBACvBiB,cACEA,cAAc,CAAC,GAAG,KAAKhB,gBAAgB,GACvC,CAAC,GACD;;UAEEa,SAASI;QACX,CAAA,CAAA,GAIAtB,kBAAkBoB,UAAUG,2BAA0B;AAE1D,eAAO;UACLC,MAAM;UACNC,iBAAaC,oDAAAA;UACb1B;UACAkB,SAAS,KAAKf,QAAQwB,eAAc;UACpC9B,OAAO,KAAKK,OAAOyB,eAAc;QACnC;MACF;;MA7EIhC;EAAyBC,oBAAAA,OAAAA,GAgF/B,2BAAeD;",
+  "names": ["AnimatedTracking", "AnimatedNode", "value", "parent", "animationClass", "animationConfig", "callback", "_value", "_parent", "_animationClass", "_animationConfig", "_useNativeDriver", "shouldUseNativeDriver", "_callback", "__attach", "__makeNative", "__isNative", "__getValue", "__addChild", "__detach", "__removeChild", "update", "animate", "toValue", "__getNativeConfig", "animation", "_objectSpread", "undefined", "__getNativeAnimationConfig", "type", "animationId", "generateNewAnimationId", "__getNativeTag"]
+}

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

@@ -0,0 +1,100 @@
+"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 AnimatedTransform_exports = {};
+__export(AnimatedTransform_exports, {
+  default: () => AnimatedTransform_default
+});
+module.exports = __toCommonJS(AnimatedTransform_exports);
+var import_NativeAnimatedHelper = __toESM(require("../NativeAnimatedHelper")), import_AnimatedNode = __toESM(require("./AnimatedNode")), import_AnimatedWithChildren = __toESM(require("./AnimatedWithChildren"));
+class AnimatedTransform extends import_AnimatedWithChildren.default {
+  constructor(transforms) {
+    super(), this._transforms = transforms || [];
+  }
+  __makeNative() {
+    this._transforms.forEach((transform) => {
+      for (var key in transform) {
+        var value = transform[key];
+        value instanceof import_AnimatedNode.default && value.__makeNative();
+      }
+    }), super.__makeNative();
+  }
+  __getValue() {
+    return this._transforms.map((transform) => {
+      var result = {};
+      for (var key in transform) {
+        var value = transform[key];
+        value instanceof import_AnimatedNode.default ? result[key] = value.__getValue() : result[key] = value;
+      }
+      return result;
+    });
+  }
+  __getAnimatedValue() {
+    return this._transforms.map((transform) => {
+      var result = {};
+      for (var key in transform) {
+        var value = transform[key];
+        value instanceof import_AnimatedNode.default ? result[key] = value.__getAnimatedValue() : result[key] = value;
+      }
+      return result;
+    });
+  }
+  __attach() {
+    this._transforms.forEach((transform) => {
+      for (var key in transform) {
+        var value = transform[key];
+        value instanceof import_AnimatedNode.default && value.__addChild(this);
+      }
+    });
+  }
+  __detach() {
+    this._transforms.forEach((transform) => {
+      for (var key in transform) {
+        var value = transform[key];
+        value instanceof import_AnimatedNode.default && value.__removeChild(this);
+      }
+    }), super.__detach();
+  }
+  __getNativeConfig() {
+    var transConfigs = [];
+    return this._transforms.forEach((transform) => {
+      for (var key in transform) {
+        var value = transform[key];
+        value instanceof import_AnimatedNode.default ? transConfigs.push({
+          type: "animated",
+          property: key,
+          nodeTag: value.__getNativeTag()
+        }) : transConfigs.push({
+          type: "static",
+          property: key,
+          value: import_NativeAnimatedHelper.default.transformDataType(value)
+        });
+      }
+    }), import_NativeAnimatedHelper.default.validateTransform(transConfigs), {
+      type: "transform",
+      transforms: transConfigs
+    };
+  }
+}
+var AnimatedTransform_default = AnimatedTransform;
+//# sourceMappingURL=AnimatedTransform.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/vendor/react-native/Animated/nodes/AnimatedTransform.js"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,kCAAiC,6CACjC,sBAAyB,oCACzB,8BAAiC;AAEjC,MAAM,0BAA0B,4BAAAA,QAAqB;AAAA,EACnD,YAAY,YAAY;AACtB,UAAM,GACN,KAAK,cAAc,cAAc,CAAC;AAAA,EACpC;AAAA,EAEA,eAAe;AACb,SAAK,YAAY,QAAQ,CAAC,cAAc;AACtC,eAAS,OAAO,WAAW;AACzB,YAAI,QAAQ,UAAU,GAAG;AAEzB,QAAI,iBAAiB,oBAAAC,WACnB,MAAM,aAAa;AAAA,MAEvB;AAAA,IACF,CAAC,GAED,MAAM,aAAa;AAAA,EACrB;AAAA,EAEA,aAAa;AACX,WAAO,KAAK,YAAY,IAAI,CAAC,cAAc;AACzC,UAAI,SAAS,CAAC;AAEd,eAAS,OAAO,WAAW;AACzB,YAAI,QAAQ,UAAU,GAAG;AAEzB,QAAI,iBAAiB,oBAAAA,UACnB,OAAO,GAAG,IAAI,MAAM,WAAW,IAE/B,OAAO,GAAG,IAAI;AAAA,MAElB;AAEA,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AAAA,EAEA,qBAAqB;AACnB,WAAO,KAAK,YAAY,IAAI,CAAC,cAAc;AACzC,UAAI,SAAS,CAAC;AAEd,eAAS,OAAO,WAAW;AACzB,YAAI,QAAQ,UAAU,GAAG;AAEzB,QAAI,iBAAiB,oBAAAA,UACnB,OAAO,GAAG,IAAI,MAAM,mBAAmB,IAGvC,OAAO,GAAG,IAAI;AAAA,MAElB;AAEA,aAAO;AAAA,IACT,CAAC;AAAA,EACH;AAAA,EAEA,WAAW;AACT,SAAK,YAAY,QAAQ,CAAC,cAAc;AACtC,eAAS,OAAO,WAAW;AACzB,YAAI,QAAQ,UAAU,GAAG;AAEzB,QAAI,iBAAiB,oBAAAA,WACnB,MAAM,WAAW,IAAI;AAAA,MAEzB;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,WAAW;AACT,SAAK,YAAY,QAAQ,CAAC,cAAc;AACtC,eAAS,OAAO,WAAW;AACzB,YAAI,QAAQ,UAAU,GAAG;AAEzB,QAAI,iBAAiB,oBAAAA,WACnB,MAAM,cAAc,IAAI;AAAA,MAE5B;AAAA,IACF,CAAC,GAED,MAAM,SAAS;AAAA,EACjB;AAAA,EAEA,oBAAoB;AAClB,QAAI,eAAe,CAAC;AAEpB,gBAAK,YAAY,QAAQ,CAAC,cAAc;AACtC,eAAS,OAAO,WAAW;AACzB,YAAI,QAAQ,UAAU,GAAG;AAEzB,QAAI,iBAAiB,oBAAAA,UACnB,aAAa,KAAK;AAAA,UAChB,MAAM;AAAA,UACN,UAAU;AAAA,UACV,SAAS,MAAM,eAAe;AAAA,QAChC,CAAC,IAED,aAAa,KAAK;AAAA,UAChB,MAAM;AAAA,UACN,UAAU;AAAA,UACV,OAAO,4BAAAC,QAAqB,kBAAkB,KAAK;AAAA,QACrD,CAAC;AAAA,MAEL;AAAA,IACF,CAAC,GAED,4BAAAA,QAAqB,kBAAkB,YAAY,GAC5C;AAAA,MACL,MAAM;AAAA,MACN,YAAY;AAAA,IACd;AAAA,EACF;AACF;AAEA,IAAO,4BAAQ;",
+  "names": ["AnimatedWithChildren", "AnimatedNode", "NativeAnimatedHelper"]
+}

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedTransform.native.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 AnimatedTransform_exports = {};
+__export(AnimatedTransform_exports, {
+  default: () => AnimatedTransform_default
+});
+module.exports = __toCommonJS(AnimatedTransform_exports);
+var import_NativeAnimatedHelper = __toESM(require("../NativeAnimatedHelper")), import_AnimatedNode = __toESM(require("./AnimatedNode")), import_AnimatedWithChildren = __toESM(require("./AnimatedWithChildren"));
+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 _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 _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 _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 AnimatedTransform = /* @__PURE__ */ function(AnimatedWithChildren2) {
+  _inherits(AnimatedTransform2, AnimatedWithChildren2);
+  function AnimatedTransform2(transforms) {
+    _class_call_check(this, AnimatedTransform2);
+    var _this;
+    return _this = _call_super(this, AnimatedTransform2), _this._transforms = transforms || [], _this;
+  }
+  return _create_class(AnimatedTransform2, [
+    {
+      key: "__makeNative",
+      value: function() {
+        this._transforms.forEach(function(transform) {
+          for (var key in transform) {
+            var value = transform[key];
+            value instanceof import_AnimatedNode.default && value.__makeNative();
+          }
+        }), _get(_get_prototype_of(AnimatedTransform2.prototype), "__makeNative", this).call(this);
+      }
+    },
+    {
+      key: "__getValue",
+      value: function() {
+        return this._transforms.map(function(transform) {
+          var result = {};
+          for (var key in transform) {
+            var value = transform[key];
+            value instanceof import_AnimatedNode.default ? result[key] = value.__getValue() : result[key] = value;
+          }
+          return result;
+        });
+      }
+    },
+    {
+      key: "__getAnimatedValue",
+      value: function() {
+        return this._transforms.map(function(transform) {
+          var result = {};
+          for (var key in transform) {
+            var value = transform[key];
+            value instanceof import_AnimatedNode.default ? result[key] = value.__getAnimatedValue() : result[key] = value;
+          }
+          return result;
+        });
+      }
+    },
+    {
+      key: "__attach",
+      value: function() {
+        var _this = this;
+        this._transforms.forEach(function(transform) {
+          for (var key in transform) {
+            var value = transform[key];
+            value instanceof import_AnimatedNode.default && value.__addChild(_this);
+          }
+        });
+      }
+    },
+    {
+      key: "__detach",
+      value: function() {
+        var _this = this;
+        this._transforms.forEach(function(transform) {
+          for (var key in transform) {
+            var value = transform[key];
+            value instanceof import_AnimatedNode.default && value.__removeChild(_this);
+          }
+        }), _get(_get_prototype_of(AnimatedTransform2.prototype), "__detach", this).call(this);
+      }
+    },
+    {
+      key: "__getNativeConfig",
+      value: function() {
+        var transConfigs = [];
+        return this._transforms.forEach(function(transform) {
+          for (var key in transform) {
+            var value = transform[key];
+            value instanceof import_AnimatedNode.default ? transConfigs.push({
+              type: "animated",
+              property: key,
+              nodeTag: value.__getNativeTag()
+            }) : transConfigs.push({
+              type: "static",
+              property: key,
+              value: import_NativeAnimatedHelper.default.transformDataType(value)
+            });
+          }
+        }), import_NativeAnimatedHelper.default.validateTransform(transConfigs), {
+          type: "transform",
+          transforms: transConfigs
+        };
+      }
+    }
+  ]), AnimatedTransform2;
+}(import_AnimatedWithChildren.default), AnimatedTransform_default = AnimatedTransform;
+//# sourceMappingURL=AnimatedTransform.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../src/vendor/react-native/Animated/nodes/Users/n8/tamagui/code/packages/react-native-web-lite/src/vendor/react-native/Animated/nodes/AnimatedTransform.js"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AAWA,kCAAiC,6CACjC,sBAAyB,oCACzB,8BAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEjC,IAAMA,oBAAN,yBAAAC,uBAAA;YAAMD,oBAAAA,qBAAAA;WAAAA,mBACQE,YAAU;4BADlBF,kBAAAA;;mBAEF,YAAA,MAFEA,kBAAAA,GAGF,MAAKG,cAAcD,cAAc,CAAA;;uBAH/BF,oBAAAA;;MAMJI,KAAAA;aAAAA,WAAAA;AACE,aAAKD,YAAYE,QAAQ,SAACC,WAAAA;AACxB,mBAASC,OAAOD,WAAW;AACzB,gBAAIE,QAAQF,UAAUC,GAAAA;AAEtB,YAAIC,iBAAiBC,oBAAAA,WACnBD,MAAMJ,aAAY;UAEtB;QACF,CAAA,GAEA,KAAA,kBAjBEJ,mBAAAA,SAAAA,GAiBII,gBAAN,IAAK,EAAA,KAAA,IAAA;MACP;;;MAEAM,KAAAA;aAAAA,WAAAA;AACE,eAAO,KAAKP,YAAYQ,IAAI,SAACL,WAAAA;AAC3B,cAAIM,SAAS,CAAC;AAEd,mBAASL,OAAOD,WAAW;AACzB,gBAAIE,QAAQF,UAAUC,GAAAA;AAEtB,YAAIC,iBAAiBC,oBAAAA,UACnBG,OAAOL,GAAAA,IAAOC,MAAME,WAAU,IAE9BE,OAAOL,GAAAA,IAAOC;UAElB;AAEA,iBAAOI;QACT,CAAA;MACF;;;MAEAC,KAAAA;aAAAA,WAAAA;AACE,eAAO,KAAKV,YAAYQ,IAAI,SAACL,WAAAA;AAC3B,cAAIM,SAAS,CAAC;AAEd,mBAASL,OAAOD,WAAW;AACzB,gBAAIE,QAAQF,UAAUC,GAAAA;AAEtB,YAAIC,iBAAiBC,oBAAAA,UACnBG,OAAOL,GAAAA,IAAOC,MAAMK,mBAAkB,IAGtCD,OAAOL,GAAAA,IAAOC;UAElB;AAEA,iBAAOI;QACT,CAAA;MACF;;;MAEAE,KAAAA;aAAAA,WAAAA;;AACE,aAAKX,YAAYE,QAAQ,SAACC,WAAAA;AACxB,mBAASC,OAAOD,WAAW;AACzB,gBAAIE,QAAQF,UAAUC,GAAAA;AAEtB,YAAIC,iBAAiBC,oBAAAA,WACnBD,MAAMO,WAAU,KAAA;UAEpB;QACF,CAAA;MACF;;;MAEAC,KAAAA;aAAAA,WAAAA;;AACE,aAAKb,YAAYE,QAAQ,SAACC,WAAAA;AACxB,mBAASC,OAAOD,WAAW;AACzB,gBAAIE,QAAQF,UAAUC,GAAAA;AAEtB,YAAIC,iBAAiBC,oBAAAA,WACnBD,MAAMS,cAAa,KAAA;UAEvB;QACF,CAAA,GAEA,KAAA,kBAhFEjB,mBAAAA,SAAAA,GAgFIgB,YAAN,IAAK,EAAA,KAAA,IAAA;MACP;;;MAEAE,KAAAA;aAAAA,WAAAA;AACE,YAAIC,eAAe,CAAA;AAEnB,oBAAKhB,YAAYE,QAAQ,SAACC,WAAAA;AACxB,mBAASC,OAAOD,WAAW;AACzB,gBAAIE,QAAQF,UAAUC,GAAAA;AAEtB,YAAIC,iBAAiBC,oBAAAA,UACnBU,aAAaC,KAAK;cAChBC,MAAM;cACNC,UAAUf;cACVgB,SAASf,MAAMgB,eAAc;YAC/B,CAAA,IAEAL,aAAaC,KAAK;cAChBC,MAAM;cACNC,UAAUf;cACVC,OAAOiB,4BAAAA,QAAqBC,kBAAkBlB,KAAAA;YAChD,CAAA;UAEJ;QACF,CAAA,GAEAiB,4BAAAA,QAAqBE,kBAAkBR,YAAAA,GAChC;UACLE,MAAM;UACNnB,YAAYiB;QACd;MACF;;MA/GInB;EAA0BC,4BAAAA,OAAAA,GAkHhC,4BAAeD;",
+  "names": ["AnimatedTransform", "AnimatedWithChildren", "transforms", "_transforms", "__makeNative", "forEach", "transform", "key", "value", "AnimatedNode", "__getValue", "map", "result", "__getAnimatedValue", "__attach", "__addChild", "__detach", "__removeChild", "__getNativeConfig", "transConfigs", "push", "type", "property", "nodeTag", "__getNativeTag", "NativeAnimatedHelper", "transformDataType", "validateTransform"]
+}

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

@@ -0,0 +1,182 @@
+"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 AnimatedValue_exports = {};
+__export(AnimatedValue_exports, {
+  default: () => AnimatedValue_default
+});
+module.exports = __toCommonJS(AnimatedValue_exports);
+var import_react_native_web_internals = require("@tamagui/react-native-web-internals"), import_NativeAnimatedHelper = __toESM(require("../NativeAnimatedHelper")), import_AnimatedInterpolation = __toESM(require("./AnimatedInterpolation")), import_AnimatedWithChildren = __toESM(require("./AnimatedWithChildren")), NativeAnimatedAPI = import_NativeAnimatedHelper.default.API;
+function _flush(rootNode) {
+  var animatedStyles = /* @__PURE__ */ new Set();
+  function findAnimatedStyles(node) {
+    typeof node.update == "function" ? animatedStyles.add(node) : node.__getChildren().forEach(findAnimatedStyles);
+  }
+  findAnimatedStyles(rootNode), animatedStyles.forEach((animatedStyle) => animatedStyle.update());
+}
+function _executeAsAnimatedBatch(id, operation) {
+  NativeAnimatedAPI.setWaitingForIdentifier(id), operation(), NativeAnimatedAPI.unsetWaitingForIdentifier(id);
+}
+class AnimatedValue extends import_AnimatedWithChildren.default {
+  constructor(value, config) {
+    if (super(), typeof value != "number")
+      throw new Error("AnimatedValue: Attempting to set value to undefined");
+    this._startingValue = this._value = value, this._offset = 0, this._animation = null, config && config.useNativeDriver && this.__makeNative();
+  }
+  __detach() {
+    this.__isNative && NativeAnimatedAPI.getValue(this.__getNativeTag(), (value) => {
+      this._value = value - this._offset;
+    }), this.stopAnimation(), super.__detach();
+  }
+  __getValue() {
+    return this._value + this._offset;
+  }
+  /**
+   * Directly set the value.  This will stop any animations running on the value
+   * and update all the bound properties.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#setvalue
+   */
+  setValue(value) {
+    this._animation && (this._animation.stop(), this._animation = null), this._updateValue(
+      value,
+      !this.__isNative
+      /* don't perform a flush for natively driven values */
+    ), this.__isNative && _executeAsAnimatedBatch(
+      this.__getNativeTag().toString(),
+      () => NativeAnimatedAPI.setAnimatedNodeValue(this.__getNativeTag(), value)
+    );
+  }
+  /**
+   * 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.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#setoffset
+   */
+  setOffset(offset) {
+    this._offset = offset, this.__isNative && NativeAnimatedAPI.setAnimatedNodeOffset(this.__getNativeTag(), offset);
+  }
+  /**
+   * Merges the offset value into the base value and resets the offset to zero.
+   * The final output of the value is unchanged.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#flattenoffset
+   */
+  flattenOffset() {
+    this._value += this._offset, this._offset = 0, this.__isNative && NativeAnimatedAPI.flattenAnimatedNodeOffset(this.__getNativeTag());
+  }
+  /**
+   * Sets the offset value to the base value, and resets the base value to zero.
+   * The final output of the value is unchanged.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#extractoffset
+   */
+  extractOffset() {
+    this._offset += this._value, this._value = 0, this.__isNative && NativeAnimatedAPI.extractAnimatedNodeOffset(this.__getNativeTag());
+  }
+  /**
+   * 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.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#stopanimation
+   */
+  stopAnimation(callback) {
+    this.stopTracking(), this._animation && this._animation.stop(), this._animation = null, callback && (this.__isNative ? NativeAnimatedAPI.getValue(this.__getNativeTag(), callback) : callback(this.__getValue()));
+  }
+  /**
+   * Stops any animation and resets the value to its original.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#resetanimation
+   */
+  resetAnimation(callback) {
+    this.stopAnimation(callback), this._value = this._startingValue, this.__isNative && NativeAnimatedAPI.setAnimatedNodeValue(this.__getNativeTag(), this._startingValue);
+  }
+  __onAnimatedValueUpdateReceived(value) {
+    this._updateValue(
+      value,
+      !1
+      /*flush*/
+    );
+  }
+  /**
+   * Interpolates the value before updating the property, e.g. mapping 0-1 to
+   * 0-10.
+   */
+  interpolate(config) {
+    return new import_AnimatedInterpolation.default(this, config);
+  }
+  /**
+   * Typically only used internally, but could be used by a custom Animation
+   * class.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#animate
+   */
+  animate(animation, callback) {
+    var handle = null;
+    animation.__isInteraction && (handle = import_react_native_web_internals.InteractionManager.createInteractionHandle());
+    var previousAnimation = this._animation;
+    this._animation && this._animation.stop(), this._animation = animation, animation.start(
+      this._value,
+      (value) => {
+        this._updateValue(
+          value,
+          !0
+          /* flush */
+        );
+      },
+      (result) => {
+        this._animation = null, handle !== null && import_react_native_web_internals.InteractionManager.clearInteractionHandle(handle), callback && callback(result);
+      },
+      previousAnimation,
+      this
+    );
+  }
+  /**
+   * Typically only used internally.
+   */
+  stopTracking() {
+    this._tracking && this._tracking.__detach(), this._tracking = null;
+  }
+  /**
+   * Typically only used internally.
+   */
+  track(tracking) {
+    this.stopTracking(), this._tracking = tracking, this._tracking && this._tracking.update();
+  }
+  _updateValue(value, flush) {
+    if (value === void 0)
+      throw new Error("AnimatedValue: Attempting to set value to undefined");
+    this._value = value, flush && _flush(this), super.__callListeners(this.__getValue());
+  }
+  __getNativeConfig() {
+    return {
+      type: "value",
+      value: this._value,
+      offset: this._offset
+    };
+  }
+}
+var AnimatedValue_default = AnimatedValue;
+//# sourceMappingURL=AnimatedValue.js.map