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

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

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

@@ -0,0 +1,167 @@
+"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 AnimatedValueXY_exports = {};
+__export(AnimatedValueXY_exports, {
+  default: () => AnimatedValueXY_default
+});
+module.exports = __toCommonJS(AnimatedValueXY_exports);
+var import_react_native_web_internals = require("@tamagui/react-native-web-internals"), import_AnimatedValue = __toESM(require("./AnimatedValue")), import_AnimatedWithChildren = __toESM(require("./AnimatedWithChildren")), _uniqueId = 1;
+class AnimatedValueXY extends import_AnimatedWithChildren.default {
+  constructor(valueIn) {
+    super();
+    var value = valueIn || {
+      x: 0,
+      y: 0
+    };
+    typeof value.x == "number" && typeof value.y == "number" ? (this.x = new import_AnimatedValue.default(value.x), this.y = new import_AnimatedValue.default(value.y)) : ((0, import_react_native_web_internals.invariant)(
+      value.x instanceof import_AnimatedValue.default && value.y instanceof import_AnimatedValue.default,
+      "AnimatedValueXY must be initialized with an object of numbers or AnimatedValues."
+    ), this.x = value.x, this.y = value.y), this._listeners = {};
+  }
+  /**
+   * Directly set the value. This will stop any animations running on the value
+   * and update all the bound properties.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#setvalue
+   */
+  setValue(value) {
+    this.x.setValue(value.x), this.y.setValue(value.y);
+  }
+  /**
+   * 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/animatedvaluexy.html#setoffset
+   */
+  setOffset(offset) {
+    this.x.setOffset(offset.x), this.y.setOffset(offset.y);
+  }
+  /**
+   * 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/animatedvaluexy.html#flattenoffset
+   */
+  flattenOffset() {
+    this.x.flattenOffset(), this.y.flattenOffset();
+  }
+  /**
+   * 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/animatedvaluexy.html#extractoffset
+   */
+  extractOffset() {
+    this.x.extractOffset(), this.y.extractOffset();
+  }
+  __getValue() {
+    return {
+      x: this.x.__getValue(),
+      y: this.y.__getValue()
+    };
+  }
+  /**
+   * Stops any animation and resets the value to its original.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#resetanimation
+   */
+  resetAnimation(callback) {
+    this.x.resetAnimation(), this.y.resetAnimation(), callback && callback(this.__getValue());
+  }
+  /**
+   * 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/animatedvaluexy.html#stopanimation
+   */
+  stopAnimation(callback) {
+    this.x.stopAnimation(), this.y.stopAnimation(), callback && callback(this.__getValue());
+  }
+  /**
+   * 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.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#addlistener
+   */
+  addListener(callback) {
+    var id = String(_uniqueId++), jointCallback = (_ref) => {
+      var number = _ref.value;
+      callback(this.__getValue());
+    };
+    return this._listeners[id] = {
+      x: this.x.addListener(jointCallback),
+      y: this.y.addListener(jointCallback)
+    }, id;
+  }
+  /**
+   * Unregister a listener. The `id` param shall match the identifier
+   * previously returned by `addListener()`.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#removelistener
+   */
+  removeListener(id) {
+    this.x.removeListener(this._listeners[id].x), this.y.removeListener(this._listeners[id].y), delete this._listeners[id];
+  }
+  /**
+   * Remove all registered listeners.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#removealllisteners
+   */
+  removeAllListeners() {
+    this.x.removeAllListeners(), this.y.removeAllListeners(), this._listeners = {};
+  }
+  /**
+   * Converts `{x, y}` into `{left, top}` for use in style.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#getlayout
+   */
+  getLayout() {
+    return {
+      left: this.x,
+      top: this.y
+    };
+  }
+  /**
+   * Converts `{x, y}` into a useable translation transform.
+   *
+   * See https://reactnative.dev/docs/animatedvaluexy.html#gettranslatetransform
+   */
+  getTranslateTransform() {
+    return [
+      {
+        translateX: this.x
+      },
+      {
+        translateY: this.y
+      }
+    ];
+  }
+}
+var AnimatedValueXY_default = AnimatedValueXY;
+//# sourceMappingURL=AnimatedValueXY.js.map

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

