@hanzogui/react-native-web-lite 2.0.0

package/dist/cjs/vendor/react-native/JSEventLoopWatchdog/index.cjs

@@ -0,0 +1,78 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var JSEventLoopWatchdog_exports = {};
+__export(JSEventLoopWatchdog_exports, {
+  JSEventLoopWatchdog: () => JSEventLoopWatchdog,
+  default: () => JSEventLoopWatchdog_default
+});
+module.exports = __toCommonJS(JSEventLoopWatchdog_exports);
+var import_infoLog = require("../infoLog/index.cjs");
+const JSEventLoopWatchdog = {
+  getStats: function () {
+    return {
+      stallCount,
+      totalStallTime,
+      longestStall,
+      acceptableBusyTime
+    };
+  },
+  reset: function () {
+    (0, import_infoLog.infoLog)("JSEventLoopWatchdog: reset"), totalStallTime = 0, stallCount = 0, longestStall = 0, lastInterval = window.performance.now();
+  },
+  addHandler: function (handler) {
+    handlers.push(handler);
+  },
+  install: function ({
+    thresholdMS
+  }) {
+    if (acceptableBusyTime = thresholdMS, installed) return;
+    installed = !0, lastInterval = window.performance.now();
+    function iteration() {
+      const now = window.performance.now(),
+        busyTime = now - lastInterval;
+      if (busyTime >= thresholdMS) {
+        const stallTime = busyTime - thresholdMS;
+        stallCount++, totalStallTime += stallTime, longestStall = Math.max(longestStall, stallTime);
+        let msg = `JSEventLoopWatchdog: JS thread busy for ${busyTime}ms. ${totalStallTime}ms in ${stallCount} stalls so far. `;
+        handlers.forEach(handler => {
+          msg += handler.onStall({
+            lastInterval,
+            busyTime
+          }) || "";
+        }), (0, import_infoLog.infoLog)(msg);
+      }
+      handlers.forEach(handler => {
+        handler.onIterate && handler.onIterate();
+      }), lastInterval = now, setTimeout(iteration, thresholdMS / 5);
+    }
+    iteration();
+  }
+};
+let acceptableBusyTime = 0,
+  installed = !1,
+  totalStallTime = 0,
+  stallCount = 0,
+  longestStall = 0,
+  lastInterval = 0;
+const handlers = [];
+var JSEventLoopWatchdog_default = JSEventLoopWatchdog;

package/dist/cjs/vendor/react-native/LayoutAnimation/index.cjs

