@tamagui/core 1.64.4 → 1.65.1

package/dist/native.js

@@ -27,6 +27,681 @@ var __export = (target, all) => {
   mod
 )), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
 
+// ../react-native-use-responder-events/dist/cjs/utils.native.js
+var require_utils_native = __commonJS({
+  "../react-native-use-responder-events/dist/cjs/utils.native.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __hasOwnProp2 = Object.prototype.hasOwnProperty, __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: !0 });
+    }, __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from == "object" || typeof from == "function")
+        for (let key of __getOwnPropNames2(from))
+          !__hasOwnProp2.call(to, key) && key !== except && __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      return to;
+    }, __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: !0 }), mod), utils_exports = {};
+    __export2(utils_exports, {
+      canUseDOM: () => canUseDOM,
+      getBoundingClientRect: () => getBoundingClientRect2,
+      getLowestCommonAncestor: () => getLowestCommonAncestor,
+      getResponderPaths: () => getResponderPaths,
+      hasTargetTouches: () => hasTargetTouches,
+      hasValidSelection: () => hasValidSelection,
+      isPrimaryPointerDown: () => isPrimaryPointerDown,
+      isSelectionValid: () => isSelectionValid,
+      setResponderId: () => setResponderId
+    });
+    module2.exports = __toCommonJS2(utils_exports);
+    var keyName = "__reactResponderId", canUseDOM = !!(typeof window < "u" && window.document && window.document.createElement), getBoundingClientRect2 = (node) => {
+      if (node && node.nodeType === 1 && node.getBoundingClientRect)
+        return node.getBoundingClientRect();
+    };
+    function getEventPath(domEvent) {
+      var _a;
+      if (domEvent.type === "selectionchange") {
+        let target = (_a = window.getSelection()) == null ? void 0 : _a.anchorNode;
+        return composedPathFallback(target);
+      } else
+        return domEvent.composedPath != null ? domEvent.composedPath() : composedPathFallback(domEvent.target);
+    }
+    function composedPathFallback(target) {
+      let path = [];
+      for (; target != null && target !== document.body; )
+        path.push(target), target = target.parentNode;
+      return path;
+    }
+    function getResponderId(node) {
+      return node != null ? node[keyName] : null;
+    }
+    function setResponderId(node, id) {
+      node != null && (node[keyName] = id);
+    }
+    function getResponderPaths(domEvent) {
+      let idPath = [], nodePath = [], eventPath = getEventPath(domEvent);
+      for (let i = 0; i < eventPath.length; i++) {
+        let node = eventPath[i], id = getResponderId(node);
+        id != null && (idPath.push(id), nodePath.push(node));
+      }
+      return { idPath, nodePath };
+    }
+    function getLowestCommonAncestor(pathA, pathB) {
+      let pathALength = pathA.length, pathBLength = pathB.length;
+      if (
+        // If either path is empty
+        pathALength === 0 || pathBLength === 0 || // If the last elements aren't the same there can't be a common ancestor
+        // that is connected to the responder system
+        pathA[pathALength - 1] !== pathB[pathBLength - 1]
+      )
+        return null;
+      let itemA = pathA[0], indexA = 0, itemB = pathB[0], indexB = 0;
+      pathALength - pathBLength > 0 && (indexA = pathALength - pathBLength, itemA = pathA[indexA], pathALength = pathBLength), pathBLength - pathALength > 0 && (indexB = pathBLength - pathALength, itemB = pathB[indexB], pathBLength = pathALength);
+      let depth = pathALength;
+      for (; depth--; ) {
+        if (itemA === itemB)
+          return itemA;
+        itemA = pathA[indexA++], itemB = pathB[indexB++];
+      }
+      return null;
+    }
+    function hasTargetTouches(target, touches) {
+      if (!touches || touches.length === 0)
+        return !1;
+      for (let i = 0; i < touches.length; i++) {
+        let node = touches[i].target;
+        if (node != null && target.contains(node))
+          return !0;
+      }
+      return !1;
+    }
+    function hasValidSelection(domEvent) {
+      return domEvent.type === "selectionchange" ? isSelectionValid() : domEvent.type === "select";
+    }
+    function isPrimaryPointerDown(domEvent) {
+      let { altKey, button, buttons, ctrlKey, type } = domEvent, isTouch = type === "touchstart" || type === "touchmove", isPrimaryMouseDown = type === "mousedown" && (button === 0 || buttons === 1), isPrimaryMouseMove = type === "mousemove" && buttons === 1, noModifiers = altKey === !1 && ctrlKey === !1;
+      return !!(isTouch || isPrimaryMouseDown && noModifiers || isPrimaryMouseMove && noModifiers);
+    }
+    function isSelectionValid() {
+      let selection = window.getSelection();
+      if (!selection)
+        return !1;
+      let string = selection.toString(), anchorNode = selection.anchorNode, focusNode = selection.focusNode, isTextNode = anchorNode && anchorNode.nodeType === window.Node.TEXT_NODE || focusNode && focusNode.nodeType === window.Node.TEXT_NODE;
+      return string.length >= 1 && string !== `
+` && !!isTextNode;
+    }
+  }
+});
+
+// ../react-native-use-responder-events/dist/cjs/createResponderEvent.native.js
+var require_createResponderEvent_native = __commonJS({
+  "../react-native-use-responder-events/dist/cjs/createResponderEvent.native.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __hasOwnProp2 = Object.prototype.hasOwnProperty, __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: !0 });
+    }, __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from == "object" || typeof from == "function")
+        for (let key of __getOwnPropNames2(from))
+          !__hasOwnProp2.call(to, key) && key !== except && __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      return to;
+    }, __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: !0 }), mod), createResponderEvent_exports = {};
+    __export2(createResponderEvent_exports, {
+      default: () => createResponderEvent
+    });
+    module2.exports = __toCommonJS2(createResponderEvent_exports);
+    var import_utils = require_utils_native(), emptyFunction = () => {
+    }, emptyObject = {}, emptyArray = [];
+    function normalizeIdentifier(identifier) {
+      return identifier > 20 ? identifier % 20 : identifier;
+    }
+    function createResponderEvent(domEvent, responderTouchHistoryStore) {
+      let rect, propagationWasStopped = !1, changedTouches, touches, domEventChangedTouches = domEvent.changedTouches, domEventType = domEvent.type, metaKey = domEvent.metaKey === !0, shiftKey = domEvent.shiftKey === !0, force = (domEventChangedTouches == null ? void 0 : domEventChangedTouches[0].force) || 0, identifier = normalizeIdentifier((domEventChangedTouches == null ? void 0 : domEventChangedTouches[0].identifier) || 0), clientX = (domEventChangedTouches == null ? void 0 : domEventChangedTouches[0].clientX) || domEvent.clientX, clientY = (domEventChangedTouches == null ? void 0 : domEventChangedTouches[0].clientY) || domEvent.clientY, pageX = (domEventChangedTouches == null ? void 0 : domEventChangedTouches[0].pageX) || domEvent.pageX, pageY = (domEventChangedTouches == null ? void 0 : domEventChangedTouches[0].pageY) || domEvent.pageY, preventDefault = typeof domEvent.preventDefault == "function" ? domEvent.preventDefault.bind(domEvent) : emptyFunction, timestamp = domEvent.timeStamp;
+      function normalizeTouches(touches2) {
+        return Array.prototype.slice.call(touches2).map((touch) => ({
+          force: touch.force,
+          identifier: normalizeIdentifier(touch.identifier),
+          get locationX() {
+            return locationX(touch.clientX);
+          },
+          get locationY() {
+            return locationY(touch.clientY);
+          },
+          pageX: touch.pageX,
+          pageY: touch.pageY,
+          target: touch.target,
+          timestamp
+        }));
+      }
+      if (domEventChangedTouches != null)
+        changedTouches = normalizeTouches(domEventChangedTouches), touches = normalizeTouches(domEvent.touches);
+      else {
+        let emulatedTouches = [
+          {
+            force,
+            identifier,
+            get locationX() {
+              return locationX(clientX);
+            },
+            get locationY() {
+              return locationY(clientY);
+            },
+            pageX,
+            pageY,
+            target: domEvent.target,
+            timestamp
+          }
+        ];
+        changedTouches = emulatedTouches, touches = domEventType === "mouseup" || domEventType === "dragstart" ? emptyArray : emulatedTouches;
+      }
+      let responderEvent = {
+        bubbles: !0,
+        cancelable: !0,
+        // `currentTarget` is set before dispatch
+        currentTarget: null,
+        defaultPrevented: domEvent.defaultPrevented,
+        dispatchConfig: emptyObject,
+        eventPhase: domEvent.eventPhase,
+        isDefaultPrevented() {
+          return domEvent.defaultPrevented;
+        },
+        isPropagationStopped() {
+          return propagationWasStopped;
+        },
+        isTrusted: domEvent.isTrusted,
+        nativeEvent: {
+          altKey: !1,
+          ctrlKey: !1,
+          metaKey,
+          shiftKey,
+          changedTouches,
+          force,
+          identifier,
+          get locationX() {
+            return locationX(clientX);
+          },
+          get locationY() {
+            return locationY(clientY);
+          },
+          pageX,
+          pageY,
+          target: domEvent.target,
+          timestamp,
+          touches,
+          type: domEventType
+        },
+        persist: emptyFunction,
+        preventDefault,
+        stopPropagation() {
+          propagationWasStopped = !0;
+        },
+        target: domEvent.target,
+        timeStamp: timestamp,
+        touchHistory: responderTouchHistoryStore.touchHistory
+      };
+      function locationX(x) {
+        if (rect = rect || (0, import_utils.getBoundingClientRect)(responderEvent.currentTarget), rect)
+          return x - rect.left;
+      }
+      function locationY(y) {
+        if (rect = rect || (0, import_utils.getBoundingClientRect)(responderEvent.currentTarget), rect)
+          return y - rect.top;
+      }
+      return responderEvent;
+    }
+  }
+});
+
+// ../react-native-use-responder-events/dist/cjs/types.native.js
+var require_types_native = __commonJS({
+  "../react-native-use-responder-events/dist/cjs/types.native.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __hasOwnProp2 = Object.prototype.hasOwnProperty, __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: !0 });
+    }, __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from == "object" || typeof from == "function")
+        for (let key of __getOwnPropNames2(from))
+          !__hasOwnProp2.call(to, key) && key !== except && __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      return to;
+    }, __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: !0 }), mod), types_exports = {};
+    __export2(types_exports, {
+      BLUR: () => BLUR,
+      CONTEXT_MENU: () => CONTEXT_MENU,
+      FOCUS_OUT: () => FOCUS_OUT,
+      MOUSE_CANCEL: () => MOUSE_CANCEL,
+      MOUSE_DOWN: () => MOUSE_DOWN,
+      MOUSE_MOVE: () => MOUSE_MOVE,
+      MOUSE_UP: () => MOUSE_UP,
+      SCROLL: () => SCROLL,
+      SELECT: () => SELECT,
+      SELECTION_CHANGE: () => SELECTION_CHANGE,
+      TOUCH_CANCEL: () => TOUCH_CANCEL,
+      TOUCH_END: () => TOUCH_END,
+      TOUCH_MOVE: () => TOUCH_MOVE,
+      TOUCH_START: () => TOUCH_START,
+      isCancelish: () => isCancelish,
+      isEndish: () => isEndish,
+      isMoveish: () => isMoveish,
+      isScroll: () => isScroll,
+      isSelectionChange: () => isSelectionChange,
+      isStartish: () => isStartish
+    });
+    module2.exports = __toCommonJS2(types_exports);
+    var BLUR = "blur", CONTEXT_MENU = "contextmenu", FOCUS_OUT = "focusout", MOUSE_DOWN = "mousedown", MOUSE_MOVE = "mousemove", MOUSE_UP = "mouseup", MOUSE_CANCEL = "dragstart", TOUCH_START = "touchstart", TOUCH_MOVE = "touchmove", TOUCH_END = "touchend", TOUCH_CANCEL = "touchcancel", SCROLL = "scroll", SELECT = "select", SELECTION_CHANGE = "selectionchange";
+    function isStartish(eventType) {
+      return eventType === TOUCH_START || eventType === MOUSE_DOWN;
+    }
+    function isMoveish(eventType) {
+      return eventType === TOUCH_MOVE || eventType === MOUSE_MOVE;
+    }
+    function isEndish(eventType) {
+      return eventType === TOUCH_END || eventType === MOUSE_UP || isCancelish(eventType);
+    }
+    function isCancelish(eventType) {
+      return eventType === TOUCH_CANCEL || eventType === MOUSE_CANCEL;
+    }
+    function isScroll(eventType) {
+      return eventType === SCROLL;
+    }
+    function isSelectionChange(eventType) {
+      return eventType === SELECT || eventType === SELECTION_CHANGE;
+    }
+  }
+});
+
+// ../react-native-use-responder-events/dist/cjs/ResponderTouchHistoryStore.native.js
+var require_ResponderTouchHistoryStore_native = __commonJS({
+  "../react-native-use-responder-events/dist/cjs/ResponderTouchHistoryStore.native.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __hasOwnProp2 = Object.prototype.hasOwnProperty, __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: !0 });
+    }, __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from == "object" || typeof from == "function")
+        for (let key of __getOwnPropNames2(from))
+          !__hasOwnProp2.call(to, key) && key !== except && __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      return to;
+    }, __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: !0 }), mod), ResponderTouchHistoryStore_exports = {};
+    __export2(ResponderTouchHistoryStore_exports, {
+      ResponderTouchHistoryStore: () => ResponderTouchHistoryStore
+    });
+    module2.exports = __toCommonJS2(ResponderTouchHistoryStore_exports);
+    var import_types = require_types_native(), MAX_TOUCH_BANK = 20;
+    function timestampForTouch(touch) {
+      return touch.timeStamp || touch.timestamp;
+    }
+    function createTouchRecord(touch) {
+      return {
+        touchActive: !0,
+        startPageX: touch.pageX,
+        startPageY: touch.pageY,
+        startTimeStamp: timestampForTouch(touch),
+        currentPageX: touch.pageX,
+        currentPageY: touch.pageY,
+        currentTimeStamp: timestampForTouch(touch),
+        previousPageX: touch.pageX,
+        previousPageY: touch.pageY,
+        previousTimeStamp: timestampForTouch(touch)
+      };
+    }
+    function resetTouchRecord(touchRecord, touch) {
+      touchRecord.touchActive = !0, touchRecord.startPageX = touch.pageX, touchRecord.startPageY = touch.pageY, touchRecord.startTimeStamp = timestampForTouch(touch), touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchRecord.previousPageX = touch.pageX, touchRecord.previousPageY = touch.pageY, touchRecord.previousTimeStamp = timestampForTouch(touch);
+    }
+    function getTouchIdentifier({ identifier }) {
+      return identifier == null && console.error("Touch object is missing identifier."), process.env.NODE_ENV === "development" && identifier > MAX_TOUCH_BANK && console.error(
+        "Touch identifier %s is greater than maximum supported %s which causes performance issues backfilling array locations for all of the indices.",
+        identifier,
+        MAX_TOUCH_BANK
+      ), identifier;
+    }
+    function recordTouchStart(touch, touchHistory) {
+      let identifier = getTouchIdentifier(touch), touchRecord = touchHistory.touchBank[identifier];
+      touchRecord ? resetTouchRecord(touchRecord, touch) : touchHistory.touchBank[identifier] = createTouchRecord(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+    }
+    function recordTouchMove(touch, touchHistory) {
+      let touchRecord = touchHistory.touchBank[getTouchIdentifier(touch)];
+      touchRecord ? (touchRecord.touchActive = !0, touchRecord.previousPageX = touchRecord.currentPageX, touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.warn(
+        `Cannot record touch move without a touch start.
+`,
+        `Touch Move: ${printTouch(touch)}
+`,
+        `Touch Bank: ${printTouchBank(touchHistory)}`
+      );
+    }
+    function recordTouchEnd(touch, touchHistory) {
+      let touchRecord = touchHistory.touchBank[getTouchIdentifier(touch)];
+      touchRecord ? (touchRecord.touchActive = !1, touchRecord.previousPageX = touchRecord.currentPageX, touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.warn(
+        `Cannot record touch end without a touch start.
+`,
+        `Touch End: ${printTouch(touch)}
+`,
+        `Touch Bank: ${printTouchBank(touchHistory)}`
+      );
+    }
+    function printTouch(touch) {
+      return JSON.stringify({
+        identifier: touch.identifier,
+        pageX: touch.pageX,
+        pageY: touch.pageY,
+        timestamp: timestampForTouch(touch)
+      });
+    }
+    function printTouchBank(touchHistory) {
+      let { touchBank } = touchHistory, printed = JSON.stringify(touchBank.slice(0, MAX_TOUCH_BANK));
+      return touchBank.length > MAX_TOUCH_BANK && (printed += ` (original size: ${touchBank.length})`), printed;
+    }
+    var ResponderTouchHistoryStore = class {
+      constructor() {
+        this._touchHistory = {
+          touchBank: [],
+          //Array<TouchRecord>
+          numberActiveTouches: 0,
+          // If there is only one active touch, we remember its location. This prevents
+          // us having to loop through all of the touches all the time in the most
+          // common case.
+          indexOfSingleActiveTouch: -1,
+          mostRecentTimeStamp: 0
+        };
+      }
+      recordTouchTrack(topLevelType, nativeEvent) {
+        let touchHistory = this._touchHistory;
+        if ((0, import_types.isMoveish)(topLevelType))
+          nativeEvent.changedTouches.forEach((touch) => recordTouchMove(touch, touchHistory));
+        else if ((0, import_types.isStartish)(topLevelType))
+          nativeEvent.changedTouches.forEach((touch) => recordTouchStart(touch, touchHistory)), touchHistory.numberActiveTouches = nativeEvent.touches.length, touchHistory.numberActiveTouches === 1 && (touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier);
+        else if ((0, import_types.isEndish)(topLevelType) && (nativeEvent.changedTouches.forEach((touch) => recordTouchEnd(touch, touchHistory)), touchHistory.numberActiveTouches = nativeEvent.touches.length, touchHistory.numberActiveTouches === 1)) {
+          let { touchBank } = touchHistory;
+          for (let i = 0; i < touchBank.length; i++) {
+            let touchTrackToCheck = touchBank[i];
+            if (touchTrackToCheck != null && touchTrackToCheck.touchActive) {
+              touchHistory.indexOfSingleActiveTouch = i;
+              break;
+            }
+          }
+          if (process.env.NODE_ENV === "development") {
+            let activeRecord = touchBank[touchHistory.indexOfSingleActiveTouch];
+            activeRecord != null && activeRecord.touchActive || console.error("Cannot find single active touch.");
+          }
+        }
+      }
+      get touchHistory() {
+        return this._touchHistory;
+      }
+    };
+  }
+});
+
+// ../react-native-use-responder-events/dist/cjs/ResponderSystem.native.js
+var require_ResponderSystem_native = __commonJS({
+  "../react-native-use-responder-events/dist/cjs/ResponderSystem.native.js"(exports, module2) {
+    "use strict";
+    var __create2 = Object.create, __defProp2 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __getProtoOf2 = Object.getPrototypeOf, __hasOwnProp2 = Object.prototype.hasOwnProperty, __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: !0 });
+    }, __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from == "object" || typeof from == "function")
+        for (let key of __getOwnPropNames2(from))
+          !__hasOwnProp2.call(to, key) && key !== except && __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      return to;
+    }, __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // 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 ? __defProp2(target, "default", { value: mod, enumerable: !0 }) : target,
+      mod
+    )), __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: !0 }), mod), ResponderSystem_exports = {};
+    __export2(ResponderSystem_exports, {
+      addNode: () => addNode,
+      attachListeners: () => attachListeners,
+      getResponderNode: () => getResponderNode,
+      removeNode: () => removeNode,
+      terminateResponder: () => terminateResponder
+    });
+    module2.exports = __toCommonJS2(ResponderSystem_exports);
+    var import_createResponderEvent = __toESM2(require_createResponderEvent_native()), import_ResponderTouchHistoryStore = require_ResponderTouchHistoryStore_native(), import_types = require_types_native(), import_utils = require_utils_native(), import_utils2 = require_utils_native(), emptyObject = {}, startRegistration = [
+      "onStartShouldSetResponderCapture",
+      "onStartShouldSetResponder",
+      { bubbles: !0 }
+    ], moveRegistration = [
+      "onMoveShouldSetResponderCapture",
+      "onMoveShouldSetResponder",
+      { bubbles: !0 }
+    ], scrollRegistration = [
+      "onScrollShouldSetResponderCapture",
+      "onScrollShouldSetResponder",
+      { bubbles: !1 }
+    ], shouldSetResponderEvents = {
+      touchstart: startRegistration,
+      mousedown: startRegistration,
+      touchmove: moveRegistration,
+      mousemove: moveRegistration,
+      scroll: scrollRegistration
+    }, emptyResponder = { id: null, idPath: null, node: null }, responderListenersMap = /* @__PURE__ */ new Map(), isEmulatingMouseEvents = !1, trackedTouchCount = 0, currentResponder = {
+      id: null,
+      node: null,
+      idPath: null
+    }, responderTouchHistoryStore = new import_ResponderTouchHistoryStore.ResponderTouchHistoryStore();
+    function changeCurrentResponder(responder) {
+      currentResponder = responder;
+    }
+    function getResponderConfig(id) {
+      return responderListenersMap.get(id) ?? emptyObject;
+    }
+    function eventListener(domEvent) {
+      let eventType = domEvent.type, eventTarget = domEvent.target;
+      if (eventType === "touchstart" && (isEmulatingMouseEvents = !0), (eventType === "touchmove" || trackedTouchCount > 1) && (isEmulatingMouseEvents = !1), // Ignore browser emulated mouse events
+      eventType === "mousedown" && isEmulatingMouseEvents || eventType === "mousemove" && isEmulatingMouseEvents || // Ignore mousemove if a mousedown didn't occur first
+      eventType === "mousemove" && trackedTouchCount < 1)
+        return;
+      if (isEmulatingMouseEvents && eventType === "mouseup") {
+        trackedTouchCount === 0 && (isEmulatingMouseEvents = !1);
+        return;
+      }
+      let isStartEvent = (0, import_types.isStartish)(eventType) && (0, import_utils2.isPrimaryPointerDown)(domEvent), isMoveEvent = (0, import_types.isMoveish)(eventType), isEndEvent = (0, import_types.isEndish)(eventType), isScrollEvent = (0, import_types.isScroll)(eventType), isSelectionChangeEvent = (0, import_types.isSelectionChange)(eventType), responderEvent = (0, import_createResponderEvent.default)(domEvent, responderTouchHistoryStore);
+      (isStartEvent || isMoveEvent || isEndEvent) && (domEvent.touches ? trackedTouchCount = domEvent.touches.length : isStartEvent ? trackedTouchCount = 1 : isEndEvent && (trackedTouchCount = 0), responderTouchHistoryStore.recordTouchTrack(
+        eventType,
+        responderEvent.nativeEvent
+      ));
+      let eventPaths = (0, import_utils2.getResponderPaths)(domEvent), wasNegotiated = !1, wantsResponder;
+      if (isStartEvent || isMoveEvent || isScrollEvent && trackedTouchCount > 0) {
+        let currentResponderIdPath = currentResponder.idPath, eventIdPath = eventPaths.idPath;
+        if (currentResponderIdPath != null && eventIdPath != null) {
+          let lowestCommonAncestor = (0, import_utils2.getLowestCommonAncestor)(
+            currentResponderIdPath,
+            eventIdPath
+          );
+          if (lowestCommonAncestor != null) {
+            let index = eventIdPath.indexOf(lowestCommonAncestor) + (lowestCommonAncestor === currentResponder.id ? 1 : 0);
+            eventPaths = {
+              idPath: eventIdPath.slice(index),
+              nodePath: eventPaths.nodePath.slice(index)
+            };
+          } else
+            eventPaths = null;
+        }
+        eventPaths != null && (wantsResponder = findWantsResponder(eventPaths, domEvent, responderEvent), wantsResponder != null && (attemptTransfer(responderEvent, wantsResponder), wasNegotiated = !0));
+      }
+      if (currentResponder.id != null && currentResponder.node != null) {
+        let { id, node } = currentResponder, {
+          onResponderStart,
+          onResponderMove,
+          onResponderEnd,
+          onResponderRelease,
+          onResponderTerminate,
+          onResponderTerminationRequest
+        } = getResponderConfig(id);
+        if (responderEvent.bubbles = !1, responderEvent.cancelable = !1, responderEvent.currentTarget = node, isStartEvent)
+          onResponderStart != null && (responderEvent.dispatchConfig.registrationName = "onResponderStart", onResponderStart(responderEvent));
+        else if (isMoveEvent)
+          onResponderMove != null && (responderEvent.dispatchConfig.registrationName = "onResponderMove", onResponderMove(responderEvent));
+        else {
+          let isTerminateEvent = (0, import_types.isCancelish)(eventType) || // native context menu
+          eventType === "contextmenu" || // window blur
+          eventType === "blur" && eventTarget === window || // responder (or ancestors) blur
+          eventType === "blur" && eventTarget.contains(node) && domEvent.relatedTarget !== node || // native scroll without using a pointer
+          isScrollEvent && trackedTouchCount === 0 || // native scroll on node that is parent of the responder (allow siblings to scroll)
+          isScrollEvent && eventTarget.contains(node) && eventTarget !== node || // native select/selectionchange on node
+          isSelectionChangeEvent && (0, import_utils2.hasValidSelection)(domEvent), isReleaseEvent = isEndEvent && !isTerminateEvent && !(0, import_utils2.hasTargetTouches)(node, domEvent.touches);
+          if (isEndEvent && onResponderEnd != null && (responderEvent.dispatchConfig.registrationName = "onResponderEnd", onResponderEnd(responderEvent)), isReleaseEvent && (onResponderRelease != null && (responderEvent.dispatchConfig.registrationName = "onResponderRelease", onResponderRelease(responderEvent)), changeCurrentResponder(emptyResponder)), isTerminateEvent) {
+            let shouldTerminate = !0;
+            (eventType === "contextmenu" || eventType === "scroll" || eventType === "selectionchange") && (wasNegotiated ? shouldTerminate = !1 : onResponderTerminationRequest != null && (responderEvent.dispatchConfig.registrationName = "onResponderTerminationRequest", onResponderTerminationRequest(responderEvent) === !1 && (shouldTerminate = !1))), shouldTerminate && (onResponderTerminate != null && (responderEvent.dispatchConfig.registrationName = "onResponderTerminate", onResponderTerminate(responderEvent)), changeCurrentResponder(emptyResponder), isEmulatingMouseEvents = !1, trackedTouchCount = 0);
+          }
+        }
+      }
+    }
+    function findWantsResponder(eventPaths, domEvent, responderEvent) {
+      let shouldSetCallbacks = shouldSetResponderEvents[domEvent.type];
+      if (shouldSetCallbacks != null) {
+        let { idPath, nodePath } = eventPaths, shouldSetCallbackCaptureName = shouldSetCallbacks[0], shouldSetCallbackBubbleName = shouldSetCallbacks[1], { bubbles } = shouldSetCallbacks[2], check = function(id, node, callbackName) {
+          let shouldSetCallback = getResponderConfig(id)[callbackName];
+          if (shouldSetCallback != null && (responderEvent.currentTarget = node, shouldSetCallback(responderEvent) === !0)) {
+            let prunedIdPath = idPath.slice(idPath.indexOf(id));
+            return { id, node, idPath: prunedIdPath };
+          }
+        };
+        for (let i = idPath.length - 1; i >= 0; i--) {
+          let id = idPath[i], node = nodePath[i], result = check(id, node, shouldSetCallbackCaptureName);
+          if (result != null)
+            return result;
+          if (responderEvent.isPropagationStopped() === !0)
+            return;
+        }
+        if (bubbles)
+          for (let i = 0; i < idPath.length; i++) {
+            let id = idPath[i], node = nodePath[i], result = check(id, node, shouldSetCallbackBubbleName);
+            if (result != null)
+              return result;
+            if (responderEvent.isPropagationStopped() === !0)
+              return;
+          }
+        else {
+          let id = idPath[0], node = nodePath[0];
+          if (domEvent.target === node)
+            return check(id, node, shouldSetCallbackBubbleName);
+        }
+      }
+    }
+    function attemptTransfer(responderEvent, wantsResponder) {
+      let { id: currentId, node: currentNode } = currentResponder, { id, node } = wantsResponder, { onResponderGrant, onResponderReject } = getResponderConfig(id);
+      if (responderEvent.bubbles = !1, responderEvent.cancelable = !1, responderEvent.currentTarget = node, currentId == null)
+        onResponderGrant != null && (responderEvent.currentTarget = node, responderEvent.dispatchConfig.registrationName = "onResponderGrant", onResponderGrant(responderEvent)), changeCurrentResponder(wantsResponder);
+      else {
+        let { onResponderTerminate, onResponderTerminationRequest } = getResponderConfig(currentId), allowTransfer = !0;
+        onResponderTerminationRequest != null && (responderEvent.currentTarget = currentNode, responderEvent.dispatchConfig.registrationName = "onResponderTerminationRequest", onResponderTerminationRequest(responderEvent) === !1 && (allowTransfer = !1)), allowTransfer ? (onResponderTerminate != null && (responderEvent.currentTarget = currentNode, responderEvent.dispatchConfig.registrationName = "onResponderTerminate", onResponderTerminate(responderEvent)), onResponderGrant != null && (responderEvent.currentTarget = node, responderEvent.dispatchConfig.registrationName = "onResponderGrant", onResponderGrant(responderEvent)), changeCurrentResponder(wantsResponder)) : onResponderReject != null && (responderEvent.currentTarget = node, responderEvent.dispatchConfig.registrationName = "onResponderReject", onResponderReject(responderEvent));
+      }
+    }
+    var documentEventsCapturePhase = ["blur", "scroll"], documentEventsBubblePhase = [
+      // mouse
+      "mousedown",
+      "mousemove",
+      "mouseup",
+      "dragstart",
+      // touch
+      "touchstart",
+      "touchmove",
+      "touchend",
+      "touchcancel",
+      // other
+      "contextmenu",
+      "select",
+      "selectionchange"
+    ], isTamaguiResponderActive = Symbol();
+    function attachListeners() {
+      import_utils.canUseDOM && !window[isTamaguiResponderActive] && (window.addEventListener("blur", eventListener), documentEventsBubblePhase.forEach((eventType) => {
+        document.addEventListener(eventType, eventListener);
+      }), documentEventsCapturePhase.forEach((eventType) => {
+        document.addEventListener(eventType, eventListener, !0);
+      }), window[isTamaguiResponderActive] = !0);
+    }
+    function addNode(id, node, config) {
+      (0, import_utils2.setResponderId)(node, id), responderListenersMap.set(id, config);
+    }
+    function removeNode(id) {
+      currentResponder.id === id && terminateResponder(), responderListenersMap.has(id) && responderListenersMap.delete(id);
+    }
+    function terminateResponder() {
+      let { id, node } = currentResponder;
+      if (id != null && node != null) {
+        let { onResponderTerminate } = getResponderConfig(id);
+        if (onResponderTerminate != null) {
+          let event = (0, import_createResponderEvent.default)({}, responderTouchHistoryStore);
+          event.currentTarget = node, onResponderTerminate(event);
+        }
+        changeCurrentResponder(emptyResponder);
+      }
+      isEmulatingMouseEvents = !1, trackedTouchCount = 0;
+    }
+    function getResponderNode() {
+      return currentResponder.node;
+    }
+  }
+});
+
+// ../react-native-use-responder-events/dist/cjs/useResponderEvents.native.js
+var require_useResponderEvents_native = __commonJS({
+  "../react-native-use-responder-events/dist/cjs/useResponderEvents.native.js"(exports, module2) {
+    "use strict";
+    var __create2 = Object.create, __defProp2 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __getProtoOf2 = Object.getPrototypeOf, __hasOwnProp2 = Object.prototype.hasOwnProperty, __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: !0 });
+    }, __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from == "object" || typeof from == "function")
+        for (let key of __getOwnPropNames2(from))
+          !__hasOwnProp2.call(to, key) && key !== except && __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      return to;
+    }, __reExport2 = (target, mod, secondTarget) => (__copyProps2(target, mod, "default"), secondTarget && __copyProps2(secondTarget, mod, "default")), __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // 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 ? __defProp2(target, "default", { value: mod, enumerable: !0 }) : target,
+      mod
+    )), __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: !0 }), mod), useResponderEvents_exports = {};
+    __export2(useResponderEvents_exports, {
+      useResponderEvents: () => useResponderEvents2
+    });
+    module2.exports = __toCommonJS2(useResponderEvents_exports);
+    var React = __toESM2(require("react")), ResponderSystem = __toESM2(require_ResponderSystem_native());
+    __reExport2(useResponderEvents_exports, require_utils_native(), module2.exports);
+    var emptyObject = {};
+    function useResponderEvents2(hostRef, config = emptyObject) {
+      let id = React.useId(), isAttachedRef = React.useRef(!1);
+      React.useEffect(() => (ResponderSystem.attachListeners(), () => {
+        ResponderSystem.removeNode(id);
+      }), [id]), React.useEffect(() => {
+        let {
+          onMoveShouldSetResponder,
+          onMoveShouldSetResponderCapture,
+          onScrollShouldSetResponder,
+          onScrollShouldSetResponderCapture,
+          onSelectionChangeShouldSetResponder,
+          onSelectionChangeShouldSetResponderCapture,
+          onStartShouldSetResponder,
+          onStartShouldSetResponderCapture
+        } = config, requiresResponderSystem = onMoveShouldSetResponder != null || onMoveShouldSetResponderCapture != null || onScrollShouldSetResponder != null || onScrollShouldSetResponderCapture != null || onSelectionChangeShouldSetResponder != null || onSelectionChangeShouldSetResponderCapture != null || onStartShouldSetResponder != null || onStartShouldSetResponderCapture != null, node = hostRef.current;
+        requiresResponderSystem ? (ResponderSystem.addNode(id, node, config), isAttachedRef.current = !0) : isAttachedRef.current && (ResponderSystem.removeNode(id), isAttachedRef.current = !1);
+      }, [config, hostRef, id]), process.env.NODE_ENV === "development" && (React.useDebugValue({
+        isResponder: hostRef.current === ResponderSystem.getResponderNode()
+      }), React.useDebugValue(config));
+    }
+  }
+});
+
+// ../react-native-use-responder-events/dist/cjs/index.native.js
+var require_index_native = __commonJS({
+  "../react-native-use-responder-events/dist/cjs/index.native.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __hasOwnProp2 = Object.prototype.hasOwnProperty, __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from == "object" || typeof from == "function")
+        for (let key of __getOwnPropNames2(from))
+          !__hasOwnProp2.call(to, key) && key !== except && __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      return to;
+    }, __reExport2 = (target, mod, secondTarget) => (__copyProps2(target, mod, "default"), secondTarget && __copyProps2(secondTarget, mod, "default")), __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: !0 }), mod), src_exports2 = {};
+    module2.exports = __toCommonJS2(src_exports2);
+    __reExport2(src_exports2, require_useResponderEvents_native(), module2.exports);
+  }
+});
+
 // ../helpers/dist/cjs/clamp.native.js
 var require_clamp_native = __commonJS({
   "../helpers/dist/cjs/clamp.native.js"(exports, module2) {
@@ -143,7 +818,7 @@ var require_concatClassName_native = __commonJS({
 });
 
 // ../constants/dist/cjs/index.native.js
-var require_index_native = __commonJS({
+var require_index_native2 = __commonJS({
   "../constants/dist/cjs/index.native.js"(exports, module2) {
     "use strict";
     var __defProp2 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __hasOwnProp2 = Object.prototype.hasOwnProperty, __export2 = (target, all) => {
@@ -200,7 +875,7 @@ var require_validStyleProps_native = __commonJS({
       validStylesOnBaseProps: () => validStylesOnBaseProps
     });
     module2.exports = __toCommonJS2(validStyleProps_exports);
-    var import_constants2 = require_index_native(), placeHolderTextColors = {
+    var import_constants2 = require_index_native2(), placeHolderTextColors = {
       placeholderTextColor: !0
     }, validStylesOnBaseProps = {
       ...placeHolderTextColors
@@ -386,7 +1061,7 @@ var require_validStyleProps_native = __commonJS({
 });
 
 // ../helpers/dist/cjs/types.native.js
-var require_types_native = __commonJS({
+var require_types_native2 = __commonJS({
   "../helpers/dist/cjs/types.native.js"(exports, module2) {
     "use strict";
     var __defProp2 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __hasOwnProp2 = Object.prototype.hasOwnProperty, __copyProps2 = (to, from, except, desc) => {
@@ -400,7 +1075,7 @@ var require_types_native = __commonJS({
 });
 
 // ../simple-hash/dist/cjs/index.native.js
-var require_index_native2 = __commonJS({
+var require_index_native3 = __commonJS({
   "../simple-hash/dist/cjs/index.native.js"(exports, module2) {
     "use strict";
     var __defProp2 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __hasOwnProp2 = Object.prototype.hasOwnProperty, __export2 = (target, all) => {
@@ -445,7 +1120,7 @@ var require_index_native2 = __commonJS({
 });
 
 // ../helpers/dist/cjs/index.native.js
-var require_index_native3 = __commonJS({
+var require_index_native4 = __commonJS({
   "../helpers/dist/cjs/index.native.js"(exports, module2) {
     "use strict";
     var __defProp2 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __hasOwnProp2 = Object.prototype.hasOwnProperty, __copyProps2 = (to, from, except, desc) => {
@@ -459,8 +1134,8 @@ var require_index_native3 = __commonJS({
     __reExport2(src_exports2, require_composeEventHandlers_native(), module2.exports);
     __reExport2(src_exports2, require_concatClassName_native(), module2.exports);
     __reExport2(src_exports2, require_validStyleProps_native(), module2.exports);
-    __reExport2(src_exports2, require_types_native(), module2.exports);
-    __reExport2(src_exports2, require_index_native2(), module2.exports);
+    __reExport2(src_exports2, require_types_native2(), module2.exports);
+    __reExport2(src_exports2, require_index_native3(), module2.exports);
   }
 });
 
@@ -494,16 +1169,16 @@ var require_config_native = __commonJS({
       useTokens: () => useTokens
     });
     module2.exports = __toCommonJS2(config_exports);
-    var import_constants2 = require_index_native(), conf, setConfig = (next) => {
+    var import_constants2 = require_index_native2(), conf, setConfig = (next) => {
       conf = next, configListeners.forEach((cb) => cb(next));
     }, setConfigFont = (name, font, fontParsed) => {
-      if (!conf)
+      if (process.env.NODE_ENV === "development" && !conf)
         throw new Error("Haven't called createTamagui yet");
       conf.fonts[name] = font, conf.fontsParsed[`$${name}`] = fontParsed;
     }, getConfig2 = () => {
       if (!conf)
         throw new Error(
-          "Missing tamagui config, you either have a duplicate config, or haven't set it up. Be sure createTamagui is called before rendering. Also, make sure all of your tamagui dependencies are on the same version (`tamagui`, `@tamagui/package-name`, etc.)"
+          process.env.NODE_ENV !== "production" ? "Missing tamagui config, you either have a duplicate config, or haven't set it up. Be sure createTamagui is called before rendering. Also, make sure all of your tamagui dependencies are on the same version (`tamagui`, `@tamagui/package-name`, etc.)" : "Err0"
         );
       return conf;
     }, tokensMerged;
@@ -513,7 +1188,7 @@ var require_config_native = __commonJS({
     var getTokens2 = ({
       prefixed
     } = {}) => {
-      if (!conf)
+      if (process.env.NODE_ENV === "development" && !conf)
         throw new Error("Haven't called createTamagui yet");
       let { tokens, tokensParsed } = conf;
       return prefixed === !1 ? tokens : prefixed === !0 ? tokensParsed : tokensMerged;
@@ -566,7 +1241,7 @@ var require_createVariable_native = __commonJS({
       variableToString: () => variableToString
     });
     module2.exports = __toCommonJS2(createVariable_exports);
-    var import_constants2 = require_index_native(), import_helpers = require_index_native3(), import_config = require_config_native(), IS_VAR = "isVar", createVariable = (props, skipHash = !1) => {
+    var import_constants2 = require_index_native2(), import_helpers = require_index_native4(), import_config = require_config_native(), IS_VAR = "isVar", createVariable = (props, skipHash = !1) => {
       if (!skipHash && isVariable(props))
         return props;
       let { key, name, val } = props;
@@ -601,7 +1276,7 @@ var require_createVariable_native = __commonJS({
       return isVariable(v) ? v.variable : v;
     }
     var createCSSVariable = (nameProp, includeVar = !0) => {
-      if (!nameProp || typeof nameProp != "string")
+      if (process.env.NODE_ENV === "development" && (!nameProp || typeof nameProp != "string"))
         throw new Error(`createCSSVariable expected string, got: ${nameProp}`);
       let name = (0, import_helpers.simpleHash)(nameProp, 60);
       return includeVar ? `var(--${name})` : name;
@@ -634,11 +1309,11 @@ var require_insertStyleRule_native = __commonJS({
       updateRules: () => updateRules
     });
     module2.exports = __toCommonJS2(insertStyleRule_exports);
-    var import_constants2 = require_index_native(), import_createVariable = require_createVariable_native(), scannedCache = /* @__PURE__ */ new WeakMap(), totalSelectorsInserted = /* @__PURE__ */ new Map(), allSelectors = {}, allRules = {}, insertedTransforms = {}, getAllSelectors = () => allSelectors, getAllRules = () => Object.values(allRules), getAllTransforms = () => insertedTransforms;
+    var import_constants2 = require_index_native2(), import_createVariable = require_createVariable_native(), scannedCache = /* @__PURE__ */ new WeakMap(), totalSelectorsInserted = /* @__PURE__ */ new Map(), allSelectors = {}, allRules = {}, insertedTransforms = {}, getAllSelectors = () => allSelectors, getAllRules = () => Object.values(allRules), getAllTransforms = () => insertedTransforms;
     function addTransform(identifier, css, rule) {
       let s = css.indexOf("transform:");
       if (s === -1) {
-        console.error(`\u274C Invalid transform, likely used deg/% improperly ${identifier}`);
+        process.env.NODE_ENV === "development" && console.error(`\u274C Invalid transform, likely used deg/% improperly ${identifier}`);
         return;
       }
       let startI = s + 10, endI = css.indexOf(";"), value = css.slice(startI, endI);
@@ -658,7 +1333,7 @@ var require_insertStyleRule_native = __commonJS({
     }
     var lastScannedSheets = null;
     function scanAllSheets(collectThemes = !1, tokens) {
-      if (!import_constants2.isClient)
+      if (process.env.NODE_ENV === "test" || !import_constants2.isClient)
         return;
       let themes, sheets = document.styleSheets || [], prev = lastScannedSheets, current = new Set(sheets);
       if (document.styleSheets) {
@@ -790,13 +1465,16 @@ var require_insertStyleRule_native = __commonJS({
             allSelectors[identifier] = rules.join(`
 `), track(identifier), updateRules(identifier, rules);
             for (let rule of rules)
-              try {
+              if (process.env.NODE_ENV === "production")
                 sheet.insertRule(rule, sheet.cssRules.length);
-              } catch (err) {
-                console.groupCollapsed(
-                  `Error inserting rule into CSSStyleSheet: ${String(err)}`
-                ), console.log({ rule, rulesToInsert }), console.trace(), console.groupEnd();
-              }
+              else
+                try {
+                  sheet.insertRule(rule, sheet.cssRules.length);
+                } catch (err) {
+                  console.groupCollapsed(
+                    `Error inserting rule into CSSStyleSheet: ${String(err)}`
+                  ), console.log({ rule, rulesToInsert }), console.trace(), console.groupEnd();
+                }
           }
       }
     }
@@ -804,7 +1482,7 @@ var require_insertStyleRule_native = __commonJS({
       if (process.env.IS_STATIC === "is_static")
         return !0;
       let total = totalSelectorsInserted.get(identifier);
-      return totalSelectorsInserted.size > +(process.env.TAMAGUI_STYLE_INSERTION_WARNING_LIMIT || 5e4) && console.warn(
+      return process.env.NODE_ENV === "development" && totalSelectorsInserted.size > +(process.env.TAMAGUI_STYLE_INSERTION_WARNING_LIMIT || 5e4) && console.warn(
         'Warning: inserting many CSS rules, you may be animating something and generating many CSS insertions, which can degrade performance. Instead, try using the "disableClassName" property on elements that change styles often. To disable this warning set TAMAGUI_STYLE_INSERTION_WARNING_LIMIT from 50000 to something higher'
       ), total === void 0 || total < 2;
     }
@@ -829,7 +1507,7 @@ var require_createProxy_native = __commonJS({
     });
     module2.exports = __toCommonJS2(createProxy_exports);
     function createProxy(target, handler) {
-      return (typeof target != "object" || !target) && console.warn(
+      return process.env.NODE_ENV === "development" && (typeof target != "object" || !target) && console.warn(
         "Invalid object given for proxy:",
         target,
         `
@@ -861,7 +1539,7 @@ var require_matchMedia_native = __commonJS({
     module2.exports = __toCommonJS2(matchMedia_native_exports);
     var matchMediaImpl = matchMediaFallback, matchMedia = (...args) => matchMediaImpl(...args);
     function matchMediaFallback(query) {
-      return console.warn("warning: matchMedia implementation is not provided."), {
+      return process.env.NODE_ENV === "development" && console.warn("warning: matchMedia implementation is not provided."), {
         match: (a, b) => !1,
         addListener: () => {
         },
@@ -894,10 +1572,11 @@ var require_isDevTools_native = __commonJS({
     });
     module2.exports = __toCommonJS2(isDevTools_exports);
     var isDevTools = (() => {
-      try {
-        return new Function("try {return this===window;}catch(e){ return false;}")();
-      } catch {
-      }
+      if (process.env.NODE_ENV === "development")
+        try {
+          return new Function("try {return this===window;}catch(e){ return false;}")();
+        } catch {
+        }
       return !1;
     })();
   }
@@ -920,7 +1599,7 @@ var require_expandStyle_native = __commonJS({
       expandStyle: () => expandStyle
     });
     module2.exports = __toCommonJS2(expandStyle_exports);
-    var import_constants2 = require_index_native();
+    var import_constants2 = require_index_native2();
     function expandStyle(key, value) {
       if (!1)
         switch (key) {
@@ -1403,7 +2082,7 @@ var require_normalize_color = __commonJS({
 });
 
 // ../normalize-css-color/dist/cjs/index.native.js
-var require_index_native4 = __commonJS({
+var require_index_native5 = __commonJS({
   "../normalize-css-color/dist/cjs/index.native.js"(exports, module2) {
     "use strict";
     var __create2 = Object.create, __defProp2 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __getProtoOf2 = Object.getPrototypeOf, __hasOwnProp2 = Object.prototype.hasOwnProperty, __export2 = (target, all) => {
@@ -1481,7 +2160,7 @@ var require_normalizeColor_native = __commonJS({
       rgba: () => import_normalize_css_color2.rgba
     });
     module2.exports = __toCommonJS2(normalizeColor_exports);
-    var import_constants2 = require_index_native(), import_normalize_css_color = require_index_native4(), import_normalize_css_color2 = require_index_native4(), normalizeColor = (color, opacity) => {
+    var import_constants2 = require_index_native2(), import_normalize_css_color = require_index_native5(), import_normalize_css_color2 = require_index_native5(), normalizeColor = (color, opacity) => {
       if (!color)
         return;
       if (color[0] === "$" || color[0] === "v" && color.startsWith("var(") || import_constants2.isWeb && opacity === 1)
@@ -1491,7 +2170,7 @@ var require_normalizeColor_native = __commonJS({
         let { r, g, b, a } = (0, import_normalize_css_color.rgba)(colorProcessed), alpha = (opacity ?? a ?? 1).toFixed(2);
         return `rgba(${r},${g},${b},${alpha})`;
       }
-      console.warn(`Unknown color value: ${color}`);
+      process.env.NODE_ENV === "development" && console.warn(`Unknown color value: ${color}`);
     };
   }
 });
@@ -1514,7 +2193,7 @@ var require_normalizeValueWithProperty_native = __commonJS({
       reverseMapClassNameToValue: () => reverseMapClassNameToValue
     });
     module2.exports = __toCommonJS2(normalizeValueWithProperty_exports);
-    var import_constants2 = require_index_native(), import_helpers = require_index_native3(), import_insertStyleRule = require_insertStyleRule_native(), stylePropsAllPlusTransforms = {
+    var import_constants2 = require_index_native2(), import_helpers = require_index_native4(), import_insertStyleRule = require_insertStyleRule_native(), stylePropsAllPlusTransforms = {
       ...import_helpers.stylePropsAll,
       translateX: !0,
       translateY: !0
@@ -1531,13 +2210,13 @@ var require_normalizeValueWithProperty_native = __commonJS({
       if (rcache[cssRule])
         return rcache[cssRule];
       if (!cssRule) {
-        console.warn(
+        process.env.NODE_ENV === "development" && console.warn(
           `No CSS rule found for ${key} looking for selector ".${className}", you may not be injecting extracted CSS`
         );
         return;
       }
       let cssVal = cssRule.replace(/.*:/, "").replace(/;.*/, "").trim(), res;
-      return cssVal.startsWith("var(") ? res = cssVal : import_helpers.stylePropsUnitless[key] ? res = +cssVal : cssVal.endsWith("px") ? res = +cssVal.replace("px", "") : res = cssVal, rcache[cssRule] = res, typeof res == "number" && isNaN(res) && console.log("Tamagui invalid parsed value, NaN:", {
+      return cssVal.startsWith("var(") ? res = cssVal : import_helpers.stylePropsUnitless[key] ? res = +cssVal : cssVal.endsWith("px") ? res = +cssVal.replace("px", "") : res = cssVal, rcache[cssRule] = res, process.env.NODE_ENV === "development" && typeof res == "number" && isNaN(res) && console.log("Tamagui invalid parsed value, NaN:", {
         res,
         cssVal,
         cssRule,
@@ -1565,7 +2244,7 @@ var require_normalizeShadow_native = __commonJS({
       normalizeShadow: () => normalizeShadow
     });
     module2.exports = __toCommonJS2(normalizeShadow_native_exports);
-    var import_normalize_css_color = require_index_native4(), import_defaultOffset = require_defaultOffset_native(), import_normalizeColor = require_normalizeColor_native(), import_normalizeValueWithProperty = require_normalizeValueWithProperty_native();
+    var import_normalize_css_color = require_index_native5(), import_defaultOffset = require_defaultOffset_native(), import_normalizeColor = require_normalizeColor_native(), import_normalizeValueWithProperty = require_normalizeValueWithProperty_native();
     function normalizeShadow({
       shadowColor,
       shadowOffset,
@@ -1660,7 +2339,7 @@ var require_expandStyles_native = __commonJS({
       fixStyles: () => fixStyles
     });
     module2.exports = __toCommonJS2(expandStyles_exports);
-    var import_constants2 = require_index_native(), import_expandStyle = require_expandStyle_native(), import_normalizeShadow = require_normalizeShadow_native(), import_normalizeValueWithProperty = require_normalizeValueWithProperty_native(), import_pseudoDescriptors = require_pseudoDescriptors_native();
+    var import_constants2 = require_index_native2(), import_expandStyle = require_expandStyle_native(), import_normalizeShadow = require_normalizeShadow_native(), import_normalizeValueWithProperty = require_normalizeValueWithProperty_native(), import_pseudoDescriptors = require_pseudoDescriptors_native();
     function expandStylesAndRemoveNullishValues(style) {
       let res = {};
       for (let key in style) {
@@ -1797,7 +2476,7 @@ var require_propMapper_native = __commonJS({
       propMapper: () => propMapper
     });
     module2.exports = __toCommonJS2(propMapper_exports);
-    var import_constants2 = require_index_native(), import_helpers = require_index_native3(), import_config = require_config_native(), import_isDevTools = require_isDevTools_native(), import_createVariable = require_createVariable_native(), import_expandStyle = require_expandStyle_native(), import_expandStyles = require_expandStyles_native(), import_getVariantExtras = require_getVariantExtras_native(), import_isObj = require_isObj_native(), import_pseudoDescriptors = require_pseudoDescriptors_native(), propMapper = (key, value, styleStateIn, subPropsIn) => {
+    var import_constants2 = require_index_native2(), import_helpers = require_index_native4(), import_config = require_config_native(), import_isDevTools = require_isDevTools_native(), import_createVariable = require_createVariable_native(), import_expandStyle = require_expandStyle_native(), import_expandStyles = require_expandStyles_native(), import_getVariantExtras = require_getVariantExtras_native(), import_isObj = require_isObj_native(), import_pseudoDescriptors = require_pseudoDescriptors_native(), propMapper = (key, value, styleStateIn, subPropsIn) => {
       if (!import_constants2.isAndroid && key === "elevationAndroid")
         return;
       let subProps = styleStateIn.styleProps.fallbackProps || subPropsIn, styleState = subProps ? new Proxy(styleStateIn, {
@@ -1805,7 +2484,7 @@ var require_propMapper_native = __commonJS({
           return k === "curProps" ? subProps : Reflect.get(_, k);
         }
       }) : styleStateIn, { conf, styleProps, fontFamily, staticConfig } = styleState, { variants } = staticConfig;
-      if (fontFamily && fontFamily[0] === "$" && !(fontFamily in conf.fontsParsed) && console.warn(
+      if (process.env.NODE_ENV === "development" && fontFamily && fontFamily[0] === "$" && !(fontFamily in conf.fontsParsed) && console.warn(
         `Warning: no fontFamily "${fontFamily}" found in config: ${Object.keys(conf.fontsParsed).join(
           ", "
         )}`
@@ -1823,7 +2502,7 @@ var require_propMapper_native = __commonJS({
       if (!variants)
         return;
       let variantValue = getVariantDefinition(variants[key], key, value, conf);
-      if (debug === "verbose" && (console.groupCollapsed(`\u2666\uFE0F\u2666\uFE0F\u2666\uFE0F resolve variant ${key}`), console.log({
+      if (process.env.NODE_ENV === "development" && debug === "verbose" && (console.groupCollapsed(`\u2666\uFE0F\u2666\uFE0F\u2666\uFE0F resolve variant ${key}`), console.log({
         key,
         value,
         variantValue,
@@ -1840,12 +2519,12 @@ var require_propMapper_native = __commonJS({
       }
       if (typeof variantValue == "function") {
         let fn = variantValue, extras = (0, import_getVariantExtras.getVariantExtras)(styleState);
-        variantValue = fn(value, extras), debug === "verbose" && (console.groupCollapsed("   expanded functional variant", key), console.log({ fn, variantValue, extras }), console.groupEnd());
+        variantValue = fn(value, extras), process.env.NODE_ENV === "development" && debug === "verbose" && (console.groupCollapsed("   expanded functional variant", key), console.log({ fn, variantValue, extras }), console.groupEnd());
       }
       let fontFamilyResult;
       if ((0, import_isObj.isObj)(variantValue)) {
         let fontFamilyUpdate = variantValue.fontFamily || variantValue[conf.inverseShorthands.fontFamily];
-        fontFamilyUpdate && (fontFamilyResult = getFontFamilyFromNameOrVariable(fontFamilyUpdate, conf), styleState.fontFamily = fontFamilyResult, debug === "verbose" && console.log("   updating font family", fontFamilyResult)), variantValue = resolveTokensAndVariants(
+        fontFamilyUpdate && (fontFamilyResult = getFontFamilyFromNameOrVariable(fontFamilyUpdate, conf), styleState.fontFamily = fontFamilyResult, process.env.NODE_ENV === "development" && debug === "verbose" && console.log("   updating font family", fontFamilyResult)), variantValue = resolveTokensAndVariants(
           key,
           variantValue,
           styleProps,
@@ -1874,7 +2553,7 @@ var require_propMapper_native = __commonJS({
     var variableToFontNameCache = /* @__PURE__ */ new WeakMap(), fontFamilyCache = /* @__PURE__ */ new WeakMap(), getPropMappedFontFamily = (expanded) => expanded && fontFamilyCache.get(expanded), resolveTokensAndVariants = (key, value, styleProps, styleState, parentVariantKey) => {
       var _a;
       let { conf, staticConfig, debug, theme } = styleState, { variants } = staticConfig, res = {};
-      debug === "verbose" && console.log("   - resolveTokensAndVariants", key, value);
+      process.env.NODE_ENV === "development" && debug === "verbose" && console.log("   - resolveTokensAndVariants", key, value);
       for (let rKey in value) {
         let fKey = conf.shorthands[rKey] || rKey, val = value[rKey];
         if (variants && fKey in variants) {
@@ -1903,10 +2582,10 @@ var require_propMapper_native = __commonJS({
         }
         if ((0, import_isObj.isObj)(val)) {
           let subObject = resolveTokensAndVariants(fKey, val, styleProps, styleState, key);
-          debug === "verbose" && console.log("object", fKey, subObject), res[fKey] ??= {}, Object.assign(res[fKey], subObject);
+          process.env.NODE_ENV === "development" && debug === "verbose" && console.log("object", fKey, subObject), res[fKey] ??= {}, Object.assign(res[fKey], subObject);
         } else
           res[fKey] = val;
-        debug && ((_a = res[fKey]) == null ? void 0 : _a[0]) === "$" && console.warn(`\u26A0\uFE0F Missing token in theme ${theme.name}:`, fKey, res[fKey], theme);
+        process.env.NODE_ENV === "development" && debug && ((_a = res[fKey]) == null ? void 0 : _a[0]) === "$" && console.warn(`\u26A0\uFE0F Missing token in theme ${theme.name}:`, fKey, res[fKey], theme);
       }
       return res;
     }, tokenCats = ["size", "color", "radius", "space", "zIndex"].map((name) => ({
@@ -1934,7 +2613,7 @@ var require_propMapper_native = __commonJS({
         return value;
       let { theme, conf = (0, import_config.getConfig)(), context, fontFamily } = styleState, tokensParsed = conf.tokensParsed, valOrVar, hasSet = !1;
       if (theme && value in theme)
-        styleState.debug === "verbose" && console.log(` - getting theme value for ${key} from ${value}`), valOrVar = theme[value], hasSet = !0;
+        process.env.NODE_ENV === "development" && styleState.debug === "verbose" && console.log(` - getting theme value for ${key} from ${value}`), valOrVar = theme[value], hasSet = !0;
       else if (value in conf.specificTokens)
         hasSet = !0, valOrVar = conf.specificTokens[value];
       else {
@@ -1965,7 +2644,7 @@ var require_propMapper_native = __commonJS({
           spaceVar != null && (valOrVar = spaceVar, hasSet = !0);
         }
       }
-      return hasSet ? resolveVariableValue(valOrVar, resolveAs) : (import_isDevTools.isDevTools && styleState.debug === "verbose" && (console.groupCollapsed("  \uFE52 propMap (val)", key, value), console.log({ valOrVar, theme, hasSet }, theme ? theme[key] : ""), console.groupEnd()), value);
+      return hasSet ? resolveVariableValue(valOrVar, resolveAs) : (process.env.NODE_ENV === "development" && import_isDevTools.isDevTools && styleState.debug === "verbose" && (console.groupCollapsed("  \uFE52 propMap (val)", key, value), console.log({ valOrVar, theme, hasSet }, theme ? theme[key] : ""), console.groupEnd()), value);
     };
     function resolveVariableValue(valOrVar, resolveVariablesAs) {
       return resolveVariablesAs === "none" ? valOrVar : (0, import_createVariable.isVariable)(valOrVar) ? !import_constants2.isWeb || resolveVariablesAs === "value" ? valOrVar.val : valOrVar.variable : valOrVar;
@@ -2017,7 +2696,7 @@ var require_ThemeManager_native = __commonJS({
       getNonComponentParentManager: () => getNonComponentParentManager
     });
     module2.exports = __toCommonJS2(ThemeManager_exports);
-    var import_constants2 = require_index_native(), import_config = require_config_native(), import_constants22 = require_constants_native(), emptyState = { name: "" };
+    var import_constants2 = require_index_native2(), import_config = require_config_native(), import_constants22 = require_constants_native(), emptyState = { name: "" };
     function getHasThemeUpdatingProps(props) {
       return props.name || props.componentName || props.inverse || props.reset;
     }
@@ -2028,9 +2707,9 @@ var require_ThemeManager_native = __commonJS({
           return;
         }
         if (!parentManagerIn)
-          throw new Error(
+          throw process.env.NODE_ENV !== "production" ? new Error(
             "No parent manager given, this is likely due to duplicated Tamagui dependencies. Check your lockfile for mis-matched versions. It could also be from an error somewhere else in your stack causing Tamagui to recieve undefined context, you can try putting some ErrorBoundary components around other areas of your app, or a Suspense boundary."
-          );
+          ) : "\u274C 0";
         if (this.parentManager = parentManagerIn, !this.updateStateFromProps(props, !1))
           return parentManagerIn || this;
       }
@@ -2044,7 +2723,7 @@ var require_ThemeManager_native = __commonJS({
       updateState(nextState, shouldNotify = !0) {
         this.state = nextState;
         let names = this.state.name.split("_"), lastName = names[names.length - 1][0];
-        this.isComponent = lastName[0] === lastName[0].toUpperCase(), this._allKeys = null, this.scheme = names[0] === "light" ? "light" : names[0] === "dark" ? "dark" : null, this._numChangeEventsSent ??= 0, this._numChangeEventsSent++, shouldNotify && queueMicrotask(() => {
+        this.isComponent = lastName[0] === lastName[0].toUpperCase(), this._allKeys = null, this.scheme = names[0] === "light" ? "light" : names[0] === "dark" ? "dark" : null, process.env.NODE_ENV === "development" && (this._numChangeEventsSent ??= 0, this._numChangeEventsSent++), shouldNotify && queueMicrotask(() => {
           this.notify();
         });
       }
@@ -2072,7 +2751,7 @@ var require_ThemeManager_native = __commonJS({
         this.themeListeners.forEach((cb) => cb(this.state.name, this, forced));
       }
       onChangeTheme(cb, debugId) {
-        return debugId && (this._listeningIds ??= /* @__PURE__ */ new Set(), this._listeningIds.add(debugId)), this.themeListeners.add(cb), () => {
+        return process.env.NODE_ENV === "development" && debugId && (this._listeningIds ??= /* @__PURE__ */ new Set(), this._listeningIds.add(debugId)), this.themeListeners.add(cb), () => {
           this.themeListeners.delete(cb);
         };
       }
@@ -2090,7 +2769,7 @@ var require_ThemeManager_native = __commonJS({
       if (!props.name && !props.inverse && !props.reset && !props.componentName)
         return null;
       if (props.reset && !isDirectParentAComponentTheme && !(parentManager != null && parentManager.parentManager))
-        return console.warn("Cannot reset no grandparent exists"), null;
+        return process.env.NODE_ENV === "development" && console.warn("Cannot reset no grandparent exists"), null;
       let result = null, nextName = props.reset ? isDirectParentAComponentTheme ? ((_a = parentManager == null ? void 0 : parentManager.state) == null ? void 0 : _a.name) || "" : ((_c = (_b = parentManager == null ? void 0 : parentManager.parentManager) == null ? void 0 : _b.state) == null ? void 0 : _c.name) || "" : props.name || "", { componentName } = props, parentName = props.reset ? isDirectParentAComponentTheme ? (
         // here because parentManager already skipped componentTheme so we have to only go up once
         ((_d = parentManager == null ? void 0 : parentManager.parentManager) == null ? void 0 : _d.state.name) || ""
@@ -2099,7 +2778,7 @@ var require_ThemeManager_native = __commonJS({
       let base = parentName.split(import_constants22.THEME_NAME_SEPARATOR), lastSegment = base[base.length - 1], isParentComponentTheme = parentName && lastSegment[0].toUpperCase() === lastSegment[0];
       isParentComponentTheme && base.pop();
       let parentBaseTheme = isParentComponentTheme ? base.slice(0, base.length).join(import_constants22.THEME_NAME_SEPARATOR) : parentName, max = base.length, min = componentName && !nextName ? max : 0;
-      typeof props.debug == "string" && (console.groupCollapsed("ThemeManager.getState()"), console.log({
+      process.env.NODE_ENV === "development" && typeof props.debug == "string" && (console.groupCollapsed("ThemeManager.getState()"), console.log({
         props,
         parentName,
         parentBaseTheme,
@@ -2134,7 +2813,7 @@ var require_ThemeManager_native = __commonJS({
           potentials = [...componentPotentials, ...potentials, ...allComponentThemes];
         }
         let found = potentials.find((t) => t in themes);
-        if (typeof props.debug == "string" && console.log(" - ", { found, potentials, parentManager }), found) {
+        if (process.env.NODE_ENV === "development" && typeof props.debug == "string" && console.log(" - ", { found, potentials, parentManager }), found) {
           result = {
             name: found,
             theme: themes[found],
@@ -2146,7 +2825,7 @@ var require_ThemeManager_native = __commonJS({
           break;
         }
       }
-      return typeof props.debug == "string" && typeof window < "u" && (console.warn("ThemeManager.getState():", {
+      return process.env.NODE_ENV === "development" && typeof props.debug == "string" && typeof window < "u" && (console.warn("ThemeManager.getState():", {
         result
       }), console.trace(), console.groupEnd()), result;
     }
@@ -2225,7 +2904,7 @@ var require_useTheme_native = __commonJS({
       useThemeWithState: () => useThemeWithState
     });
     module2.exports = __toCommonJS2(useTheme_exports);
-    var import_constants2 = require_index_native(), import_react = require("react"), import_config = require_config_native(), import_createVariable = require_createVariable_native(), import_createProxy = require_createProxy_native(), import_ThemeManager = require_ThemeManager_native(), import_ThemeManagerContext = require_ThemeManagerContext_native(), import_getThemeUnwrapped = require_getThemeUnwrapped_native(), emptyProps = { name: null }, cached;
+    var import_constants2 = require_index_native2(), import_react = require("react"), import_config = require_config_native(), import_createVariable = require_createVariable_native(), import_createProxy = require_createProxy_native(), import_ThemeManager = require_ThemeManager_native(), import_ThemeManagerContext = require_ThemeManagerContext_native(), import_getThemeUnwrapped = require_getThemeUnwrapped_native(), emptyProps = { name: null }, cached;
     function getDefaultThemeProxied() {
       if (cached)
         return cached;
@@ -2243,20 +2922,20 @@ var require_useTheme_native = __commonJS({
         import_constants2.isServer ? void 0 : () => {
           var _a, _b;
           let next = ((_a = props.shouldUpdate) == null ? void 0 : _a.call(props)) ?? (keys.current.length > 0 ? !0 : void 0);
-          return props.debug && props.debug !== "profile" && console.log("  \u{1F3A8} useTheme() shouldUpdate?", next, {
+          return process.env.NODE_ENV === "development" && props.debug && props.debug !== "profile" && console.log("  \u{1F3A8} useTheme() shouldUpdate?", next, {
             shouldUpdateProp: (_b = props.shouldUpdate) == null ? void 0 : _b.call(props),
             keys: [...keys.current]
           }), next;
         }
       ), { themeManager, state } = changedThemeState, { theme, name, className } = state;
       if (!theme)
-        throw new Error(
+        throw process.env.NODE_ENV === "development" ? new Error(
           `No theme found given props ${JSON.stringify(
             props
           )}. Themes given to tamagui are: ${Object.keys((0, import_config.getConfig)().themes)}`
-        );
+        ) : "\u274C 1";
       let themeProxied = (0, import_react.useMemo)(() => getThemeProxied(theme, themeManager, keys.current, props.debug), [theme, name, className, themeManager]);
-      return props.debug === "verbose" && (console.groupCollapsed("  \u{1F539} useTheme =>", name), console.log("returning state", changedThemeState, "from props", props), console.groupEnd()), [changedThemeState, themeProxied];
+      return process.env.NODE_ENV === "development" && props.debug === "verbose" && (console.groupCollapsed("  \u{1F539} useTheme =>", name), console.log("returning state", changedThemeState, "from props", props), console.groupEnd()), [changedThemeState, themeProxied];
     };
     function getThemeProxied(theme, themeManager, keys, debug) {
       return (0, import_createProxy.createProxy)(theme, {
@@ -2280,7 +2959,7 @@ var require_useTheme_native = __commonJS({
                 // when they touch the actual value we only track it
                 // if its a variable (web), its ignored!
                 get(_2, subkey) {
-                  return keys && (subkey === "val" || subkey === "get" && !import_constants2.isWeb) && !keys.includes(keyString) && (keys.push(keyString), debug && console.log(` \u{1F3A8} useTheme() tracking new key: ${keyString}`)), subkey === "get" ? () => (0, import_createVariable.getVariable)(val) : Reflect.get(val, subkey);
+                  return keys && (subkey === "val" || subkey === "get" && !import_constants2.isWeb) && !keys.includes(keyString) && (keys.push(keyString), process.env.NODE_ENV === "development" && debug && console.log(` \u{1F3A8} useTheme() tracking new key: ${keyString}`)), subkey === "get" ? () => (0, import_createVariable.getVariable)(val) : Reflect.get(val, subkey);
                 }
               });
           }
@@ -2321,7 +3000,7 @@ var require_useTheme_native = __commonJS({
           forced && setThemeState((prev) => createState(prev, !0));
         }), disposeChangeListener = parentManager == null ? void 0 : parentManager.onChangeTheme((name, manager) => {
           let force = shouldUpdate == null ? void 0 : shouldUpdate(), doUpdate = force ?? !!(keys != null && keys.length || isNewTheme);
-          props.debug && console.log(" \u{1F538} onChange", themeManager.id, {
+          process.env.NODE_ENV === "development" && props.debug && console.log(" \u{1F538} onChange", themeManager.id, {
             force,
             doUpdate,
             props,
@@ -2342,7 +3021,7 @@ var require_useTheme_native = __commonJS({
         props.name,
         props.reset,
         mounted
-      ]), props.debug !== "profile" && (0, import_react.useEffect)(() => (globalThis.TamaguiThemeManagers ??= /* @__PURE__ */ new Set(), globalThis.TamaguiThemeManagers.add(themeManager), () => {
+      ]), process.env.NODE_ENV === "development" && props.debug !== "profile" && (0, import_react.useEffect)(() => (globalThis.TamaguiThemeManagers ??= /* @__PURE__ */ new Set(), globalThis.TamaguiThemeManagers.add(themeManager), () => {
         globalThis.TamaguiThemeManagers.delete(themeManager);
       }), [themeManager])), isInversingOnMount) {
         if (!parentManager)
@@ -2388,7 +3067,7 @@ var require_useTheme_native = __commonJS({
           isNewTheme: isNewTheme2,
           mounted: mounted2
         };
-        if (props.debug && import_constants2.isClient) {
+        if (process.env.NODE_ENV === "development" && props.debug && import_constants2.isClient) {
           console.groupCollapsed(` \u{1F537} ${themeManager2.id} useChangeThemeEffect createState`);
           let parentState = { ...parentManager == null ? void 0 : parentManager.state }, parentId = parentManager == null ? void 0 : parentManager.id, themeManagerState = { ...themeManager2.state };
           console.log({
@@ -2441,18 +3120,21 @@ var require_useMedia_native = __commonJS({
       useMediaPropsActive: () => useMediaPropsActive2
     });
     module2.exports = __toCommonJS2(useMedia_exports);
-    var import_constants2 = require_index_native(), import_react = require("react"), import_config = require_config_native(), import_createProxy = require_createProxy_native(), import_matchMedia = require_matchMedia_native(), import_propMapper = require_propMapper_native(), import_pseudoDescriptors = require_pseudoDescriptors_native(), import_useTheme = require_useTheme_native(), mediaState2 = (0, import_createProxy.createProxy)(
-      {},
-      {
-        get(target, key) {
-          if (typeof key == "string" && key[0] === "$" && // dont error on $$typeof
-          key[1] !== "$")
-            throw new Error(`Access mediaState should not use "$": ${key}`);
-          return Reflect.get(target, key);
+    var import_constants2 = require_index_native2(), import_react = require("react"), import_config = require_config_native(), import_createProxy = require_createProxy_native(), import_matchMedia = require_matchMedia_native(), import_propMapper = require_propMapper_native(), import_pseudoDescriptors = require_pseudoDescriptors_native(), import_useTheme = require_useTheme_native(), mediaState2 = (
+      // development only safeguard
+      process.env.NODE_ENV === "development" ? (0, import_createProxy.createProxy)(
+        {},
+        {
+          get(target, key) {
+            if (typeof key == "string" && key[0] === "$" && // dont error on $$typeof
+            key[1] !== "$")
+              throw new Error(`Access mediaState should not use "$": ${key}`);
+            return Reflect.get(target, key);
+          }
         }
-      }
+      ) : {}
     ), mediaQueryConfig2 = {}, getMedia2 = () => mediaState2, mediaKeys = /* @__PURE__ */ new Set(), isMediaKey = (key) => mediaKeys.has(key) || key[0] === "$" && (key.startsWith("$platform-") || key.startsWith("$theme-") || key.startsWith("$group-")), initState, getInitialMediaState = () => ((0, import_config.getConfig)().disableSSR ? mediaState2 : initState) || {}, defaultMediaImportance = Object.keys(import_pseudoDescriptors.pseudoDescriptors).length, mediaKeysOrdered, getMediaKeyImportance = (key) => {
-      if (key[0] === "$")
+      if (process.env.NODE_ENV === "development" && key[0] === "$")
         throw new Error("use short key");
       return (0, import_config.getConfig)().settings.mediaPropOrder ? defaultMediaImportance : mediaKeysOrdered.indexOf(key) + 100;
     }, dispose = /* @__PURE__ */ new Set(), mediaVersion = 0, configureMedia2 = (config) => {
@@ -2618,7 +3300,7 @@ var require_Tamagui_native = __commonJS({
       setIdentifierValue: () => setIdentifierValue
     });
     module2.exports = __toCommonJS2(Tamagui_exports);
-    var Helpers = __toESM2(require_index_native3()), import_config = require_config_native(), import_insertStyleRule = require_insertStyleRule_native(), import_useMedia = require_useMedia_native(), TamaguiManager = class {
+    var Helpers = __toESM2(require_index_native4()), import_config = require_config_native(), import_insertStyleRule = require_insertStyleRule_native(), import_useMedia = require_useMedia_native(), TamaguiManager = class {
       constructor() {
         this.Helpers = Helpers;
       }
@@ -2671,7 +3353,7 @@ var require_compose_refs_native = __commonJS({
       useComposedRefs: () => useComposedRefs
     });
     module2.exports = __toCommonJS2(compose_refs_exports);
-    var React2 = __toESM2(require("react"));
+    var React = __toESM2(require("react"));
     function setRef(ref, value) {
       typeof ref == "function" ? ref(value) : ref && (ref.current = value);
     }
@@ -2679,13 +3361,13 @@ var require_compose_refs_native = __commonJS({
       return (node) => refs.forEach((ref) => setRef(ref, node));
     }
     function useComposedRefs(...refs) {
-      return React2.useCallback(composeRefs(...refs), refs);
+      return React.useCallback(composeRefs(...refs), refs);
     }
   }
 });
 
 // ../compose-refs/dist/cjs/index.native.js
-var require_index_native5 = __commonJS({
+var require_index_native6 = __commonJS({
   "../compose-refs/dist/cjs/index.native.js"(exports, module2) {
     "use strict";
     var __defProp2 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __hasOwnProp2 = Object.prototype.hasOwnProperty, __copyProps2 = (to, from, except, desc) => {
@@ -2700,7 +3382,7 @@ var require_index_native5 = __commonJS({
 });
 
 // ../use-did-finish-ssr/dist/cjs/index.native.js
-var require_index_native6 = __commonJS({
+var require_index_native7 = __commonJS({
   "../use-did-finish-ssr/dist/cjs/index.native.js"(exports, module2) {
     "use strict";
     var __defProp2 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __hasOwnProp2 = Object.prototype.hasOwnProperty, __export2 = (target, all) => {
@@ -3107,7 +3789,7 @@ var require_getSplitStyles_native = __commonJS({
       useSplitStyles: () => useSplitStyles
     });
     module2.exports = __toCommonJS2(getSplitStyles_exports);
-    var import_constants2 = require_index_native(), import_helpers = require_index_native3(), import_react = require("react"), import_config = require_config_native(), import_accessibilityDirectMap = require_accessibilityDirectMap_native(), import_isDevTools = require_isDevTools_native(), import_useMedia = require_useMedia_native(), import_createMediaStyle = require_createMediaStyle_native(), import_expandStyles = require_expandStyles_native(), import_getGroupPropParts = require_getGroupPropParts_native(), import_getStylesAtomic = require_getStylesAtomic_native(), import_insertStyleRule = require_insertStyleRule_native(), import_normalizeValueWithProperty = require_normalizeValueWithProperty_native(), import_propMapper = require_propMapper_native(), import_pseudoDescriptors = require_pseudoDescriptors_native(), fontFamilyKey = "fontFamily", IS_STATIC = process.env.IS_STATIC === "is_static", conf, PROP_SPLIT = "-", getSplitStyles = (props, staticConfig, theme, themeName, componentState, styleProps, parentSplitStyles, context, elementType, debug) => {
+    var import_constants2 = require_index_native2(), import_helpers = require_index_native4(), import_react = require("react"), import_config = require_config_native(), import_accessibilityDirectMap = require_accessibilityDirectMap_native(), import_isDevTools = require_isDevTools_native(), import_useMedia = require_useMedia_native(), import_createMediaStyle = require_createMediaStyle_native(), import_expandStyles = require_expandStyles_native(), import_getGroupPropParts = require_getGroupPropParts_native(), import_getStylesAtomic = require_getStylesAtomic_native(), import_insertStyleRule = require_insertStyleRule_native(), import_normalizeValueWithProperty = require_normalizeValueWithProperty_native(), import_propMapper = require_propMapper_native(), import_pseudoDescriptors = require_pseudoDescriptors_native(), fontFamilyKey = "fontFamily", IS_STATIC = process.env.IS_STATIC === "is_static", conf, PROP_SPLIT = "-", getSplitStyles = (props, staticConfig, theme, themeName, componentState, styleProps, parentSplitStyles, context, elementType, debug) => {
       var _a, _b, _c, _e, _f, _g;
       conf = conf || (0, import_config.getConfig)();
       let { shorthands } = conf, {
@@ -3134,7 +3816,7 @@ var require_getSplitStyles_native = __commonJS({
         context,
         debug
       };
-      debug && debug !== "profile" && import_constants2.isClient && (console.groupCollapsed("getSplitStyles (collapsed)"), console.log({
+      process.env.NODE_ENV === "development" && debug && debug !== "profile" && import_constants2.isClient && (console.groupCollapsed("getSplitStyles (collapsed)"), console.log({
         props,
         staticConfig,
         shouldDoClasses,
@@ -3201,7 +3883,7 @@ var require_getSplitStyles_native = __commonJS({
           continue;
         let shouldPassProp = !isStyleProp || // is in parent variants
         isHOC && (parentStaticConfig == null ? void 0 : parentStaticConfig.variants) && keyInit in parentStaticConfig.variants || (inlineProps == null ? void 0 : inlineProps.has(keyInit)), isHOCShouldPassThrough = !!(isHOC && (isShorthand || isValidStyleKeyInit || isMediaOrPseudo || (_a = parentStaticConfig == null ? void 0 : parentStaticConfig.variants) != null && _a[keyInit] || keyInit in skipProps)), shouldPassThrough = shouldPassProp || isHOCShouldPassThrough;
-        if (debug === "verbose" && (console.groupCollapsed(
+        if (process.env.NODE_ENV === "development" && debug === "verbose" && (console.groupCollapsed(
           `\u{1F539}\u{1F539}\u{1F539}\u{1F539} ${keyOg}${keyInit !== keyOg ? ` (shorthand for ${keyInit})` : ""} ${shouldPassThrough ? "(pass)" : ""} \u{1F539}\u{1F539}\u{1F539}\u{1F539}`
         ), console.log({ isVariant, valInit, shouldPassProp }), import_constants2.isClient && console.log({
           variants,
@@ -3217,7 +3899,7 @@ var require_getSplitStyles_native = __commonJS({
           continue;
         }
         let expanded = isMediaOrPseudo || !isVariant && !isValidStyleKeyInit ? [[keyInit, valInit]] : (0, import_propMapper.propMapper)(keyInit, valInit, styleState), next = (0, import_propMapper.getPropMappedFontFamily)(expanded);
-        if (next && (styleState.fontFamily = next), debug === "verbose") {
+        if (next && (styleState.fontFamily = next), process.env.NODE_ENV === "development" && debug === "verbose") {
           console.groupCollapsed("  \u{1F4A0} expanded", keyInit, valInit);
           try {
             !import_constants2.isServer && import_isDevTools.isDevTools && (console.log({
@@ -3244,7 +3926,7 @@ current`, {
           for (let [key, val] of expanded)
             if (!(val == null || key in usedKeys)) {
               if (isPseudo = key in import_helpers.validPseudoKeys, isMedia = !isPseudo && !isValidStyleKeyInit && (0, import_useMedia.isMediaKey)(key), isMediaOrPseudo = isMedia || isPseudo, isVariant = variants && key in variants, (inlineProps != null && inlineProps.has(key) || IS_STATIC && inlineWhenUnflattened != null && inlineWhenUnflattened.has(key)) && (viewProps[key] = props[key] ?? val), isHOC && (isMediaOrPseudo || ((_b = parentStaticConfig == null ? void 0 : parentStaticConfig.variants) == null ? void 0 : _b[keyInit]))) {
-                passDownProp(viewProps, key, val, isMediaOrPseudo), debug === "verbose" && (console.groupCollapsed(` - passing down prop ${key}`), console.log({ val, after: { ...viewProps[key] } }), console.groupEnd());
+                passDownProp(viewProps, key, val, isMediaOrPseudo), process.env.NODE_ENV === "development" && debug === "verbose" && (console.groupCollapsed(` - passing down prop ${key}`), console.log({ val, after: { ...viewProps[key] } }), console.groupEnd());
                 continue;
               }
               if (isPseudo) {
@@ -3256,7 +3938,7 @@ current`, {
                   val,
                   styleProps.noClassNames
                 ), descriptor = import_pseudoDescriptors.pseudoDescriptors[key], isEnter = key === "enterStyle", isExit = key === "exitStyle";
-                if (!styleProps.isAnimated && !componentState.unmounted && (isEnter || isExit) && console.warn(
+                if (process.env.NODE_ENV === "development" && !styleProps.isAnimated && !componentState.unmounted && (isEnter || isExit) && console.warn(
                   `No animation prop given to component ${staticConfig.componentName || ""} with enterStyle / exitStyle, these styles will be ignore.`
                 ), !descriptor || isExit && !styleProps.isExiting)
                   continue;
@@ -3266,12 +3948,12 @@ current`, {
                 }
                 if (shouldDoClasses && !isEnter && !isExit) {
                   let pseudoStyles = (0, import_getStylesAtomic.generateAtomicStyles)(pseudoStyleObject, descriptor);
-                  debug === "verbose" && (console.groupCollapsed("pseudo (classes)", key), console.log({ pseudoStyleObject, pseudoStyles }), console.groupEnd());
+                  process.env.NODE_ENV === "development" && debug === "verbose" && (console.groupCollapsed("pseudo (classes)", key), console.log({ pseudoStyleObject, pseudoStyles }), console.groupEnd());
                   for (let psuedoStyle of pseudoStyles)
                     `${psuedoStyle.property}${PROP_SPLIT}${descriptor.name}` in usedKeys || psuedoStyle.identifier;
                 } else {
                   let descriptorKey = descriptor.stateKey || descriptor.name, pseudoState = componentState[descriptorKey], isDisabled = isExit ? !styleProps.isExiting : !pseudoState;
-                  import_constants2.isWeb && !import_constants2.isClient && isEnter && (isDisabled = !1), debug === "verbose" && (console.groupCollapsed("pseudo", key, { isDisabled }), console.log(pseudoStyleObject, {
+                  import_constants2.isWeb && !import_constants2.isClient && isEnter && (isDisabled = !1), process.env.NODE_ENV === "development" && debug === "verbose" && (console.groupCollapsed("pseudo", key, { isDisabled }), console.log(pseudoStyleObject, {
                     isDisabled,
                     descriptorKey,
                     descriptor,
@@ -3288,7 +3970,7 @@ current`, {
                       }
                     } else {
                       let curImportance = usedKeys[importance] || 0, shouldMerge = importance >= curImportance;
-                      shouldMerge && (pseudos ||= {}, pseudos[key] ||= {}, pseudos[key][pkey] = val2, mergeStyle(styleState, pkey, val2), usedKeys[pkey] ||= 1), debug === "verbose" && console.log("    subKey", pkey, shouldMerge, {
+                      shouldMerge && (pseudos ||= {}, pseudos[key] ||= {}, pseudos[key][pkey] = val2, mergeStyle(styleState, pkey, val2), usedKeys[pkey] ||= 1), process.env.NODE_ENV === "development" && debug === "verbose" && console.log("    subKey", pkey, shouldMerge, {
                         importance,
                         curImportance,
                         pkey,
@@ -3324,7 +4006,7 @@ current`, {
                   // TODO try true like pseudo
                   !1
                 ), mediaKeyShort = key.slice(1);
-                debug === "verbose" && console.log(`  \u{1F4FA} ${key}`, { key, val, mediaStyle, props, shouldDoClasses, componentState });
+                process.env.NODE_ENV === "development" && debug === "verbose" && console.log(`  \u{1F4FA} ${key}`, { key, val, mediaStyle, props, shouldDoClasses, componentState });
                 let hasSpace = val.space;
                 if ((hasSpace || !shouldDoClasses) && (Array.isArray(hasMedia) || (hasMedia = []), hasMedia.push(mediaKeyShort)), shouldDoClasses) {
                   if (hasSpace && (delete mediaStyle.space, mediaState2[mediaKeyShort])) {
@@ -3334,7 +4016,7 @@ current`, {
                       usedKeys,
                       !0
                     );
-                    importance && (space = val.space, usedKeys.space = importance, debug === "verbose" && console.log(
+                    importance && (space = val.space, usedKeys.space = importance, process.env.NODE_ENV === "development" && debug === "verbose" && console.log(
                       `Found more important space for current media ${mediaKeyShort}: ${val} (importance: ${importance})`
                     ));
                   }
@@ -3363,7 +4045,7 @@ current`, {
                   } else if (isGroupMedia) {
                     let groupInfo = (0, import_getGroupPropParts.getGroupPropParts)(mediaKeyShort), groupName = groupInfo.name, groupContext = context == null ? void 0 : context.groups.state[groupName];
                     if (!groupContext) {
-                      debug && console.warn(`No parent with group prop, skipping styles: ${groupName}`);
+                      process.env.NODE_ENV === "development" && debug && console.warn(`No parent with group prop, skipping styles: ${groupName}`);
                       continue;
                     }
                     let groupPseudoKey = groupInfo.pseudo, groupMediaKey = groupInfo.media, componentGroupState = (_c = componentState.group) == null ? void 0 : _c[groupName];
@@ -3415,7 +4097,7 @@ current`, {
               }
               isVariant || (viewProps[key] = val);
             }
-          if (debug === "verbose") {
+          if (process.env.NODE_ENV === "development" && debug === "verbose") {
             console.groupCollapsed(" \u2714\uFE0F expand complete", keyInit);
             try {
               console.log("style", { ...style }), console.log("viewProps", { ...viewProps });
@@ -3450,9 +4132,9 @@ current`, {
           let overrideFace = (_g = (_f = faceInfo[style.fontWeight]) == null ? void 0 : _f[style.fontStyle || "normal"]) == null ? void 0 : _g.val;
           overrideFace && (style.fontFamily = overrideFace, styleState.fontFamily = overrideFace, delete style.fontWeight, delete style.fontStyle);
         }
-        debug && debug !== "profile" && console.log(`Found fontFamily native: ${style.fontFamily}`, faceInfo);
+        process.env.NODE_ENV === "development" && debug && debug !== "profile" && console.log(`Found fontFamily native: ${style.fontFamily}`, faceInfo);
       }
-      if (className && (classNames.className = className), debug === "verbose" && import_isDevTools.isDevTools) {
+      if (className && (classNames.className = className), process.env.NODE_ENV === "development" && debug === "verbose" && import_isDevTools.isDevTools) {
         console.groupCollapsed("  \u{1F539} ===>");
         try {
           let logs = {
@@ -3542,6 +4224,7 @@ current`, {
       // handled after loop so pseudos set usedKeys and override it if necessary
       group: 1
     };
+    process.env.NODE_ENV === "test" && (skipProps["data-test-renders"] = 1);
     Object.assign(skipProps, {
       whiteSpace: 1,
       wordWrap: 1,
@@ -3697,7 +4380,7 @@ var require_Theme_native = __commonJS({
       wrapThemeElements: () => wrapThemeElements
     });
     module2.exports = __toCommonJS2(Theme_exports);
-    var import_constants2 = require_index_native(), import_react = __toESM2(require("react")), import_createVariable = require_createVariable_native(), import_ThemeManagerContext = require_ThemeManagerContext_native(), import_useTheme = require_useTheme_native(), import_ThemeDebug = require_ThemeDebug_native(), import_jsx_runtime = require("react/jsx-runtime"), Theme = (0, import_react.forwardRef)(function(props, ref) {
+    var import_constants2 = require_index_native2(), import_react = __toESM2(require("react")), import_createVariable = require_createVariable_native(), import_ThemeManagerContext = require_ThemeManagerContext_native(), import_useTheme = require_useTheme_native(), import_ThemeDebug = require_ThemeDebug_native(), import_jsx_runtime = require("react/jsx-runtime"), Theme = (0, import_react.forwardRef)(function(props, ref) {
       if (props.disable)
         return props.children;
       let isRoot = !!props._isRoot, disableDirectChildTheme = props["disable-child-theme"], themeState = (0, import_useTheme.useChangeThemeEffect)(props, isRoot), children = (0, import_react.useMemo)(() => {
@@ -3710,7 +4393,7 @@ var require_Theme_native = __commonJS({
             import_react.default.Children.only(children2), children2 = (0, import_react.cloneElement)(children2, { ref });
           } catch {
           }
-        return props.debug === "visualize" && (children2 = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ThemeDebug.ThemeDebug, { themeState, themeProps: props, children: children2 })), children2;
+        return process.env.NODE_ENV === "development" && props.debug === "visualize" && (children2 = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ThemeDebug.ThemeDebug, { themeState, themeProps: props, children: children2 })), children2;
       }, [props.children, disableDirectChildTheme]);
       return useThemedChildren(themeState, children, props, isRoot);
     });
@@ -3853,7 +4536,7 @@ var require_Slot_native = __commonJS({
       Slottable: () => Slottable
     });
     module2.exports = __toCommonJS2(Slot_exports);
-    var import_compose_refs = require_index_native5(), import_constants2 = require_index_native(), import_helpers = require_index_native3(), import_react = require("react"), import_jsx_runtime = require("react/jsx-runtime"), Slot = (0, import_react.forwardRef)(function(props, forwardedRef) {
+    var import_compose_refs = require_index_native6(), import_constants2 = require_index_native2(), import_helpers = require_index_native4(), import_react = require("react"), import_jsx_runtime = require("react/jsx-runtime"), Slot = (0, import_react.forwardRef)(function(props, forwardedRef) {
       let { children, ...slotProps } = props;
       if ((0, import_react.isValidElement)(children)) {
         let mergedProps = mergeSlotProps(children, slotProps);
@@ -3914,7 +4597,7 @@ var require_createComponent_native = __commonJS({
       spacedChildren: () => spacedChildren
     });
     module2.exports = __toCommonJS2(createComponent_exports);
-    var import_compose_refs = require_index_native5(), import_constants2 = require_index_native(), import_helpers = require_index_native3(), import_use_did_finish_ssr = require_index_native6(), import_react = __toESM2(require("react")), import_config = require_config_native(), import_constants22 = require_constants_native(), import_ComponentContext = require_ComponentContext_native(), import_createVariable = require_createVariable_native(), import_defaultComponentState = require_defaultComponentState_native(), import_createShallowSetState = require_createShallowSetState_native(), import_getSplitStyles = require_getSplitStyles_native(), import_mergeProps = require_mergeProps_native(), import_proxyThemeVariables = require_proxyThemeVariables_native(), import_themeable = require_themeable_native(), import_useMedia = require_useMedia_native(), import_useTheme = require_useTheme_native(), import_setupHooks = require_setupHooks_native(), import_Slot = require_Slot_native(), import_Theme = require_Theme_native(), import_ThemeDebug = require_ThemeDebug_native(), import_jsx_runtime = require("react/jsx-runtime"), tamaguiConfig, AnimatedText, AnimatedView, initialTheme, time, mouseUps = /* @__PURE__ */ new Set();
+    var import_compose_refs = require_index_native6(), import_constants2 = require_index_native2(), import_helpers = require_index_native4(), import_use_did_finish_ssr = require_index_native7(), import_react = __toESM2(require("react")), import_config = require_config_native(), import_constants22 = require_constants_native(), import_ComponentContext = require_ComponentContext_native(), import_createVariable = require_createVariable_native(), import_defaultComponentState = require_defaultComponentState_native(), import_createShallowSetState = require_createShallowSetState_native(), import_getSplitStyles = require_getSplitStyles_native(), import_mergeProps = require_mergeProps_native(), import_proxyThemeVariables = require_proxyThemeVariables_native(), import_themeable = require_themeable_native(), import_useMedia = require_useMedia_native(), import_useTheme = require_useTheme_native(), import_setupHooks = require_setupHooks_native(), import_Slot = require_Slot_native(), import_Theme = require_Theme_native(), import_ThemeDebug = require_ThemeDebug_native(), import_jsx_runtime = require("react/jsx-runtime"), tamaguiConfig, AnimatedText, AnimatedView, initialTheme, time, mouseUps = /* @__PURE__ */ new Set();
     if (typeof document < "u") {
       let cancelTouches = () => {
         mouseUps.forEach((x) => x()), mouseUps.clear();
@@ -3928,7 +4611,7 @@ var require_createComponent_native = __commonJS({
       (0, import_config.onConfiguredOnce)((conf) => {
         if (config = conf, !tamaguiConfig && (tamaguiConfig = conf, !initialTheme)) {
           let next = conf.themes[Object.keys(conf.themes)[0]];
-          initialTheme = (0, import_proxyThemeVariables.proxyThemeVariables)(next), initialTheme || console.log("Warning: Missing theme");
+          initialTheme = (0, import_proxyThemeVariables.proxyThemeVariables)(next), process.env.NODE_ENV === "development" && (initialTheme || console.log("Warning: Missing theme"));
         }
       });
       let {
@@ -3939,7 +4622,7 @@ var require_createComponent_native = __commonJS({
         validStyles: validStyles2 = {},
         variants = {}
       } = staticConfig, defaultComponentClassName = `is_${staticConfig.componentName}`, defaultProps = staticConfig.defaultProps;
-      (_a = staticConfig.defaultProps) != null && _a.debug && process.env.IS_STATIC !== "is_static" && console.log(`\u{1F41B} [${staticConfig.componentName || "Component"}]`, {
+      process.env.NODE_ENV === "development" && (_a = staticConfig.defaultProps) != null && _a.debug && process.env.IS_STATIC !== "is_static" && console.log(`\u{1F41B} [${staticConfig.componentName || "Component"}]`, {
         staticConfig,
         defaultProps,
         defaultPropsKeyOrder: defaultProps ? Object.keys(defaultProps) : []
@@ -3951,6 +4634,7 @@ var require_createComponent_native = __commonJS({
           let baseViews = (_b = (_a2 = import_setupHooks.hooks).getBaseViews) == null ? void 0 : _b.call(_a2);
           baseViews && (BaseText = baseViews.Text, BaseView = baseViews.View);
         }
+        process.env.NODE_ENV === "test" && propsIn["data-test-renders"] && (propsIn["data-test-renders"].current ??= 0, propsIn["data-test-renders"].current += 1);
         let componentContext = (0, import_react.useContext)(import_ComponentContext.ComponentContext), styledContextProps, overriddenContextProps, contextValue, { context } = staticConfig;
         if (context) {
           contextValue = (0, import_react.useContext)(context);
@@ -3966,20 +4650,20 @@ var require_createComponent_native = __commonJS({
         let curDefaultProps = styledContextProps ? { ...defaultProps, ...styledContextProps } : defaultProps, props;
         curDefaultProps ? props = (0, import_mergeProps.mergeProps)(curDefaultProps, propsIn) : props = propsIn;
         let debugProp = props.debug, componentName = props.componentName || staticConfig.componentName;
-        time && time`start (ignore)`;
+        process.env.NODE_ENV === "development" && time && time`start (ignore)`;
         let isHydrated = config != null && config.disableSSR ? !0 : (0, import_use_did_finish_ssr.useDidFinishSSR)();
-        time && time`did-finish-ssr`;
+        process.env.NODE_ENV === "development" && time && time`did-finish-ssr`;
         let stateRef = (0, import_react.useRef)(
           void 0
         );
-        stateRef.current ||= {}, time && time`stateref`;
+        stateRef.current ||= {}, process.env.NODE_ENV === "development" && time && time`stateref`;
         let hostRef = (0, import_react.useRef)(null), animationsConfig = componentContext.animationDriver, useAnimations = animationsConfig == null ? void 0 : animationsConfig.useAnimations, hasAnimationProp = !!(props.animation || props.style && hasAnimatedStyleValue(props.style)), supportsCSSVars = animationsConfig == null ? void 0 : animationsConfig.supportsCSSVars, willBeAnimated = (() => {
           if (import_constants2.isServer && !supportsCSSVars)
             return !1;
           let curState = stateRef.current;
           return !!(hasAnimationProp && !isHOC && useAnimations || curState.hasAnimated);
         })(), usePresence = animationsConfig == null ? void 0 : animationsConfig.usePresence, presence = willBeAnimated && (usePresence == null ? void 0 : usePresence()) || null, hasEnterStyle = !!props.enterStyle, needsMount = !!((!import_constants2.isWeb || import_constants2.isClient) && willBeAnimated);
-        time && time`pre-use-state`;
+        process.env.NODE_ENV === "development" && time && time`pre-use-state`;
         let initialState = willBeAnimated ? supportsCSSVars ? import_defaultComponentState.defaultComponentStateShouldEnter : import_defaultComponentState.defaultComponentState : import_defaultComponentState.defaultComponentStateMounted, states = (0, import_react.useState)(initialState), state = propsIn.forceStyle ? { ...states[0], [propsIn.forceStyle]: !0 } : states[0], setState = states[1], setStateShallow = (0, import_createShallowSetState.createShallowSetState)(setState), groupName = props.group, groupClassName = groupName ? `t_group_${props.group}` : "";
         if (groupName) {
           let groupContextState = componentContext.groups.state, og = setStateShallow;
@@ -3994,11 +4678,11 @@ var require_createComponent_native = __commonJS({
             groupContextState[groupName] = next;
           };
         }
-        time && time`use-state`;
+        process.env.NODE_ENV === "development" && time && time`use-state`;
         let isAnimated = willBeAnimated;
         willBeAnimated && !supportsCSSVars && !presence && isHydrated && (import_constants2.isServer || state.unmounted === !0) && (isAnimated = !1), willBeAnimated && !stateRef.current.hasAnimated && (stateRef.current.hasAnimated = !0);
         let componentClassName = props.asChild ? "" : props.componentName ? `is_${props.componentName}` : defaultComponentClassName, hasTextAncestor = !!(import_constants2.isWeb && isText && componentContext.inText), isDisabled = props.disabled ?? ((_c = props.accessibilityState) == null ? void 0 : _c.disabled);
-        time && time`use-context`;
+        process.env.NODE_ENV === "development" && time && time`use-context`;
         let element = import_constants2.isWeb && (!Component || typeof Component == "string") && props.tag || Component, BaseTextComponent = BaseText || element || "span", BaseViewComponent = BaseView || element || (hasTextAncestor ? "span" : "div");
         AnimatedText = animationsConfig ? animationsConfig.Text : BaseTextComponent, AnimatedView = animationsConfig ? animationsConfig.View : BaseViewComponent;
         let elementType = isText ? (isAnimated ? AnimatedText : null) || BaseTextComponent : (isAnimated ? AnimatedView : null) || BaseViewComponent;
@@ -4006,11 +4690,11 @@ var require_createComponent_native = __commonJS({
           let presenceState = presence[2];
           if (presenceState) {
             let isEntering = state.unmounted, isExiting2 = !presenceState.isPresent, enterExitVariant = presenceState.enterExitVariant, enterVariant = enterExitVariant ?? presenceState.enterVariant, exitVariant = enterExitVariant ?? presenceState.exitVariant;
-            isEntering && enterVariant ? (debugProp === "verbose" && console.warn(`Animating presence ENTER "${enterVariant}"`), props[enterVariant] = !0) : isExiting2 && exitVariant && (debugProp === "verbose" && console.warn(`Animating presence EXIT "${enterVariant}"`), props[exitVariant] = !enterExitVariant);
+            isEntering && enterVariant ? (process.env.NODE_ENV === "development" && debugProp === "verbose" && console.warn(`Animating presence ENTER "${enterVariant}"`), props[enterVariant] = !0) : isExiting2 && exitVariant && (process.env.NODE_ENV === "development" && debugProp === "verbose" && console.warn(`Animating presence EXIT "${enterVariant}"`), props[exitVariant] = !enterExitVariant);
           }
         }
         let isAnimatedReactNative = hasAnimationProp && (animationsConfig == null ? void 0 : animationsConfig.isReactNative), isReactNative = !!(staticConfig.isReactNative || isAnimatedReactNative), shouldAvoidClasses = !!(!import_constants2.isWeb || isAnimated || !staticConfig.acceptsClassName || propsIn.disableClassName), shouldForcePseudo = !!propsIn.forceStyle, noClassNames = shouldAvoidClasses || shouldForcePseudo, disableThemeProp = props["data-disable-theme"], disableTheme = disableThemeProp && !willBeAnimated || isHOC;
-        time && time`theme-props`, props.themeShallow && (stateRef.current.themeShallow = !0);
+        process.env.NODE_ENV === "development" && time && time`theme-props`, props.themeShallow && (stateRef.current.themeShallow = !0);
         let themeStateProps = {
           name: props.theme,
           componentName,
@@ -4020,7 +4704,7 @@ var require_createComponent_native = __commonJS({
           shouldUpdate: () => stateRef.current.isListeningToTheme,
           debug: debugProp
         }, isExiting = !state.unmounted && (presence == null ? void 0 : presence[0]) === !1;
-        {
+        if (process.env.NODE_ENV === "development") {
           let id = (0, import_react.useId)();
           if (debugProp && debugProp !== "profile") {
             let name = `${componentName || (Component == null ? void 0 : Component.displayName) || (Component == null ? void 0 : Component.name) || "[Unnamed Component]"}`, type = isAnimatedReactNative ? "(animated)" : isReactNative ? "(rnw)" : "", dataIs = propsIn["data-is"] || "", banner = `${name}${dataIs ? ` ${dataIs}` : ""} ${type} id ${id}`;
@@ -4047,17 +4731,17 @@ var require_createComponent_native = __commonJS({
             }), console.groupEnd());
           }
         }
-        time && time`pre-theme-media`;
+        process.env.NODE_ENV === "development" && time && time`pre-theme-media`;
         let [themeState, theme] = (0, import_useTheme.useThemeWithState)(themeStateProps);
         elementType = Component || elementType;
         let isStringElement = typeof elementType == "string";
-        time && time`theme`;
+        process.env.NODE_ENV === "development" && time && time`theme`;
         let mediaState2 = (0, import_useMedia.useMedia)(
           // @ts-ignore, we just pass a stable object so we can get it later with
           // should match to the one used in `setMediaShouldUpdate` below
           stateRef
         );
-        time && time`media`, (0, import_createVariable.setDidGetVariableValue)(!1);
+        process.env.NODE_ENV === "development" && time && time`media`, (0, import_createVariable.setDidGetVariableValue)(!1);
         let resolveVariablesAs = (
           // if HOC + mounted + has animation prop, resolve as value so it passes non-variable to child
           isAnimated && !supportsCSSVars || isHOC && state.unmounted == !1 && hasAnimationProp ? "value" : "auto"
@@ -4080,14 +4764,14 @@ var require_createComponent_native = __commonJS({
           elementType,
           debugProp
         );
-        props.group && props.untilMeasured === "hide" && !stateRef.current.hasMeasured && (splitStyles.style.opacity = 0), time && time`split-styles`, stateRef.current.isListeningToTheme = splitStyles.dynamicThemeAccess;
+        props.group && props.untilMeasured === "hide" && !stateRef.current.hasMeasured && (splitStyles.style.opacity = 0), process.env.NODE_ENV === "development" && time && time`split-styles`, stateRef.current.isListeningToTheme = splitStyles.dynamicThemeAccess;
         let isMediaArray = splitStyles.hasMedia && Array.isArray(splitStyles.hasMedia), shouldListenForMedia = (0, import_createVariable.didGetVariableValue)() || isMediaArray || noClassNames && splitStyles.hasMedia === !0, mediaListeningKeys = isMediaArray ? splitStyles.hasMedia : null;
         (0, import_useMedia.setMediaShouldUpdate)(stateRef, {
           enabled: shouldListenForMedia,
           keys: mediaListeningKeys
         });
         let isAnimatedReactNativeWeb = hasAnimationProp && isReactNative;
-        if (debugProp && debugProp !== "profile" && (console.groupCollapsed(">>>"), console.log("props in", propsIn, "mapped to", props, "in order", Object.keys(props)), console.log("splitStyles", splitStyles), console.log("media", { shouldListenForMedia, isMediaArray, mediaListeningKeys }), console.log("className", Object.values(splitStyles.classNames)), import_constants2.isClient && console.log("ref", hostRef, "(click to view)"), console.groupEnd(), debugProp === "break"))
+        if (process.env.NODE_ENV === "development" && debugProp && debugProp !== "profile" && (console.groupCollapsed(">>>"), console.log("props in", propsIn, "mapped to", props, "in order", Object.keys(props)), console.log("splitStyles", splitStyles), console.log("media", { shouldListenForMedia, isMediaArray, mediaListeningKeys }), console.log("className", Object.values(splitStyles.classNames)), import_constants2.isClient && console.log("ref", hostRef, "(click to view)"), console.groupEnd(), debugProp === "break"))
           debugger;
         let {
           viewProps: viewPropsIn,
@@ -4110,7 +4794,7 @@ var require_createComponent_native = __commonJS({
             hostRef,
             staticConfig
           });
-          isAnimated && animations && (animationStyles = animations.style), time && time`animations`;
+          isAnimated && animations && (animationStyles = animations.style), process.env.NODE_ENV === "development" && time && time`animations`;
         }
         let {
           asChild,
@@ -4138,11 +4822,11 @@ var require_createComponent_native = __commonJS({
           defaultVariants,
           ...nonTamaguiProps
         } = viewPropsIn;
-        props.untilMeasured && !props.group && console.warn(
+        process.env.NODE_ENV === "development" && props.untilMeasured && !props.group && console.warn(
           `You set the untilMeasured prop without setting group. This doesn't work, be sure to set untilMeasured on the parent that sets group, not the children that use the $group- prop.
 
 If you meant to do this, you can disable this warning - either change untilMeasured and group at the same time, or do group={conditional ? 'name' : undefined}`
-        ), time && time`destructure`;
+        ), process.env.NODE_ENV === "development" && time && time`destructure`;
         let disabled = ((_d = props.accessibilityState) == null ? void 0 : _d.disabled) || // @ts-expect-error (comes from core)
         props.accessibilityDisabled, viewProps = nonTamaguiProps;
         isHOC && _themeProp && (viewProps.theme = _themeProp), groupName && (nonTamaguiProps.onLayout = (0, import_helpers.composeEventHandlers)(
@@ -4154,12 +4838,12 @@ If you meant to do this, you can disable this warning - either change untilMeasu
           }
         )), viewProps = nonTamaguiProps;
         let composedRef = (0, import_compose_refs.useComposedRefs)(hostRef, forwardedRef);
-        viewProps.ref = composedRef, !isReactNative && !isText && import_constants2.isWeb && !isHOC && import_react.Children.toArray(props.children).forEach((item) => {
+        viewProps.ref = composedRef, process.env.NODE_ENV === "development" && !isReactNative && !isText && import_constants2.isWeb && !isHOC && import_react.Children.toArray(props.children).forEach((item) => {
           typeof item == "string" && item !== `
 ` && console.error(
             `Unexpected text node: ${item}. A text node cannot be a child of a <View>.`
           );
-        }), time && time`events-hooks`;
+        }), process.env.NODE_ENV === "development" && time && time`events-hooks`;
         let unPress = () => setStateShallow({
           press: !1,
           pressIn: !1
@@ -4212,7 +4896,7 @@ If you meant to do this, you can disable this warning - either change untilMeasu
         let fontFamilyClassName = fontFamily ? `font_${fontFamily}` : "", style = avoidAnimationStyle ? splitStyles.style : animationStyles || splitStyles.style, className;
         viewProps.style = style;
         let runtimePressStyle = !disabled && noClassNames && (pseudos == null ? void 0 : pseudos.pressStyle), attachPress = !!(groupName || runtimePressStyle || onPress || onPressOut || onPressIn || onLongPress || onClick), runtimeHoverStyle = !disabled && noClassNames && (pseudos == null ? void 0 : pseudos.hoverStyle), isHoverable = import_constants2.isWeb && !!(groupName || runtimeHoverStyle || onHoverIn || onHoverOut || onMouseEnter || onMouseLeave), handlesPressEvents = !(import_constants2.isWeb || asChild), shouldAttach = !!(attachPress || isHoverable || noClassNames && "pressStyle" in props || import_constants2.isWeb && noClassNames && "hoverStyle" in props);
-        time && time`events-setup`;
+        process.env.NODE_ENV === "development" && time && time`events-setup`;
         let events = shouldAttach && !isDisabled && !asChild ? {
           onPressOut: attachPress ? (e) => {
             unPress(), onPressOut == null || onPressOut(e), onMouseUp == null || onMouseUp(e);
@@ -4249,9 +4933,9 @@ If you meant to do this, you can disable this warning - either change untilMeasu
           delayPressOut: viewProps.delayPressOut,
           focusable: viewProps.focusable ?? !0,
           minPressDuration: 0
-        }), time && time`events`, debugProp === "verbose" && console.log("events", { events, isHoverable, attachPress }), (_i = (_h = import_setupHooks.hooks).useEvents) == null || _i.call(_h, viewProps, events, splitStyles, setStateShallow);
+        }), process.env.NODE_ENV === "development" && time && time`events`, process.env.NODE_ENV === "development" && debugProp === "verbose" && console.log("events", { events, isHoverable, attachPress }), (_i = (_h = import_setupHooks.hooks).useEvents) == null || _i.call(_h, viewProps, events, splitStyles, setStateShallow);
         let direction = props.spaceDirection || "both";
-        time && time`hooks`;
+        process.env.NODE_ENV === "development" && time && time`hooks`;
         let content = !children || asChild ? children : spacedChildren({
           separator,
           children,
@@ -4265,8 +4949,8 @@ If you meant to do this, you can disable this warning - either change untilMeasu
           onLongPress,
           onPressIn,
           onPressOut
-        })), time && time`spaced-as-child`, // in test mode disable perf unwrapping so react-testing-library finds Text properly
-        elementType === BaseText || elementType === BaseView ? (viewProps.children = content, content = elementType.render(viewProps, viewProps.ref)) : content = (0, import_react.createElement)(elementType, viewProps, content), time && time`create-element`;
+        })), process.env.NODE_ENV === "development" && time && time`spaced-as-child`, // in test mode disable perf unwrapping so react-testing-library finds Text properly
+        process.env.NODE_ENV !== "test" && (elementType === BaseText || elementType === BaseView) ? (viewProps.children = content, content = elementType.render(viewProps, viewProps.ref)) : content = (0, import_react.createElement)(elementType, viewProps, content), process.env.NODE_ENV === "development" && time && time`create-element`;
         let subGroupContext = (0, import_react.useMemo)(() => {
           if (groupName)
             return {
@@ -4286,11 +4970,11 @@ If you meant to do this, you can disable this warning - either change untilMeasu
               }
             };
         }, [groupName]);
-        if (groupName && subGroupContext && (content = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ComponentContext.ComponentContext.Provider, { groups: subGroupContext, children: content })), time && time`group-context`, content = disableThemeProp ? content : (0, import_Theme.useThemedChildren)(themeState, content, themeStateProps), time && time`themed-children`, props.debug === "visualize" && (content = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ThemeDebug.ThemeDebug, { themeState, themeProps: props, children: content })), overriddenContextProps) {
+        if (groupName && subGroupContext && (content = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ComponentContext.ComponentContext.Provider, { groups: subGroupContext, children: content })), process.env.NODE_ENV === "development" && time && time`group-context`, content = disableThemeProp ? content : (0, import_Theme.useThemedChildren)(themeState, content, themeStateProps), process.env.NODE_ENV === "development" && time && time`themed-children`, process.env.NODE_ENV === "development" && props.debug === "visualize" && (content = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_ThemeDebug.ThemeDebug, { themeState, themeProps: props, children: content })), overriddenContextProps) {
           let Provider = staticConfig.context.Provider;
           content = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(Provider, { ...contextValue, ...overriddenContextProps, children: content });
         }
-        if (debugProp && debugProp !== "profile") {
+        if (process.env.NODE_ENV === "development" && debugProp && debugProp !== "profile") {
           console.groupCollapsed(`render <${typeof elementType == "string" ? elementType : "Component"} /> with props`);
           try {
             console.log("viewProps", viewProps), console.log("viewPropsOrder", Object.keys(viewProps));
@@ -4329,7 +5013,7 @@ If you meant to do this, you can disable this warning - either change untilMeasu
           }
           console.groupEnd(), console.groupEnd();
         }
-        return time && (time`rest`, globalThis.willPrint || (globalThis.willPrint = !0, setTimeout(() => {
+        return process.env.NODE_ENV === "development" && time && (time`rest`, globalThis.willPrint || (globalThis.willPrint = !0, setTimeout(() => {
           delete globalThis.willPrint, time.print(), time = null;
         }, 50))), content;
       });
@@ -4450,7 +5134,7 @@ If you meant to do this, you can disable this warning - either change untilMeasu
           })
         ));
       }
-      return props.debug && console.log("  Spaced children", final, props), final;
+      return process.env.NODE_ENV === "development" && props.debug && console.log("  Spaced children", final, props), final;
     }
     function createSpacer({ key, direction, space, spaceFlex }) {
       return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
@@ -4557,7 +5241,7 @@ var require_createVariables_native = __commonJS({
       createVariables: () => createVariables
     });
     module2.exports = __toCommonJS2(createVariables_exports);
-    var import_helpers = require_index_native3(), import_createVariable = require_createVariable_native(), cache = /* @__PURE__ */ new WeakMap(), createVariables = (tokens, parentPath = "", isFont = !1) => {
+    var import_helpers = require_index_native4(), import_createVariable = require_createVariable_native(), cache = /* @__PURE__ */ new WeakMap(), createVariables = (tokens, parentPath = "", isFont = !1) => {
       if (cache.has(tokens))
         return tokens;
       let res = {}, i = 0;
@@ -4853,17 +5537,19 @@ var require_createTamagui_native = __commonJS({
       createTamagui: () => createTamagui
     });
     module2.exports = __toCommonJS2(createTamagui_exports);
-    var import_constants2 = require_index_native(), import_config = require_config_native(), import_createVariables = require_createVariables_native(), import_getThemeCSSRules = require_getThemeCSSRules_native(), import_insertStyleRule = require_insertStyleRule_native(), import_proxyThemeToParents = require_proxyThemeToParents_native(), import_registerCSSVariable = require_registerCSSVariable_native(), import_themes = require_themes_native(), import_useMedia = require_useMedia_native(), import_insertFont = require_insertFont_native(), import_Tamagui = require_Tamagui_native(), createdConfigs = /* @__PURE__ */ new WeakMap();
+    var import_constants2 = require_index_native2(), import_config = require_config_native(), import_createVariables = require_createVariables_native(), import_getThemeCSSRules = require_getThemeCSSRules_native(), import_insertStyleRule = require_insertStyleRule_native(), import_proxyThemeToParents = require_proxyThemeToParents_native(), import_registerCSSVariable = require_registerCSSVariable_native(), import_themes = require_themes_native(), import_useMedia = require_useMedia_native(), import_insertFont = require_insertFont_native(), import_Tamagui = require_Tamagui_native(), createdConfigs = /* @__PURE__ */ new WeakMap();
     function createTamagui(configIn) {
       var _a;
       if (createdConfigs.has(configIn))
         return configIn;
-      if (!configIn.tokens)
-        throw new Error("Must define tokens");
-      if (!configIn.themes)
-        throw new Error("Must define themes");
-      if (!configIn.fonts)
-        throw new Error("Must define fonts");
+      if (process.env.NODE_ENV === "development") {
+        if (!configIn.tokens)
+          throw new Error("Must define tokens");
+        if (!configIn.themes)
+          throw new Error("Must define themes");
+        if (!configIn.fonts)
+          throw new Error("Must define fonts");
+      }
       let tokens = (0, import_createVariables.createVariables)(configIn.tokens), tokensParsed = {}, tokensMerged = {};
       for (let cat in tokens) {
         tokensParsed[cat] = {}, tokensMerged[cat] = {};
@@ -4893,7 +5579,7 @@ var require_createTamagui_native = __commonJS({
           for (let key in tokens)
             for (let skey in tokens[key]) {
               let variable = tokens[key][skey];
-              if (specificTokens[`$${key}.${skey}`] = variable, typeof variable > "u")
+              if (specificTokens[`$${key}.${skey}`] = variable, process.env.NODE_ENV === "development" && typeof variable > "u")
                 throw new Error(
                   `No value for tokens.${key}.${skey}:
 ${JSON.stringify(
@@ -4917,7 +5603,7 @@ ${JSON.stringify(
                 language
               };
             }
-            let sep = configIn.cssStyleSeparator || " ";
+            let sep = process.env.NODE_ENV === "development" ? configIn.cssStyleSeparator || " " : "";
             if (cssRuleSets.push(declarationsToRuleSet2(declarations)), fontDeclarations)
               for (let key in fontDeclarations) {
                 let { name, declarations: declarations2, language = "default" } = fontDeclarations[key], fontSelector = `.font_${name}`, langSelector = `:root .t_lang-${name}-${language} ${fontSelector}`, selectors = language === "default" ? ` ${fontSelector}, ${langSelector}` : langSelector, specificRuleSet = declarationsToRuleSet2(declarations2, selectors);
@@ -4986,7 +5672,7 @@ ${runtimeStyles}`;
         // const tokens = [...getToken(tokens.size[0])]
         // .spacer-sm + ._dsp_contents._dsp-sm-hidden { margin-left: -var(--${}) }
       };
-      return (0, import_useMedia.configureMedia)(config), (0, import_config.setConfig)(config), import_config.configListeners.size && (import_config.configListeners.forEach((cb) => cb(config)), import_config.configListeners.clear()), createdConfigs.set(config, !0), (_a = process.env.DEBUG) != null && _a.startsWith("tamagui") && console.log("Tamagui config:", config), globalThis.Tamagui || (globalThis.Tamagui = import_Tamagui.Tamagui), config;
+      return (0, import_useMedia.configureMedia)(config), (0, import_config.setConfig)(config), import_config.configListeners.size && (import_config.configListeners.forEach((cb) => cb(config)), import_config.configListeners.clear()), createdConfigs.set(config, !0), process.env.NODE_ENV === "development" && ((_a = process.env.DEBUG) != null && _a.startsWith("tamagui") && console.log("Tamagui config:", config), globalThis.Tamagui || (globalThis.Tamagui = import_Tamagui.Tamagui)), config;
     }
     function getThemesDeduped(themes) {
       let dedupedThemes = [], existing = /* @__PURE__ */ new Map();
@@ -5142,7 +5828,7 @@ var require_styled_native = __commonJS({
     module2.exports = __toCommonJS2(styled_exports);
     var import_createComponent = require_createComponent_native(), import_mergeVariants = require_mergeVariants_native(), import_setupReactNative = require_setupReactNative_native();
     function styled(ComponentIn, options, staticExtractionOptions) {
-      if (!ComponentIn)
+      if (process.env.NODE_ENV !== "production" && !ComponentIn)
         throw new Error("No component given to styled()");
       let parentStaticConfig = ComponentIn.staticConfig, isPlainStyledComponent = !!parentStaticConfig && !(parentStaticConfig.isReactNative || parentStaticConfig.isHOC), Component = parentStaticConfig != null && parentStaticConfig.isHOC && !(parentStaticConfig != null && parentStaticConfig.isStyledHOC) || isPlainStyledComponent ? ComponentIn : (parentStaticConfig == null ? void 0 : parentStaticConfig.Component) || ComponentIn, reactNativeConfig = (0, import_setupReactNative.getReactNativeConfig)(Component), isReactNative = !!(reactNativeConfig || staticExtractionOptions != null && staticExtractionOptions.isReactNative || parentStaticConfig != null && parentStaticConfig.isReactNative || (0, import_setupReactNative.getReactNativeConfig)(parentStaticConfig == null ? void 0 : parentStaticConfig.Component)), staticConfigProps = (() => {
         if (options) {
@@ -5192,7 +5878,7 @@ var require_styled_native = __commonJS({
 });
 
 // ../web/dist/cjs/types.native.js
-var require_types_native2 = __commonJS({
+var require_types_native3 = __commonJS({
   "../web/dist/cjs/types.native.js"(exports, module2) {
     "use strict";
     var __defProp2 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __hasOwnProp2 = Object.prototype.hasOwnProperty, __copyProps2 = (to, from, except, desc) => {
@@ -5370,7 +6056,7 @@ var require_useThemeName_native = __commonJS({
       useThemeName: () => useThemeName
     });
     module2.exports = __toCommonJS2(useThemeName_exports);
-    var import_constants2 = require_index_native(), import_react = require("react"), import_ThemeManagerContext = require_ThemeManagerContext_native();
+    var import_constants2 = require_index_native2(), import_react = require("react"), import_ThemeManagerContext = require_ThemeManagerContext_native();
     function useThemeName(opts) {
       let manager = (0, import_react.useContext)(import_ThemeManagerContext.ThemeManagerContext), [name, setName] = (0, import_react.useState)((manager == null ? void 0 : manager.state.name) || "");
       return (0, import_constants2.useIsomorphicLayoutEffect)(() => {
@@ -5465,7 +6151,7 @@ var require_useIsTouchDevice_native = __commonJS({
       useIsTouchDevice: () => useIsTouchDevice
     });
     module2.exports = __toCommonJS2(useIsTouchDevice_exports);
-    var import_constants2 = require_index_native(), import_use_did_finish_ssr = require_index_native6(), useIsTouchDevice = () => import_constants2.isWeb ? (0, import_use_did_finish_ssr.useDidFinishSSR)() ? import_constants2.isTouchable : !1 : !0;
+    var import_constants2 = require_index_native2(), import_use_did_finish_ssr = require_index_native7(), useIsTouchDevice = () => import_constants2.isWeb ? (0, import_use_did_finish_ssr.useDidFinishSSR)() ? import_constants2.isTouchable : !1 : !0;
   }
 });
 
@@ -5513,7 +6199,7 @@ var require_Stack_native = __commonJS({
       Stack: () => Stack2
     });
     module2.exports = __toCommonJS2(Stack_exports);
-    var import_helpers = require_index_native3(), import_constants2 = require_constants_native(), import_createComponent = require_createComponent_native(), Stack2 = (0, import_createComponent.createComponent)({
+    var import_helpers = require_index_native4(), import_constants2 = require_constants_native(), import_createComponent = require_createComponent_native(), Stack2 = (0, import_createComponent.createComponent)({
       acceptsClassName: !0,
       defaultProps: import_constants2.stackDefaultStyles,
       validStyles: import_helpers.validStyles
@@ -5538,7 +6224,7 @@ var require_View_native = __commonJS({
       View: () => View
     });
     module2.exports = __toCommonJS2(View_exports);
-    var import_helpers = require_index_native3(), import_createComponent = require_createComponent_native(), View = (0, import_createComponent.createComponent)({
+    var import_helpers = require_index_native4(), import_createComponent = require_createComponent_native(), View = (0, import_createComponent.createComponent)({
       acceptsClassName: !0,
       defaultProps: {
         display: "flex"
@@ -5565,7 +6251,7 @@ var require_Text_native = __commonJS({
       Text: () => Text2
     });
     module2.exports = __toCommonJS2(Text_exports);
-    var import_helpers = require_index_native3(), import_createComponent = require_createComponent_native(), Text2 = (0, import_createComponent.createComponent)({
+    var import_helpers = require_index_native4(), import_createComponent = require_createComponent_native(), Text2 = (0, import_createComponent.createComponent)({
       acceptsClassName: !0,
       isText: !0,
       defaultProps: {
@@ -5612,7 +6298,7 @@ var require_ThemeProvider_native = __commonJS({
       ThemeProvider: () => ThemeProvider
     });
     module2.exports = __toCommonJS2(ThemeProvider_exports);
-    var import_constants2 = require_index_native(), import_react = require("react"), import_constants22 = require_constants_native(), import_Theme = require_Theme_native(), import_jsx_runtime = require("react/jsx-runtime"), ThemeProvider = (props) => (import_constants2.isClient && (0, import_react.useLayoutEffect)(() => {
+    var import_constants2 = require_index_native2(), import_react = require("react"), import_constants22 = require_constants_native(), import_Theme = require_Theme_native(), import_jsx_runtime = require("react/jsx-runtime"), ThemeProvider = (props) => (import_constants2.isClient && (0, import_react.useLayoutEffect)(() => {
       if (props.disableRootThemeClass)
         return;
       let cn = `${import_constants22.THEME_CLASSNAME_PREFIX}${props.defaultTheme}`, target = props.themeClassNameOnRoot ? document.documentElement : document.body;
@@ -5680,14 +6366,14 @@ var require_TamaguiProvider_native = __commonJS({
       TamaguiProvider: () => TamaguiProvider
     });
     module2.exports = __toCommonJS2(TamaguiProvider_exports);
-    var import_constants2 = require_index_native(), React2 = __toESM2(require("react")), import_ComponentContext = require_ComponentContext_native(), import_useMedia = require_useMedia_native(), import_ThemeProvider = require_ThemeProvider_native(), import_jsx_runtime = require("react/jsx-runtime");
+    var import_constants2 = require_index_native2(), React = __toESM2(require("react")), import_ComponentContext = require_ComponentContext_native(), import_useMedia = require_useMedia_native(), import_ThemeProvider = require_ThemeProvider_native(), import_jsx_runtime = require("react/jsx-runtime");
     function TamaguiProvider({
       children,
       disableInjectCSS,
       config,
       ...themePropsProvider
     }) {
-      return import_constants2.isWeb && import_constants2.isServer || (0, import_useMedia.useMediaListeners)(config), import_constants2.isClient && React2.useLayoutEffect(() => {
+      return import_constants2.isWeb && import_constants2.isServer || (0, import_useMedia.useMediaListeners)(config), import_constants2.isClient && React.useLayoutEffect(() => {
         if (document.documentElement.classList.contains("t_unmounted") && document.documentElement.classList.remove("t_unmounted"), disableInjectCSS)
           return;
         let style = document.createElement("style");
@@ -5790,7 +6476,7 @@ var require_useEvent_native = __commonJS({
 });
 
 // ../use-event/dist/cjs/index.native.js
-var require_index_native7 = __commonJS({
+var require_index_native8 = __commonJS({
   "../use-event/dist/cjs/index.native.js"(exports, module2) {
     "use strict";
     var __defProp2 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __hasOwnProp2 = Object.prototype.hasOwnProperty, __copyProps2 = (to, from, except, desc) => {
@@ -5806,7 +6492,7 @@ var require_index_native7 = __commonJS({
 });
 
 // ../web/dist/cjs/index.native.js
-var require_index_native8 = __commonJS({
+var require_index_native9 = __commonJS({
   "../web/dist/cjs/index.native.js"(exports, module2) {
     "use strict";
     var __defProp2 = Object.defineProperty, __getOwnPropDesc2 = Object.getOwnPropertyDescriptor, __getOwnPropNames2 = Object.getOwnPropertyNames, __hasOwnProp2 = Object.prototype.hasOwnProperty, __export2 = (target, all) => {
@@ -5846,7 +6532,7 @@ var require_index_native8 = __commonJS({
     __reExport2(src_exports2, require_insertFont_native(), module2.exports);
     __reExport2(src_exports2, require_styled_native(), module2.exports);
     __reExport2(src_exports2, require_setupReactNative_native(), module2.exports);
-    __reExport2(src_exports2, require_types_native2(), module2.exports);
+    __reExport2(src_exports2, require_types_native3(), module2.exports);
     __reExport2(src_exports2, require_GetRef_native(), module2.exports);
     var import_config = require_config_native();
     __reExport2(src_exports2, require_constants_native(), module2.exports);
@@ -5888,11 +6574,11 @@ var require_index_native8 = __commonJS({
     __reExport2(src_exports2, require_FontLanguage_native(), module2.exports);
     __reExport2(src_exports2, require_TamaguiProvider_native(), module2.exports);
     __reExport2(src_exports2, require_AnimationDriverProvider_native(), module2.exports);
-    __reExport2(src_exports2, require_index_native6(), module2.exports);
     __reExport2(src_exports2, require_index_native7(), module2.exports);
-    __reExport2(src_exports2, require_index_native5(), module2.exports);
-    __reExport2(src_exports2, require_index_native3(), module2.exports);
-    __reExport2(src_exports2, require_index_native(), module2.exports);
+    __reExport2(src_exports2, require_index_native8(), module2.exports);
+    __reExport2(src_exports2, require_index_native6(), module2.exports);
+    __reExport2(src_exports2, require_index_native4(), module2.exports);
+    __reExport2(src_exports2, require_index_native2(), module2.exports);
     __reExport2(src_exports2, require_setupHooks_native(), module2.exports);
   }
 });
@@ -5947,525 +6633,14 @@ var idFn_default, init_idFn = __esm({
   }
 });
 
-// src/native.ts
-var native_exports = {};
-__export(native_exports, {
-  Stack: () => Stack,
-  Text: () => Text
-});
-module.exports = __toCommonJS(native_exports);
-
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
   Stack: () => Stack,
   Text: () => Text
 });
-
-// ../react-native-use-responder-events/dist/esm/useResponderEvents.js
-var React = __toESM(require("react"));
-
-// ../react-native-use-responder-events/dist/esm/utils.js
-var keyName = "__reactResponderId", canUseDOM = !!(typeof window < "u" && window.document && window.document.createElement), getBoundingClientRect = (node) => {
-  if (node && node.nodeType === 1 && node.getBoundingClientRect)
-    return node.getBoundingClientRect();
-};
-function getEventPath(domEvent) {
-  var _a;
-  if (domEvent.type === "selectionchange") {
-    let target = (_a = window.getSelection()) == null ? void 0 : _a.anchorNode;
-    return composedPathFallback(target);
-  } else
-    return domEvent.composedPath != null ? domEvent.composedPath() : composedPathFallback(domEvent.target);
-}
-function composedPathFallback(target) {
-  let path = [];
-  for (; target != null && target !== document.body; )
-    path.push(target), target = target.parentNode;
-  return path;
-}
-function getResponderId(node) {
-  return node != null ? node[keyName] : null;
-}
-function setResponderId(node, id) {
-  node != null && (node[keyName] = id);
-}
-function getResponderPaths(domEvent) {
-  let idPath = [], nodePath = [], eventPath = getEventPath(domEvent);
-  for (let i = 0; i < eventPath.length; i++) {
-    let node = eventPath[i], id = getResponderId(node);
-    id != null && (idPath.push(id), nodePath.push(node));
-  }
-  return { idPath, nodePath };
-}
-function getLowestCommonAncestor(pathA, pathB) {
-  let pathALength = pathA.length, pathBLength = pathB.length;
-  if (
-    // If either path is empty
-    pathALength === 0 || pathBLength === 0 || // If the last elements aren't the same there can't be a common ancestor
-    // that is connected to the responder system
-    pathA[pathALength - 1] !== pathB[pathBLength - 1]
-  )
-    return null;
-  let itemA = pathA[0], indexA = 0, itemB = pathB[0], indexB = 0;
-  pathALength - pathBLength > 0 && (indexA = pathALength - pathBLength, itemA = pathA[indexA], pathALength = pathBLength), pathBLength - pathALength > 0 && (indexB = pathBLength - pathALength, itemB = pathB[indexB], pathBLength = pathALength);
-  let depth = pathALength;
-  for (; depth--; ) {
-    if (itemA === itemB)
-      return itemA;
-    itemA = pathA[indexA++], itemB = pathB[indexB++];
-  }
-  return null;
-}
-function hasTargetTouches(target, touches) {
-  if (!touches || touches.length === 0)
-    return !1;
-  for (let i = 0; i < touches.length; i++) {
-    let node = touches[i].target;
-    if (node != null && target.contains(node))
-      return !0;
-  }
-  return !1;
-}
-function hasValidSelection(domEvent) {
-  return domEvent.type === "selectionchange" ? isSelectionValid() : domEvent.type === "select";
-}
-function isPrimaryPointerDown(domEvent) {
-  let { altKey, button, buttons, ctrlKey, type } = domEvent, isTouch = type === "touchstart" || type === "touchmove", isPrimaryMouseDown = type === "mousedown" && (button === 0 || buttons === 1), isPrimaryMouseMove = type === "mousemove" && buttons === 1, noModifiers = altKey === !1 && ctrlKey === !1;
-  return !!(isTouch || isPrimaryMouseDown && noModifiers || isPrimaryMouseMove && noModifiers);
-}
-function isSelectionValid() {
-  let selection = window.getSelection();
-  if (!selection)
-    return !1;
-  let string = selection.toString(), anchorNode = selection.anchorNode, focusNode = selection.focusNode, isTextNode = anchorNode && anchorNode.nodeType === window.Node.TEXT_NODE || focusNode && focusNode.nodeType === window.Node.TEXT_NODE;
-  return string.length >= 1 && string !== `
-` && !!isTextNode;
-}
-
-// ../react-native-use-responder-events/dist/esm/createResponderEvent.js
-var emptyFunction = () => {
-}, emptyObject = {}, emptyArray = [];
-function normalizeIdentifier(identifier) {
-  return identifier > 20 ? identifier % 20 : identifier;
-}
-function createResponderEvent(domEvent, responderTouchHistoryStore2) {
-  let rect, propagationWasStopped = !1, changedTouches, touches, domEventChangedTouches = domEvent.changedTouches, domEventType = domEvent.type, metaKey = domEvent.metaKey === !0, shiftKey = domEvent.shiftKey === !0, force = (domEventChangedTouches == null ? void 0 : domEventChangedTouches[0].force) || 0, identifier = normalizeIdentifier((domEventChangedTouches == null ? void 0 : domEventChangedTouches[0].identifier) || 0), clientX = (domEventChangedTouches == null ? void 0 : domEventChangedTouches[0].clientX) || domEvent.clientX, clientY = (domEventChangedTouches == null ? void 0 : domEventChangedTouches[0].clientY) || domEvent.clientY, pageX = (domEventChangedTouches == null ? void 0 : domEventChangedTouches[0].pageX) || domEvent.pageX, pageY = (domEventChangedTouches == null ? void 0 : domEventChangedTouches[0].pageY) || domEvent.pageY, preventDefault = typeof domEvent.preventDefault == "function" ? domEvent.preventDefault.bind(domEvent) : emptyFunction, timestamp = domEvent.timeStamp;
-  function normalizeTouches(touches2) {
-    return Array.prototype.slice.call(touches2).map((touch) => ({
-      force: touch.force,
-      identifier: normalizeIdentifier(touch.identifier),
-      get locationX() {
-        return locationX(touch.clientX);
-      },
-      get locationY() {
-        return locationY(touch.clientY);
-      },
-      pageX: touch.pageX,
-      pageY: touch.pageY,
-      target: touch.target,
-      timestamp
-    }));
-  }
-  if (domEventChangedTouches != null)
-    changedTouches = normalizeTouches(domEventChangedTouches), touches = normalizeTouches(domEvent.touches);
-  else {
-    let emulatedTouches = [
-      {
-        force,
-        identifier,
-        get locationX() {
-          return locationX(clientX);
-        },
-        get locationY() {
-          return locationY(clientY);
-        },
-        pageX,
-        pageY,
-        target: domEvent.target,
-        timestamp
-      }
-    ];
-    changedTouches = emulatedTouches, touches = domEventType === "mouseup" || domEventType === "dragstart" ? emptyArray : emulatedTouches;
-  }
-  let responderEvent = {
-    bubbles: !0,
-    cancelable: !0,
-    // `currentTarget` is set before dispatch
-    currentTarget: null,
-    defaultPrevented: domEvent.defaultPrevented,
-    dispatchConfig: emptyObject,
-    eventPhase: domEvent.eventPhase,
-    isDefaultPrevented() {
-      return domEvent.defaultPrevented;
-    },
-    isPropagationStopped() {
-      return propagationWasStopped;
-    },
-    isTrusted: domEvent.isTrusted,
-    nativeEvent: {
-      altKey: !1,
-      ctrlKey: !1,
-      metaKey,
-      shiftKey,
-      changedTouches,
-      force,
-      identifier,
-      get locationX() {
-        return locationX(clientX);
-      },
-      get locationY() {
-        return locationY(clientY);
-      },
-      pageX,
-      pageY,
-      target: domEvent.target,
-      timestamp,
-      touches,
-      type: domEventType
-    },
-    persist: emptyFunction,
-    preventDefault,
-    stopPropagation() {
-      propagationWasStopped = !0;
-    },
-    target: domEvent.target,
-    timeStamp: timestamp,
-    touchHistory: responderTouchHistoryStore2.touchHistory
-  };
-  function locationX(x) {
-    if (rect = rect || getBoundingClientRect(responderEvent.currentTarget), rect)
-      return x - rect.left;
-  }
-  function locationY(y) {
-    if (rect = rect || getBoundingClientRect(responderEvent.currentTarget), rect)
-      return y - rect.top;
-  }
-  return responderEvent;
-}
-
-// ../react-native-use-responder-events/dist/esm/types.js
-var MOUSE_DOWN = "mousedown", MOUSE_MOVE = "mousemove", MOUSE_UP = "mouseup", MOUSE_CANCEL = "dragstart", TOUCH_START = "touchstart", TOUCH_MOVE = "touchmove", TOUCH_END = "touchend", TOUCH_CANCEL = "touchcancel", SCROLL = "scroll", SELECT = "select", SELECTION_CHANGE = "selectionchange";
-function isStartish(eventType) {
-  return eventType === TOUCH_START || eventType === MOUSE_DOWN;
-}
-function isMoveish(eventType) {
-  return eventType === TOUCH_MOVE || eventType === MOUSE_MOVE;
-}
-function isEndish(eventType) {
-  return eventType === TOUCH_END || eventType === MOUSE_UP || isCancelish(eventType);
-}
-function isCancelish(eventType) {
-  return eventType === TOUCH_CANCEL || eventType === MOUSE_CANCEL;
-}
-function isScroll(eventType) {
-  return eventType === SCROLL;
-}
-function isSelectionChange(eventType) {
-  return eventType === SELECT || eventType === SELECTION_CHANGE;
-}
-
-// ../react-native-use-responder-events/dist/esm/ResponderTouchHistoryStore.js
-var MAX_TOUCH_BANK = 20;
-function timestampForTouch(touch) {
-  return touch.timeStamp || touch.timestamp;
-}
-function createTouchRecord(touch) {
-  return {
-    touchActive: !0,
-    startPageX: touch.pageX,
-    startPageY: touch.pageY,
-    startTimeStamp: timestampForTouch(touch),
-    currentPageX: touch.pageX,
-    currentPageY: touch.pageY,
-    currentTimeStamp: timestampForTouch(touch),
-    previousPageX: touch.pageX,
-    previousPageY: touch.pageY,
-    previousTimeStamp: timestampForTouch(touch)
-  };
-}
-function resetTouchRecord(touchRecord, touch) {
-  touchRecord.touchActive = !0, touchRecord.startPageX = touch.pageX, touchRecord.startPageY = touch.pageY, touchRecord.startTimeStamp = timestampForTouch(touch), touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchRecord.previousPageX = touch.pageX, touchRecord.previousPageY = touch.pageY, touchRecord.previousTimeStamp = timestampForTouch(touch);
-}
-function getTouchIdentifier({ identifier }) {
-  return identifier == null && console.error("Touch object is missing identifier."), identifier > MAX_TOUCH_BANK && console.error(
-    "Touch identifier %s is greater than maximum supported %s which causes performance issues backfilling array locations for all of the indices.",
-    identifier,
-    MAX_TOUCH_BANK
-  ), identifier;
-}
-function recordTouchStart(touch, touchHistory) {
-  let identifier = getTouchIdentifier(touch), touchRecord = touchHistory.touchBank[identifier];
-  touchRecord ? resetTouchRecord(touchRecord, touch) : touchHistory.touchBank[identifier] = createTouchRecord(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
-}
-function recordTouchMove(touch, touchHistory) {
-  let touchRecord = touchHistory.touchBank[getTouchIdentifier(touch)];
-  touchRecord ? (touchRecord.touchActive = !0, touchRecord.previousPageX = touchRecord.currentPageX, touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.warn(
-    `Cannot record touch move without a touch start.
-`,
-    `Touch Move: ${printTouch(touch)}
-`,
-    `Touch Bank: ${printTouchBank(touchHistory)}`
-  );
-}
-function recordTouchEnd(touch, touchHistory) {
-  let touchRecord = touchHistory.touchBank[getTouchIdentifier(touch)];
-  touchRecord ? (touchRecord.touchActive = !1, touchRecord.previousPageX = touchRecord.currentPageX, touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.warn(
-    `Cannot record touch end without a touch start.
-`,
-    `Touch End: ${printTouch(touch)}
-`,
-    `Touch Bank: ${printTouchBank(touchHistory)}`
-  );
-}
-function printTouch(touch) {
-  return JSON.stringify({
-    identifier: touch.identifier,
-    pageX: touch.pageX,
-    pageY: touch.pageY,
-    timestamp: timestampForTouch(touch)
-  });
-}
-function printTouchBank(touchHistory) {
-  let { touchBank } = touchHistory, printed = JSON.stringify(touchBank.slice(0, MAX_TOUCH_BANK));
-  return touchBank.length > MAX_TOUCH_BANK && (printed += ` (original size: ${touchBank.length})`), printed;
-}
-var ResponderTouchHistoryStore = class {
-  _touchHistory = {
-    touchBank: [],
-    //Array<TouchRecord>
-    numberActiveTouches: 0,
-    // If there is only one active touch, we remember its location. This prevents
-    // us having to loop through all of the touches all the time in the most
-    // common case.
-    indexOfSingleActiveTouch: -1,
-    mostRecentTimeStamp: 0
-  };
-  recordTouchTrack(topLevelType, nativeEvent) {
-    var _a, _b;
-    let touchHistory = this._touchHistory;
-    if (isMoveish(topLevelType))
-      nativeEvent.changedTouches.forEach((touch) => recordTouchMove(touch, touchHistory));
-    else if (isStartish(topLevelType))
-      nativeEvent.changedTouches.forEach((touch) => recordTouchStart(touch, touchHistory)), touchHistory.numberActiveTouches = nativeEvent.touches.length, touchHistory.numberActiveTouches === 1 && (touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier);
-    else if (isEndish(topLevelType) && (nativeEvent.changedTouches.forEach((touch) => recordTouchEnd(touch, touchHistory)), touchHistory.numberActiveTouches = nativeEvent.touches.length, touchHistory.numberActiveTouches === 1)) {
-      let { touchBank } = touchHistory;
-      for (let i = 0; i < touchBank.length; i++)
-        if ((_a = touchBank[i]) != null && _a.touchActive) {
-          touchHistory.indexOfSingleActiveTouch = i;
-          break;
-        }
-      (_b = touchBank[touchHistory.indexOfSingleActiveTouch]) != null && _b.touchActive || console.error("Cannot find single active touch.");
-    }
-  }
-  get touchHistory() {
-    return this._touchHistory;
-  }
-};
-
-// ../react-native-use-responder-events/dist/esm/ResponderSystem.js
-var emptyObject2 = {}, startRegistration = [
-  "onStartShouldSetResponderCapture",
-  "onStartShouldSetResponder",
-  { bubbles: !0 }
-], moveRegistration = [
-  "onMoveShouldSetResponderCapture",
-  "onMoveShouldSetResponder",
-  { bubbles: !0 }
-], scrollRegistration = [
-  "onScrollShouldSetResponderCapture",
-  "onScrollShouldSetResponder",
-  { bubbles: !1 }
-], shouldSetResponderEvents = {
-  touchstart: startRegistration,
-  mousedown: startRegistration,
-  touchmove: moveRegistration,
-  mousemove: moveRegistration,
-  scroll: scrollRegistration
-}, emptyResponder = { id: null, idPath: null, node: null }, responderListenersMap = /* @__PURE__ */ new Map(), isEmulatingMouseEvents = !1, trackedTouchCount = 0, currentResponder = {
-  id: null,
-  node: null,
-  idPath: null
-}, responderTouchHistoryStore = new ResponderTouchHistoryStore();
-function changeCurrentResponder(responder) {
-  currentResponder = responder;
-}
-function getResponderConfig(id) {
-  return responderListenersMap.get(id) ?? emptyObject2;
-}
-function eventListener(domEvent) {
-  let eventType = domEvent.type, eventTarget = domEvent.target;
-  if (eventType === "touchstart" && (isEmulatingMouseEvents = !0), (eventType === "touchmove" || trackedTouchCount > 1) && (isEmulatingMouseEvents = !1), // Ignore browser emulated mouse events
-  eventType === "mousedown" && isEmulatingMouseEvents || eventType === "mousemove" && isEmulatingMouseEvents || // Ignore mousemove if a mousedown didn't occur first
-  eventType === "mousemove" && trackedTouchCount < 1)
-    return;
-  if (isEmulatingMouseEvents && eventType === "mouseup") {
-    trackedTouchCount === 0 && (isEmulatingMouseEvents = !1);
-    return;
-  }
-  let isStartEvent = isStartish(eventType) && isPrimaryPointerDown(domEvent), isMoveEvent = isMoveish(eventType), isEndEvent = isEndish(eventType), isScrollEvent = isScroll(eventType), isSelectionChangeEvent = isSelectionChange(eventType), responderEvent = createResponderEvent(domEvent, responderTouchHistoryStore);
-  (isStartEvent || isMoveEvent || isEndEvent) && (domEvent.touches ? trackedTouchCount = domEvent.touches.length : isStartEvent ? trackedTouchCount = 1 : isEndEvent && (trackedTouchCount = 0), responderTouchHistoryStore.recordTouchTrack(
-    eventType,
-    responderEvent.nativeEvent
-  ));
-  let eventPaths = getResponderPaths(domEvent), wasNegotiated = !1, wantsResponder;
-  if (isStartEvent || isMoveEvent || isScrollEvent && trackedTouchCount > 0) {
-    let currentResponderIdPath = currentResponder.idPath, eventIdPath = eventPaths.idPath;
-    if (currentResponderIdPath != null && eventIdPath != null) {
-      let lowestCommonAncestor = getLowestCommonAncestor(
-        currentResponderIdPath,
-        eventIdPath
-      );
-      if (lowestCommonAncestor != null) {
-        let index = eventIdPath.indexOf(lowestCommonAncestor) + (lowestCommonAncestor === currentResponder.id ? 1 : 0);
-        eventPaths = {
-          idPath: eventIdPath.slice(index),
-          nodePath: eventPaths.nodePath.slice(index)
-        };
-      } else
-        eventPaths = null;
-    }
-    eventPaths != null && (wantsResponder = findWantsResponder(eventPaths, domEvent, responderEvent), wantsResponder != null && (attemptTransfer(responderEvent, wantsResponder), wasNegotiated = !0));
-  }
-  if (currentResponder.id != null && currentResponder.node != null) {
-    let { id, node } = currentResponder, {
-      onResponderStart,
-      onResponderMove,
-      onResponderEnd,
-      onResponderRelease,
-      onResponderTerminate,
-      onResponderTerminationRequest
-    } = getResponderConfig(id);
-    if (responderEvent.bubbles = !1, responderEvent.cancelable = !1, responderEvent.currentTarget = node, isStartEvent)
-      onResponderStart != null && (responderEvent.dispatchConfig.registrationName = "onResponderStart", onResponderStart(responderEvent));
-    else if (isMoveEvent)
-      onResponderMove != null && (responderEvent.dispatchConfig.registrationName = "onResponderMove", onResponderMove(responderEvent));
-    else {
-      let isTerminateEvent = isCancelish(eventType) || // native context menu
-      eventType === "contextmenu" || // window blur
-      eventType === "blur" && eventTarget === window || // responder (or ancestors) blur
-      eventType === "blur" && eventTarget.contains(node) && domEvent.relatedTarget !== node || // native scroll without using a pointer
-      isScrollEvent && trackedTouchCount === 0 || // native scroll on node that is parent of the responder (allow siblings to scroll)
-      isScrollEvent && eventTarget.contains(node) && eventTarget !== node || // native select/selectionchange on node
-      isSelectionChangeEvent && hasValidSelection(domEvent), isReleaseEvent = isEndEvent && !isTerminateEvent && !hasTargetTouches(node, domEvent.touches);
-      if (isEndEvent && onResponderEnd != null && (responderEvent.dispatchConfig.registrationName = "onResponderEnd", onResponderEnd(responderEvent)), isReleaseEvent && (onResponderRelease != null && (responderEvent.dispatchConfig.registrationName = "onResponderRelease", onResponderRelease(responderEvent)), changeCurrentResponder(emptyResponder)), isTerminateEvent) {
-        let shouldTerminate = !0;
-        (eventType === "contextmenu" || eventType === "scroll" || eventType === "selectionchange") && (wasNegotiated ? shouldTerminate = !1 : onResponderTerminationRequest != null && (responderEvent.dispatchConfig.registrationName = "onResponderTerminationRequest", onResponderTerminationRequest(responderEvent) === !1 && (shouldTerminate = !1))), shouldTerminate && (onResponderTerminate != null && (responderEvent.dispatchConfig.registrationName = "onResponderTerminate", onResponderTerminate(responderEvent)), changeCurrentResponder(emptyResponder), isEmulatingMouseEvents = !1, trackedTouchCount = 0);
-      }
-    }
-  }
-}
-function findWantsResponder(eventPaths, domEvent, responderEvent) {
-  let shouldSetCallbacks = shouldSetResponderEvents[domEvent.type];
-  if (shouldSetCallbacks != null) {
-    let { idPath, nodePath } = eventPaths, shouldSetCallbackCaptureName = shouldSetCallbacks[0], shouldSetCallbackBubbleName = shouldSetCallbacks[1], { bubbles } = shouldSetCallbacks[2], check = function(id, node, callbackName) {
-      let shouldSetCallback = getResponderConfig(id)[callbackName];
-      if (shouldSetCallback != null && (responderEvent.currentTarget = node, shouldSetCallback(responderEvent) === !0)) {
-        let prunedIdPath = idPath.slice(idPath.indexOf(id));
-        return { id, node, idPath: prunedIdPath };
-      }
-    };
-    for (let i = idPath.length - 1; i >= 0; i--) {
-      let id = idPath[i], node = nodePath[i], result = check(id, node, shouldSetCallbackCaptureName);
-      if (result != null)
-        return result;
-      if (responderEvent.isPropagationStopped() === !0)
-        return;
-    }
-    if (bubbles)
-      for (let i = 0; i < idPath.length; i++) {
-        let id = idPath[i], node = nodePath[i], result = check(id, node, shouldSetCallbackBubbleName);
-        if (result != null)
-          return result;
-        if (responderEvent.isPropagationStopped() === !0)
-          return;
-      }
-    else {
-      let id = idPath[0], node = nodePath[0];
-      if (domEvent.target === node)
-        return check(id, node, shouldSetCallbackBubbleName);
-    }
-  }
-}
-function attemptTransfer(responderEvent, wantsResponder) {
-  let { id: currentId, node: currentNode } = currentResponder, { id, node } = wantsResponder, { onResponderGrant, onResponderReject } = getResponderConfig(id);
-  if (responderEvent.bubbles = !1, responderEvent.cancelable = !1, responderEvent.currentTarget = node, currentId == null)
-    onResponderGrant != null && (responderEvent.currentTarget = node, responderEvent.dispatchConfig.registrationName = "onResponderGrant", onResponderGrant(responderEvent)), changeCurrentResponder(wantsResponder);
-  else {
-    let { onResponderTerminate, onResponderTerminationRequest } = getResponderConfig(currentId), allowTransfer = !0;
-    onResponderTerminationRequest != null && (responderEvent.currentTarget = currentNode, responderEvent.dispatchConfig.registrationName = "onResponderTerminationRequest", onResponderTerminationRequest(responderEvent) === !1 && (allowTransfer = !1)), allowTransfer ? (onResponderTerminate != null && (responderEvent.currentTarget = currentNode, responderEvent.dispatchConfig.registrationName = "onResponderTerminate", onResponderTerminate(responderEvent)), onResponderGrant != null && (responderEvent.currentTarget = node, responderEvent.dispatchConfig.registrationName = "onResponderGrant", onResponderGrant(responderEvent)), changeCurrentResponder(wantsResponder)) : onResponderReject != null && (responderEvent.currentTarget = node, responderEvent.dispatchConfig.registrationName = "onResponderReject", onResponderReject(responderEvent));
-  }
-}
-var documentEventsCapturePhase = ["blur", "scroll"], documentEventsBubblePhase = [
-  // mouse
-  "mousedown",
-  "mousemove",
-  "mouseup",
-  "dragstart",
-  // touch
-  "touchstart",
-  "touchmove",
-  "touchend",
-  "touchcancel",
-  // other
-  "contextmenu",
-  "select",
-  "selectionchange"
-], isTamaguiResponderActive = Symbol();
-function attachListeners() {
-  canUseDOM && !window[isTamaguiResponderActive] && (window.addEventListener("blur", eventListener), documentEventsBubblePhase.forEach((eventType) => {
-    document.addEventListener(eventType, eventListener);
-  }), documentEventsCapturePhase.forEach((eventType) => {
-    document.addEventListener(eventType, eventListener, !0);
-  }), window[isTamaguiResponderActive] = !0);
-}
-function addNode(id, node, config) {
-  setResponderId(node, id), responderListenersMap.set(id, config);
-}
-function removeNode(id) {
-  currentResponder.id === id && terminateResponder(), responderListenersMap.has(id) && responderListenersMap.delete(id);
-}
-function terminateResponder() {
-  let { id, node } = currentResponder;
-  if (id != null && node != null) {
-    let { onResponderTerminate } = getResponderConfig(id);
-    if (onResponderTerminate != null) {
-      let event = createResponderEvent({}, responderTouchHistoryStore);
-      event.currentTarget = node, onResponderTerminate(event);
-    }
-    changeCurrentResponder(emptyResponder);
-  }
-  isEmulatingMouseEvents = !1, trackedTouchCount = 0;
-}
-function getResponderNode() {
-  return currentResponder.node;
-}
-
-// ../react-native-use-responder-events/dist/esm/useResponderEvents.js
-var emptyObject3 = {};
-function useResponderEvents(hostRef, config = emptyObject3) {
-  let id = React.useId(), isAttachedRef = React.useRef(!1);
-  React.useEffect(() => (attachListeners(), () => {
-    removeNode(id);
-  }), [id]), React.useEffect(() => {
-    let {
-      onMoveShouldSetResponder,
-      onMoveShouldSetResponderCapture,
-      onScrollShouldSetResponder,
-      onScrollShouldSetResponderCapture,
-      onSelectionChangeShouldSetResponder,
-      onSelectionChangeShouldSetResponderCapture,
-      onStartShouldSetResponder,
-      onStartShouldSetResponderCapture
-    } = config, requiresResponderSystem = onMoveShouldSetResponder != null || onMoveShouldSetResponderCapture != null || onScrollShouldSetResponder != null || onScrollShouldSetResponderCapture != null || onSelectionChangeShouldSetResponder != null || onSelectionChangeShouldSetResponderCapture != null || onStartShouldSetResponder != null || onStartShouldSetResponderCapture != null, node = hostRef.current;
-    requiresResponderSystem ? (addNode(id, node, config), isAttachedRef.current = !0) : isAttachedRef.current && (removeNode(id), isAttachedRef.current = !1);
-  }, [config, hostRef, id]), React.useDebugValue({
-    isResponder: hostRef.current === getResponderNode()
-  }), React.useDebugValue(config);
-}
-
-// src/index.ts
-var import_web2 = __toESM(require_index_native8());
+module.exports = __toCommonJS(src_exports);
+var import_react_native_use_responder_events = __toESM(require_index_native()), import_web2 = __toESM(require_index_native9());
 
 // src/getBaseViews.native.ts
 function getBaseViews() {
@@ -6477,10 +6652,10 @@ function getBaseViews() {
 }
 
 // src/hooks/useElementLayout.tsx
-var import_constants = __toESM(require_index_native());
+var import_constants = __toESM(require_index_native2());
 
 // src/helpers/getBoundingClientRect.tsx
-var getBoundingClientRect2 = (node) => {
+var getBoundingClientRect = (node) => {
   var _a;
   if (!(!node || node.nodeType !== 1))
     return (_a = node.getBoundingClientRect) == null ? void 0 : _a.call(node);
@@ -6488,7 +6663,7 @@ var getBoundingClientRect2 = (node) => {
 
 // src/helpers/getRect.tsx
 var getRect = (node) => {
-  let rect = getBoundingClientRect2(node);
+  let rect = getBoundingClientRect(node);
   if (!rect)
     return;
   let { x, y, top, left } = rect;
@@ -6516,7 +6691,7 @@ typeof window < "u" && "ResizeObserver" in window && (resizeObserver = new Resiz
 var measureLayout = (node, relativeTo, callback) => {
   let relativeNode = relativeTo || (node == null ? void 0 : node.parentNode);
   relativeNode instanceof HTMLElement && setTimeout(() => {
-    let relativeRect = getBoundingClientRect2(relativeNode), { height, left, top, width } = getRect(node), x = left - relativeRect.left, y = top - relativeRect.top;
+    let relativeRect = getBoundingClientRect(relativeNode), { height, left, top, width } = getRect(node), x = left - relativeRect.left, y = top - relativeRect.top;
     callback(x, y, width, height, left, top);
   }, 0);
 };
@@ -6533,7 +6708,7 @@ function useElementLayout(ref, onLayout) {
 }
 
 // src/hooks/usePlatformMethods.ts
-var import_web = __toESM(require_index_native8());
+var import_web = __toESM(require_index_native9());
 function usePlatformMethods(hostRef) {
   (0, import_web.useIsomorphicLayoutEffect)(() => {
     let node = hostRef.current;
@@ -6550,7 +6725,7 @@ function usePlatformMethods(hostRef) {
 var Pressability = require_fake_react_native().default, usePressability = (init_idFn(), __toCommonJS(idFn_exports)).default;
 
 // src/index.ts
-__reExport(src_exports, __toESM(require_index_native8()));
+__reExport(src_exports, __toESM(require_index_native9()), module.exports);
 var Stack = import_web2.Stack, Text = import_web2.Text;
 (0, import_web2.setupHooks)({
   getBaseViews,
@@ -6583,7 +6758,7 @@ var Stack = import_web2.Stack, Text = import_web2.Text;
       hrefAttrs,
       ...viewProps
     } = propsIn;
-    if (usePlatformMethods(hostRef), useElementLayout(hostRef, onLayout), useResponderEvents(hostRef, {
+    if (usePlatformMethods(hostRef), useElementLayout(hostRef, onLayout), (0, import_react_native_use_responder_events.useResponderEvents)(hostRef, {
       onMoveShouldSetResponder,
       onMoveShouldSetResponderCapture,
       onResponderEnd,
@@ -6625,7 +6800,9 @@ var Stack = import_web2.Stack, Text = import_web2.Text;
 var dontComposePressabilityKeys = {
   onClick: !0
 };
-
-// src/native.ts
-__reExport(native_exports, src_exports, module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Stack,
+  Text
+});
 //# sourceMappingURL=native.js.map