@@ -0,0 +1,67 @@
+"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 AnimatedWithChildren_exports = {};
+__export(AnimatedWithChildren_exports, {
+  default: () => AnimatedWithChildren_default
+});
+module.exports = __toCommonJS(AnimatedWithChildren_exports);
+var import_createForOfIteratorHelperLoose = __toESM(require("@babel/runtime/helpers/createForOfIteratorHelperLoose")), import_AnimatedNode = __toESM(require("./AnimatedNode")), import_NativeAnimatedHelper = __toESM(require("../NativeAnimatedHelper"));
+class AnimatedWithChildren extends import_AnimatedNode.default {
+  constructor() {
+    super(), this._children = [];
+  }
+  __makeNative(platformConfig) {
+    if (!this.__isNative) {
+      this.__isNative = !0;
+      for (var _iterator = (0, import_createForOfIteratorHelperLoose.default)(this._children), _step; !(_step = _iterator()).done; ) {
+        var child = _step.value;
+        child.__makeNative(platformConfig), import_NativeAnimatedHelper.default.API.connectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
+      }
+    }
+    super.__makeNative(platformConfig);
+  }
+  __addChild(child) {
+    this._children.length === 0 && this.__attach(), this._children.push(child), this.__isNative && (child.__makeNative(this.__getPlatformConfig()), import_NativeAnimatedHelper.default.API.connectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag()));
+  }
+  __removeChild(child) {
+    var index = this._children.indexOf(child);
+    if (index === -1) {
+      console.warn("Trying to remove a child that doesn't exist");
+      return;
+    }
+    this.__isNative && child.__isNative && import_NativeAnimatedHelper.default.API.disconnectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag()), this._children.splice(index, 1), this._children.length === 0 && this.__detach();
+  }
+  __getChildren() {
+    return this._children;
+  }
+  __callListeners(value) {
+    if (super.__callListeners(value), !this.__isNative)
+      for (var _iterator2 = (0, import_createForOfIteratorHelperLoose.default)(this._children), _step2; !(_step2 = _iterator2()).done; ) {
+        var child = _step2.value;
+        child.__getValue && child.__callListeners(child.__getValue());
+      }
+  }
+}
+var AnimatedWithChildren_default = AnimatedWithChildren;
+//# sourceMappingURL=AnimatedWithChildren.js.map

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

@@ -0,0 +1,89 @@
+"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 useAnimatedProps_exports = {};
+__export(useAnimatedProps_exports, {
+  default: () => useAnimatedProps
+});
+module.exports = __toCommonJS(useAnimatedProps_exports);
+var import_createForOfIteratorHelperLoose = __toESM(require("@babel/runtime/helpers/createForOfIteratorHelperLoose")), import_react = require("react"), import_useRefEffect = __toESM(require("../useRefEffect")), import_AnimatedEvent = require("./AnimatedEvent"), import_NativeAnimatedHelper = __toESM(require("./NativeAnimatedHelper")), import_AnimatedProps = __toESM(require("./nodes/AnimatedProps"));
+const useLayoutEffect = typeof window > "u" ? import_react.useEffect : import_react.useLayoutEffect;
+function useAnimatedProps(props) {
+  var _useReducer = (0, import_react.useReducer)((count) => count + 1, 0), scheduleUpdate = _useReducer[1], onUpdateRef = (0, import_react.useRef)(null), node = (0, import_react.useMemo)(
+    () => new import_AnimatedProps.default(
+      props,
+      () => onUpdateRef.current == null ? void 0 : onUpdateRef.current()
+    ),
+    [props]
+  );
+  useAnimatedPropsLifecycle(node);
+  var refEffect = (0, import_react.useCallback)(
+    (instance) => {
+      node.setNativeView(instance), onUpdateRef.current = () => {
+        (0, import_react.startTransition)(() => {
+          scheduleUpdate();
+        });
+      };
+      var target = getEventTarget(instance), events = [];
+      for (var propName in props) {
+        var propValue = props[propName];
+        propValue instanceof import_AnimatedEvent.AnimatedEvent && propValue.__isNative && (propValue.__attach(target, propName), events.push([propName, propValue]));
+      }
+      return () => {
+        onUpdateRef.current = null;
+        for (var _iterator = (0, import_createForOfIteratorHelperLoose.default)(events), _step; !(_step = _iterator()).done; ) {
+          var _step$value = _step.value, _propName = _step$value[0], _propValue = _step$value[1];
+          _propValue.__detach(target, _propName);
+        }
+      };
+    },
+    [props, node]
+  ), callbackRef = (0, import_useRefEffect.default)(refEffect);
+  return [reduceAnimatedProps(node), callbackRef];
+}
+function reduceAnimatedProps(node) {
+  return {
+    ...node.__getValue(),
+    collapsable: !1
+  };
+}
+function useAnimatedPropsLifecycle(node) {
+  var prevNodeRef = (0, import_react.useRef)(null), isUnmountingRef = (0, import_react.useRef)(!1);
+  (0, import_react.useEffect)(() => {
+    import_NativeAnimatedHelper.default.API.flushQueue();
+  }), useLayoutEffect(() => (isUnmountingRef.current = !1, () => {
+    isUnmountingRef.current = !0;
+  }), []), useLayoutEffect(() => {
+    if (node.__attach(), prevNodeRef.current != null) {
+      var prevNode = prevNodeRef.current;
+      prevNode.__restoreDefaultValues(), prevNode.__detach(), prevNodeRef.current = null;
+    }
+    return () => {
+      isUnmountingRef.current ? node.__detach() : prevNodeRef.current = node;
+    };
+  }, [node]);
+}
+function getEventTarget(instance) {
+  return typeof instance == "object" && typeof instance?.getScrollableNode == "function" ? instance.getScrollableNode() : instance;
+}
+//# sourceMappingURL=useAnimatedProps.js.map