@@ -0,0 +1,112 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var LayoutAnimation_exports = {};
+__export(LayoutAnimation_exports, {
+  LayoutAnimation: () => LayoutAnimation,
+  default: () => LayoutAnimation_default
+});
+module.exports = __toCommonJS(LayoutAnimation_exports);
+var import_Platform = require("../../../exports/Platform"),
+  import_UIManager = require("../../../exports/UIManager");
+const __DEV__ = process.env.NODE_ENV !== "production";
+function configureNext(config, onAnimationDidEnd) {
+  import_Platform.Platform.isTesting || import_UIManager.UIManager.configureNextLayoutAnimation(config, onAnimationDidEnd ?? function () {}, function () {}
+  /* unused onError */);
+}
+function create(duration, type, property) {
+  return {
+    duration,
+    create: {
+      type,
+      property
+    },
+    update: {
+      type
+    },
+    delete: {
+      type,
+      property
+    }
+  };
+}
+const Presets = {
+    easeInEaseOut: create(300, "easeInEaseOut", "opacity"),
+    linear: create(500, "linear", "opacity"),
+    spring: {
+      duration: 700,
+      create: {
+        type: "linear",
+        property: "opacity"
+      },
+      update: {
+        type: "spring",
+        springDamping: 0.4
+      },
+      delete: {
+        type: "linear",
+        property: "opacity"
+      }
+    }
+  },
+  LayoutAnimation = {
+    /**
+     * Schedules an animation to happen on the next layout.
+     *
+     * @param config Specifies animation properties:
+     *
+     *   - `duration` in milliseconds
+     *   - `create`, `AnimationConfig` for animating in new views
+     *   - `update`, `AnimationConfig` for animating views that have been updated
+     *
+     * @param onAnimationDidEnd Called when the animation finished.
+     * Only supported on iOS.
+     * @param onError Called on error. Only supported on iOS.
+     */
+    configureNext,
+    /**
+     * Helper for creating a config for `configureNext`.
+     */
+    create,
+    Types: Object.freeze({
+      spring: "spring",
+      linear: "linear",
+      easeInEaseOut: "easeInEaseOut",
+      easeIn: "easeIn",
+      easeOut: "easeOut",
+      keyboard: "keyboard"
+    }),
+    Properties: Object.freeze({
+      opacity: "opacity",
+      scaleX: "scaleX",
+      scaleY: "scaleY",
+      scaleXY: "scaleXY"
+    }),
+    checkConfig(...args) {
+      console.error("LayoutAnimation.checkConfig(...) has been disabled.");
+    },
+    Presets,
+    easeInEaseOut: configureNext.bind(null, Presets.easeInEaseOut),
+    linear: configureNext.bind(null, Presets.linear),
+    spring: configureNext.bind(null, Presets.spring)
+  };
+var LayoutAnimation_default = LayoutAnimation;

package/dist/cjs/vendor/react-native/PanResponder/index.cjs

@@ -0,0 +1,144 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var PanResponder_exports = {};
+__export(PanResponder_exports, {
+  PanResponder: () => PanResponder,
+  default: () => PanResponder_default
+});
+module.exports = __toCommonJS(PanResponder_exports);
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals"),
+  import_TouchHistoryMath = __toESM(require("../TouchHistoryMath/index.cjs"), 1);
+const currentCentroidXOfTouchesChangedAfter = import_TouchHistoryMath.default.currentCentroidXOfTouchesChangedAfter,
+  currentCentroidYOfTouchesChangedAfter = import_TouchHistoryMath.default.currentCentroidYOfTouchesChangedAfter,
+  previousCentroidXOfTouchesChangedAfter = import_TouchHistoryMath.default.previousCentroidXOfTouchesChangedAfter,
+  previousCentroidYOfTouchesChangedAfter = import_TouchHistoryMath.default.previousCentroidYOfTouchesChangedAfter,
+  currentCentroidX = import_TouchHistoryMath.default.currentCentroidX,
+  currentCentroidY = import_TouchHistoryMath.default.currentCentroidY,
+  PanResponder = {
+    _initializeGestureState(gestureState) {
+      gestureState.moveX = 0, gestureState.moveY = 0, gestureState.x0 = 0, gestureState.y0 = 0, gestureState.dx = 0, gestureState.dy = 0, gestureState.vx = 0, gestureState.vy = 0, gestureState.numberActiveTouches = 0, gestureState._accountsForMovesUpTo = 0;
+    },
+    _updateGestureStateOnMove(gestureState, touchHistory) {
+      gestureState.numberActiveTouches = touchHistory.numberActiveTouches, gestureState.moveX = currentCentroidXOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo), gestureState.moveY = currentCentroidYOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);
+      const movedAfter = gestureState._accountsForMovesUpTo,
+        prevX = previousCentroidXOfTouchesChangedAfter(touchHistory, movedAfter),
+        x = currentCentroidXOfTouchesChangedAfter(touchHistory, movedAfter),
+        prevY = previousCentroidYOfTouchesChangedAfter(touchHistory, movedAfter),
+        y = currentCentroidYOfTouchesChangedAfter(touchHistory, movedAfter),
+        nextDX = gestureState.dx + (x - prevX),
+        nextDY = gestureState.dy + (y - prevY),
+        dt = touchHistory.mostRecentTimeStamp - gestureState._accountsForMovesUpTo;
+      gestureState.vx = (nextDX - gestureState.dx) / dt, gestureState.vy = (nextDY - gestureState.dy) / dt, gestureState.dx = nextDX, gestureState.dy = nextDY, gestureState._accountsForMovesUpTo = touchHistory.mostRecentTimeStamp;
+    },
+    create(config) {
+      const interactionState = {
+          handle: null,
+          shouldCancelClick: !1,
+          timeout: null
+        },
+        gestureState = {
+          stateID: Math.random(),
+          moveX: 0,
+          moveY: 0,
+          x0: 0,
+          y0: 0,
+          dx: 0,
+          dy: 0,
+          vx: 0,
+          vy: 0,
+          numberActiveTouches: 0,
+          _accountsForMovesUpTo: 0
+        };
+      return {
+        panHandlers: {
+          onStartShouldSetResponder(event) {
+            return config.onStartShouldSetPanResponder == null ? !1 : config.onStartShouldSetPanResponder(event, gestureState);
+          },
+          onMoveShouldSetResponder(event) {
+            return config.onMoveShouldSetPanResponder == null ? !1 : config.onMoveShouldSetPanResponder(event, gestureState);
+          },
+          onStartShouldSetResponderCapture(event) {
+            return event.nativeEvent.touches.length === 1 && PanResponder._initializeGestureState(gestureState), gestureState.numberActiveTouches = event.touchHistory.numberActiveTouches, config.onStartShouldSetPanResponderCapture != null ? config.onStartShouldSetPanResponderCapture(event, gestureState) : !1;
+          },
+          onMoveShouldSetResponderCapture(event) {
+            const touchHistory = event.touchHistory;
+            return gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp ? !1 : (PanResponder._updateGestureStateOnMove(gestureState, touchHistory), config.onMoveShouldSetPanResponderCapture ? config.onMoveShouldSetPanResponderCapture(event, gestureState) : !1);
+          },
+          onResponderGrant(event) {
+            return interactionState.handle || (interactionState.handle = import_react_native_web_internals.InteractionManager.createInteractionHandle()), interactionState.timeout && clearInteractionTimeout(interactionState), interactionState.shouldCancelClick = !0, gestureState.x0 = currentCentroidX(event.touchHistory), gestureState.y0 = currentCentroidY(event.touchHistory), gestureState.dx = 0, gestureState.dy = 0, config.onPanResponderGrant && config.onPanResponderGrant(event, gestureState), config.onShouldBlockNativeResponder == null ? !0 : config.onShouldBlockNativeResponder(event, gestureState);
+          },
+          onResponderReject(event) {
+            clearInteractionHandle(interactionState, config.onPanResponderReject, event, gestureState);
+          },
+          onResponderRelease(event) {
+            clearInteractionHandle(interactionState, config.onPanResponderRelease, event, gestureState), setInteractionTimeout(interactionState), PanResponder._initializeGestureState(gestureState);
+          },
+          onResponderStart(event) {
+            const touchHistory = event.touchHistory;
+            gestureState.numberActiveTouches = touchHistory.numberActiveTouches, config.onPanResponderStart && config.onPanResponderStart(event, gestureState);
+          },
+          onResponderMove(event) {
+            const touchHistory = event.touchHistory;
+            gestureState._accountsForMovesUpTo !== touchHistory.mostRecentTimeStamp && (PanResponder._updateGestureStateOnMove(gestureState, touchHistory), config.onPanResponderMove && config.onPanResponderMove(event, gestureState));
+          },
+          onResponderEnd(event) {
+            const touchHistory = event.touchHistory;
+            gestureState.numberActiveTouches = touchHistory.numberActiveTouches, clearInteractionHandle(interactionState, config.onPanResponderEnd, event, gestureState);
+          },
+          onResponderTerminate(event) {
+            clearInteractionHandle(interactionState, config.onPanResponderTerminate, event, gestureState), setInteractionTimeout(interactionState), PanResponder._initializeGestureState(gestureState);
+          },
+          onResponderTerminationRequest(event) {
+            return config.onPanResponderTerminationRequest == null ? !0 : config.onPanResponderTerminationRequest(event, gestureState);
+          },
+          onClickCapture: event => {
+            interactionState.shouldCancelClick === !0 && (event.stopPropagation(), event.preventDefault());
+          }
+        },
+        getInteractionHandle() {
+          return interactionState.handle;
+        }
+      };
+    }
+  };
+function clearInteractionHandle(interactionState, callback, event, gestureState) {
+  interactionState.handle && (import_react_native_web_internals.InteractionManager.clearInteractionHandle(interactionState.handle), interactionState.handle = null), callback && callback(event, gestureState);
+}
+function clearInteractionTimeout(interactionState) {
+  clearTimeout(interactionState.timeout);
+}
+function setInteractionTimeout(interactionState) {
+  interactionState.timeout = setTimeout(() => {
+    interactionState.shouldCancelClick = !1;
+  }, 250);
+}
+var PanResponder_default = PanResponder;