package/dist/cjs/vendor/react-native/FeatureFlags.js

@@ -0,0 +1,28 @@
+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 FeatureFlags_exports = {};
+__export(FeatureFlags_exports, {
+  ReactNativeFeatureFlags: () => ReactNativeFeatureFlags
+});
+module.exports = __toCommonJS(FeatureFlags_exports);
+const ReactNativeFeatureFlags = {
+  isLayoutAnimationEnabled: () => !0,
+  shouldEmitW3CPointerEvents: () => !1,
+  shouldPressibilityUseW3CPointerEventsForHover: () => !1,
+  animatedShouldDebounceQueueFlush: () => !1,
+  animatedShouldUseSingleOp: () => !1,
+  enableCppComponents: () => !1
+};
+//# sourceMappingURL=FeatureFlags.js.map

package/dist/cjs/vendor/react-native/NativeEventEmitter/RCTDeviceEventEmitter.js

@@ -0,0 +1,29 @@
+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 RCTDeviceEventEmitter_exports = {};
+__export(RCTDeviceEventEmitter_exports, {
+  default: () => RCTDeviceEventEmitter_default
+});
+module.exports = __toCommonJS(RCTDeviceEventEmitter_exports);
+var import_EventEmitter = __toESM(require("../emitter/EventEmitter")), RCTDeviceEventEmitter_default = new import_EventEmitter.default();
+//# sourceMappingURL=RCTDeviceEventEmitter.js.map

package/dist/cjs/vendor/react-native/NativeEventEmitter/index.js

@@ -0,0 +1,73 @@
+"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 NativeEventEmitter_exports = {};
+__export(NativeEventEmitter_exports, {
+  default: () => NativeEventEmitter
+});
+module.exports = __toCommonJS(NativeEventEmitter_exports);
+var import_react_native_web_internals = require("@tamagui/react-native-web-internals"), import_react_native_web_internals2 = require("@tamagui/react-native-web-internals"), import_RCTDeviceEventEmitter = __toESM(require("./RCTDeviceEventEmitter"));
+class NativeEventEmitter {
+  constructor(nativeModule) {
+    import_react_native_web_internals2.Platform.OS === "ios" && ((0, import_react_native_web_internals.invariant)(
+      nativeModule != null,
+      "`new NativeEventEmitter()` requires a non-null argument."
+    ), this._nativeModule = nativeModule);
+  }
+  addListener(eventType, listener, context) {
+    var _this$_nativeModule;
+    (_this$_nativeModule = this._nativeModule) == null || _this$_nativeModule.addListener(eventType);
+    var subscription = import_RCTDeviceEventEmitter.default.addListener(eventType, listener, context);
+    return {
+      remove: () => {
+        if (subscription != null) {
+          var _this$_nativeModule2;
+          (_this$_nativeModule2 = this._nativeModule) == null || _this$_nativeModule2.removeListeners(1), subscription.remove(), subscription = null;
+        }
+      }
+    };
+  }
+  /**
+   * @deprecated Use `remove` on the EventSubscription from `addListener`.
+   */
+  removeListener(eventType, listener) {
+    var _this$_nativeModule3;
+    (_this$_nativeModule3 = this._nativeModule) == null || _this$_nativeModule3.removeListeners(1), import_RCTDeviceEventEmitter.default.removeListener(eventType, listener);
+  }
+  emit(eventType) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++)
+      args[_key - 1] = arguments[_key];
+    import_RCTDeviceEventEmitter.default.emit(eventType, ...args);
+  }
+  removeAllListeners(eventType) {
+    var _this$_nativeModule4;
+    (0, import_react_native_web_internals.invariant)(
+      eventType != null,
+      "`NativeEventEmitter.removeAllListener()` requires a non-null argument."
+    ), (_this$_nativeModule4 = this._nativeModule) == null || _this$_nativeModule4.removeListeners(this.listenerCount(eventType)), import_RCTDeviceEventEmitter.default.removeAllListeners(eventType);
+  }
+  listenerCount(eventType) {
+    return import_RCTDeviceEventEmitter.default.listenerCount(eventType);
+  }
+}
+//# sourceMappingURL=index.js.map