package/dist/cjs/vendor/react-native/PooledClass/index.cjs

@@ -0,0 +1,48 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var PooledClass_exports = {};
+__export(PooledClass_exports, {
+  PooledClass: () => PooledClass,
+  default: () => PooledClass_default
+});
+module.exports = __toCommonJS(PooledClass_exports);
+var twoArgumentPooler = function (a1, a2) {
+    var Klass = this;
+    if (Klass.instancePool.length) {
+      var instance = Klass.instancePool.pop();
+      return Klass.call(instance, a1, a2), instance;
+    } else return new Klass(a1, a2);
+  },
+  standardReleaser = function (instance) {
+    var Klass = this;
+    instance.destructor(), Klass.instancePool.length < Klass.poolSize && Klass.instancePool.push(instance);
+  },
+  DEFAULT_POOL_SIZE = 10,
+  DEFAULT_POOLER = twoArgumentPooler,
+  addPoolingTo = function (CopyConstructor, pooler) {
+    var NewKlass = CopyConstructor;
+    return NewKlass.instancePool = [], NewKlass.getPooled = pooler || DEFAULT_POOLER, NewKlass.poolSize || (NewKlass.poolSize = DEFAULT_POOL_SIZE), NewKlass.release = standardReleaser, NewKlass;
+  },
+  PooledClass = {
+    addPoolingTo,
+    twoArgumentPooler
+  };
+var PooledClass_default = PooledClass;

package/dist/cjs/vendor/react-native/ReactNative/ReactNativeFeatureFlags.cjs

@@ -0,0 +1,34 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: !0
+}), mod);
+var ReactNativeFeatureFlags_exports = {};
+__export(ReactNativeFeatureFlags_exports, {
+  ReactNativeFeatureFlags: () => ReactNativeFeatureFlags,
+  default: () => ReactNativeFeatureFlags_default
+});
+module.exports = __toCommonJS(ReactNativeFeatureFlags_exports);
+const ReactNativeFeatureFlags = {
+  isLayoutAnimationEnabled: () => !0,
+  shouldEmitW3CPointerEvents: () => !1,
+  shouldPressibilityUseW3CPointerEventsForHover: () => !1,
+  animatedShouldDebounceQueueFlush: () => !1,
+  animatedShouldUseSingleOp: () => !1
+};
+var ReactNativeFeatureFlags_default = ReactNativeFeatureFlags;

package/dist/cjs/vendor/react-native/SectionList/index.cjs

@@ -0,0 +1,104 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var SectionList_exports = {};
+__export(SectionList_exports, {
+  SectionList: () => SectionList,
+  default: () => SectionList_default
+});
+module.exports = __toCommonJS(SectionList_exports);
+var import_VirtualizedSectionList = require("../VirtualizedSectionList/index.cjs"),
+  React = __toESM(require("react"), 1),
+  import_jsx_runtime = require("react/jsx-runtime");
+class SectionList extends React.PureComponent {
+  scrollToLocation(params) {
+    this._wrapperListRef != null && this._wrapperListRef.scrollToLocation(params);
+  }
+  recordInteraction() {
+    const listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+    listRef && listRef.recordInteraction();
+  }
+  flashScrollIndicators() {
+    const listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+    listRef && listRef.flashScrollIndicators();
+  }
+  getScrollResponder() {
+    const listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+    if (listRef) return listRef.getScrollResponder();
+  }
+  getScrollableNode() {
+    const listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+    if (listRef) return listRef.getScrollableNode();
+  }
+  setNativeProps(props) {
+    const listRef = this._wrapperListRef && this._wrapperListRef.getListRef();
+    listRef && listRef.setNativeProps(props);
+  }
+  render() {
+    const {
+      sections,
+      ...passThroughProps
+    } = this.props;
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_VirtualizedSectionList.VirtualizedSectionList, {
+      ...passThroughProps,
+      sections,
+      ref: this._captureRef,
+      getItem: this._getItem,
+      getItemCount: this._getItemCount,
+      keyExtractor: this._keyExtractor,
+      renderItem: this._renderItem
+    });
+  }
+  _captureRef = ref => {
+    this._wrapperListRef = ref;
+  };
+  _getItem = (sections, index) => {
+    if (!sections) return null;
+    const section = sections[index];
+    return section && section.data ? section.data[0] : null;
+  };
+  _getItemCount = sections => sections ? sections.length : 0;
+  _keyExtractor = (item, index) => (this.props.keyExtractor || this._defaultKeyExtractor)(item, index);
+  _defaultKeyExtractor = (item, index) => item.key != null ? item.key : String(index);
+  _renderItem = ({
+    item,
+    index,
+    section
+  }) => (this.props.renderItem || this._defaultRenderItem)({
+    item,
+    index,
+    section
+  });
+  _defaultRenderItem = ({
+    item
+  }) => null;
+}
+var SectionList_default = SectionList;

package/dist/cjs/vendor/react-native/StaticContainer/index.cjs

@@ -0,0 +1,50 @@
+"use strict";
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var StaticContainer_exports = {};
+__export(StaticContainer_exports, {
+  StaticContainer: () => StaticContainer,
+  default: () => StaticContainer_default
+});
+module.exports = __toCommonJS(StaticContainer_exports);
+var React = __toESM(require("react"), 1);
+class StaticContainer extends React.Component {
+  shouldComponentUpdate(nextProps) {
+    return !!nextProps.shouldUpdate;
+  }
+  render() {
+    const child = this.props.children;
+    return child === null || child === !1 ? null : React.Children.only(child);
+  }
+}
+var StaticContainer_default = StaticContainer;

package/dist/cjs/vendor/react-native/StaticRenderer/index.cjs

@@ -0,0 +1,49 @@
+"use strict";
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf,
+  __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+    for (var name in all) __defProp(target, name, {
+      get: all[name],
+      enumerable: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+    return to;
+  };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+    value: mod,
+    enumerable: !0
+  }) : target, mod)),
+  __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+    value: !0
+  }), mod);
+var StaticRenderer_exports = {};
+__export(StaticRenderer_exports, {
+  StaticRenderer: () => StaticRenderer,
+  default: () => StaticRenderer_default
+});
+module.exports = __toCommonJS(StaticRenderer_exports);
+var React = __toESM(require("react"), 1);
+class StaticRenderer extends React.Component {
+  shouldComponentUpdate(nextProps) {
+    return nextProps.shouldUpdate;
+  }
+  render() {
+    return this.props.render();
+  }
+}
+var StaticRenderer_default = StaticRenderer;