@hanzogui/react-native-web-lite 2.0.0

package/dist/cjs/vendor/react-native/VirtualizedList/VirtualizedListContext.cjs

@@ -0,0 +1,85 @@
+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 VirtualizedListContext_exports = {};
+__export(VirtualizedListContext_exports, {
+  VirtualizedListCellContextProvider: () => VirtualizedListCellContextProvider,
+  VirtualizedListContext: () => VirtualizedListContext,
+  VirtualizedListContextProvider: () => VirtualizedListContextProvider,
+  VirtualizedListContextResetter: () => VirtualizedListContextResetter
+});
+module.exports = __toCommonJS(VirtualizedListContext_exports);
+var import_VirtualizedList = require("../VirtualizedList/index.cjs"),
+  React = __toESM(require("react"), 1),
+  import_react = require("react"),
+  import_jsx_runtime = require("react/jsx-runtime");
+const __DEV__ = process.env.NODE_ENV !== "production";
+const VirtualizedListContext = React.createContext(null);
+__DEV__ && (VirtualizedListContext.displayName = "VirtualizedListContext");
+function VirtualizedListContextResetter({
+  children
+}) {
+  return /* @__PURE__ */(0, import_jsx_runtime.jsx)(VirtualizedListContext.Provider, {
+    value: null,
+    children
+  });
+}
+function VirtualizedListContextProvider({
+  children,
+  value
+}) {
+  const context = (0, import_react.useMemo)(() => ({
+    cellKey: null,
+    getScrollMetrics: value.getScrollMetrics,
+    horizontal: value.horizontal,
+    getOutermostParentListRef: value.getOutermostParentListRef,
+    registerAsNestedChild: value.registerAsNestedChild,
+    unregisterAsNestedChild: value.unregisterAsNestedChild
+  }), [value.getScrollMetrics, value.horizontal, value.getOutermostParentListRef, value.registerAsNestedChild, value.unregisterAsNestedChild]);
+  return /* @__PURE__ */(0, import_jsx_runtime.jsx)(VirtualizedListContext.Provider, {
+    value: context,
+    children
+  });
+}
+function VirtualizedListCellContextProvider({
+  cellKey,
+  children
+}) {
+  const currContext = (0, import_react.useContext)(VirtualizedListContext),
+    context = (0, import_react.useMemo)(() => currContext == null ? null : {
+      ...currContext,
+      cellKey
+    }, [currContext, cellKey]);
+  return /* @__PURE__ */(0, import_jsx_runtime.jsx)(VirtualizedListContext.Provider, {
+    value: context,
+    children
+  });
+}

package/dist/cjs/vendor/react-native/VirtualizedList/VirtualizedListProps.cjs

@@ -0,0 +1,64 @@
+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 VirtualizedListProps_exports = {};
+__export(VirtualizedListProps_exports, {
+  default: () => VirtualizedListProps_default,
+  defaultVirtualizedListProps: () => defaultVirtualizedListProps
+});
+module.exports = __toCommonJS(VirtualizedListProps_exports);
+const defaultVirtualizedListProps = {
+  debug: !1,
+  disableVirtualization: !1,
+  extraData: null,
+  getItemLayout: null,
+  horizontal: !1,
+  initialNumToRender: 10,
+  initialScrollIndex: null,
+  inverted: !1,
+  keyExtractor: null,
+  CellRendererComponent: null,
+  ItemSeparatorComponent: null,
+  ListItemComponent: null,
+  ListEmptyComponent: null,
+  ListFooterComponent: null,
+  ListFooterComponentStyle: null,
+  ListHeaderComponent: null,
+  ListHeaderComponentStyle: null,
+  maxToRenderPerBatch: 10,
+  onEndReached: null,
+  onEndReachedThreshold: 2,
+  onRefresh: null,
+  onScrollToIndexFailed: null,
+  onStartReached: null,
+  onStartReachedThreshold: 2,
+  onViewableItemsChanged: null,
+  persistentScrollbar: !1,
+  progressViewOffset: 0,
+  refreshControl: null,
+  refreshing: !1,
+  removeClippedSubviews: !1,
+  renderScrollComponent: null,
+  updateCellsBatchingPeriod: 50,
+  viewabilityConfig: null,
+  viewabilityConfigCallbackPairs: null,
+  windowSize: 21
+};
+var VirtualizedListProps_default = defaultVirtualizedListProps;

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

@@ -0,0 +1,264 @@
+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 VirtualizedList_exports = {};
+__export(VirtualizedList_exports, {
+  VirtualizedList: () => VirtualizedList,
+  default: () => VirtualizedList_default
+});
+module.exports = __toCommonJS(VirtualizedList_exports);
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals"),
+  import_ScrollView = require("../../../ScrollView/index.cjs"),
+  import_RefreshControl = require("../../../RefreshControl/index.cjs"),
+  import_Batchinator = require("../Batchinator/index.cjs"),
+  import_ChildListCollection = require("./ChildListCollection.cjs"),
+  import_FillRateHelper = require("../FillRateHelper/index.cjs"),
+  import_StateSafePureComponent = require("./StateSafePureComponent.cjs"),
+  import_ViewabilityHelper = require("../ViewabilityHelper/index.cjs"),
+  import_VirtualizedListCellRenderer = require("./VirtualizedListCellRenderer.cjs"),
+  import_VirtualizedListContext = require("./VirtualizedListContext.cjs"),
+  import_jsx_runtime = require("react/jsx-runtime");
+const __DEV__ = process.env.NODE_ENV !== "production";
+function horizontalOrDefault(horizontal) {
+  return horizontal ?? !1;
+}
+function scrollEventThrottleOrDefault(scrollEventThrottle) {
+  return scrollEventThrottle ?? 50;
+}
+class VirtualizedList extends import_StateSafePureComponent.StateSafePureComponent {
+  static contextType = import_VirtualizedListContext.VirtualizedListContext;
+  constructor(props) {
+    super(props), this._nestedChildLists = new import_ChildListCollection.ChildListCollection(), this._viewabilityTuples = [], this._scrollMetrics = {
+      contentLength: 0,
+      dOffset: 0,
+      dt: 10,
+      offset: 0,
+      timestamp: 0,
+      velocity: 0,
+      visibleLength: 0
+    }, this._highestMeasuredFrameIndex = 0, this._headerLength = 0, this._footerLength = 0, this._averageCellLength = 0, this._hasWarned = {}, this._fillRateHelper = new import_FillRateHelper.FillRateHelper(this._getFrameMetrics), this._updateCellsToRenderBatcher = new import_Batchinator.Batchinator(this._updateCellsToRender, this.props.updateCellsBatchingPeriod ?? 50), this.props.viewabilityConfig && this.props.onViewableItemsChanged && this._viewabilityTuples.push({
+      viewabilityHelper: new import_ViewabilityHelper.ViewabilityHelper(this.props.viewabilityConfig),
+      onViewableItemsChanged: this.props.onViewableItemsChanged
+    });
+  }
+  scrollToEnd(params) {
+    const animated = params ? params.animated : !0,
+      veryLast = this.props.getItemCount(this.props.data) - 1;
+    if (veryLast < 0) return;
+    const frame = this.__getFrameMetricsApprox(veryLast, this.props),
+      offset = Math.max(0, frame.offset + frame.length + this._footerLength - this._scrollMetrics.visibleLength);
+    if (this._scrollRef != null) {
+      if (this._scrollRef.scrollTo == null) {
+        console.warn("No scrollTo method provided. This may be because you have two nested VirtualizedLists with the same orientation, or because you are using a custom component that does not implement scrollTo.");
+        return;
+      }
+      this._scrollRef.scrollTo(horizontalOrDefault(this.props.horizontal) ? {
+        x: offset,
+        animated
+      } : {
+        y: offset,
+        animated
+      });
+    }
+  }
+  scrollToIndex(params) {
+    const {
+        data,
+        horizontal,
+        getItemCount,
+        getItemLayout,
+        onScrollToIndexFailed
+      } = this.props,
+      {
+        animated,
+        index,
+        viewOffset,
+        viewPosition
+      } = params;
+    if ((0, import_react_native_web_internals.invariant)(index >= 0, `scrollToIndex out of range: requested index ${index} but minimum is 0`), (0, import_react_native_web_internals.invariant)(getItemCount(data) >= 1, `scrollToIndex out of range: item length ${getItemCount(data)} but minimum is 1`), (0, import_react_native_web_internals.invariant)(index < getItemCount(data), `scrollToIndex out of range: requested index ${index} is out of 0 to ${getItemCount(data) - 1}`), !getItemLayout && index > this._highestMeasuredFrameIndex) {
+      (0, import_react_native_web_internals.invariant)(!!onScrollToIndexFailed, "scrollToIndex should be used in conjunction with getItemLayout or onScrollToIndexFailed, otherwise there is no way to know the location of offscreen indices or handle failures."), onScrollToIndexFailed({
+        averageItemLength: this._averageCellLength,
+        highestMeasuredFrameIndex: this._highestMeasuredFrameIndex,
+        index
+      });
+      return;
+    }
+    const frame = this.__getFrameMetricsApprox(Math.floor(index), this.props),
+      offset = Math.max(0, this._getOffsetApprox(index, this.props) - (viewPosition || 0) * (this._scrollMetrics.visibleLength - frame.length)) - (viewOffset || 0);
+    this._scrollRef != null && this._scrollRef.scrollTo(horizontalOrDefault(horizontal) ? {
+      x: offset,
+      animated
+    } : {
+      y: offset,
+      animated
+    });
+  }
+  scrollToItem(params) {
+    const {
+        data,
+        getItem,
+        getItemCount,
+        horizontal,
+        onScrollToIndexFailed
+      } = this.props,
+      {
+        animated,
+        item,
+        viewPosition,
+        viewOffset
+      } = params,
+      index = this.props.data.indexOf(item);
+    if (index !== -1) this.scrollToIndex({
+      animated,
+      index,
+      viewOffset,
+      viewPosition
+    });else {
+      const itemCount = getItemCount(data);
+      for (let i = 0; i < itemCount; i++) if (getItem(data, i) === item) {
+        this.scrollToIndex({
+          animated,
+          index: i,
+          viewOffset,
+          viewPosition
+        });
+        break;
+      }
+    }
+  }
+  scrollToOffset(params) {
+    const {
+      animated,
+      offset
+    } = params;
+    this._scrollRef != null && this._scrollRef.scrollTo(horizontalOrDefault(this.props.horizontal) ? {
+      x: offset,
+      animated
+    } : {
+      y: offset,
+      animated
+    });
+  }
+  recordInteraction() {
+    this._nestedChildLists.forEach(childList => {
+      childList.recordInteraction();
+    }), this._viewabilityTuples.forEach(viewabilityTuple => {
+      viewabilityTuple.viewabilityHelper.recordInteraction();
+    });
+  }
+  flashScrollIndicators() {
+    this._scrollRef && this._scrollRef.flashScrollIndicators && this._scrollRef.flashScrollIndicators();
+  }
+  getScrollResponder() {
+    if (this._scrollRef && this._scrollRef.getScrollResponder) return this._scrollRef.getScrollResponder();
+  }
+  getScrollableNode() {
+    if (this._scrollRef && this._scrollRef.getScrollableNode) return this._scrollRef.getScrollableNode();
+  }
+  getScrollRef() {
+    return this._scrollRef;
+  }
+  setNativeProps(props) {
+    this._scrollRef && this._scrollRef.setNativeProps(props);
+  }
+  render() {
+    const {
+      ListEmptyComponent,
+      ListFooterComponent,
+      ListHeaderComponent,
+      data,
+      debug,
+      disableVirtualization,
+      getItem,
+      getItemCount,
+      getItemLayout,
+      horizontal,
+      keyExtractor,
+      numColumns,
+      onEndReached,
+      onEndReachedThreshold,
+      onLayout,
+      onRefresh,
+      onScroll,
+      onScrollBeginDrag,
+      onScrollEndDrag,
+      onMomentumScrollBegin,
+      onMomentumScrollEnd,
+      onStartReached,
+      onStartReachedThreshold,
+      onViewableItemsChanged,
+      refreshing,
+      removeClippedSubviews,
+      renderItem,
+      viewabilityConfig,
+      viewabilityConfigCallbackPairs,
+      ...restProps
+    } = this.props;
+    return getItemCount(data) === 0 ? ListEmptyComponent ? /* @__PURE__ */(0, import_jsx_runtime.jsx)(ListEmptyComponent, {}) : null : /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_ScrollView.ScrollView, {
+      ...restProps,
+      ref: this._captureRef,
+      onContentSizeChange: this._onContentSizeChange,
+      onLayout: this._onLayout,
+      onScroll: this._onScroll,
+      refreshControl: onRefresh && /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_RefreshControl.RefreshControl, {
+        refreshing,
+        onRefresh
+      }),
+      scrollEventThrottle: scrollEventThrottleOrDefault(this.props.scrollEventThrottle),
+      removeClippedSubviews,
+      children: this._renderChildren()
+    });
+  }
+  _renderChildren() {
+    const {
+        data,
+        getItem,
+        getItemCount,
+        renderItem
+      } = this.props,
+      items = [];
+    for (let i = 0; i < getItemCount(data); i++) {
+      const item = getItem(data, i);
+      items.push(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_VirtualizedListCellRenderer.CellRenderer, {
+        cellKey: String(i),
+        index: i,
+        item,
+        renderItem
+      }, this.props.keyExtractor ? this.props.keyExtractor(item, i) : i));
+    }
+    return items;
+  }
+  _captureRef = ref => {
+    this._scrollRef = ref;
+  };
+  _onContentSizeChange = (width, height) => {};
+  _onLayout = event => {};
+  _onScroll = event => {};
+  __getFrameMetricsApprox(index, props) {
+    return {
+      length: this._averageCellLength,
+      offset: this._averageCellLength * index
+    };
+  }
+  _getOffsetApprox(index, props) {
+    return this.__getFrameMetricsApprox(index, props).offset;
+  }
+}
+var VirtualizedList_default = VirtualizedList;

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

@@ -0,0 +1,130 @@
+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 VirtualizedSectionList_exports = {};
+__export(VirtualizedSectionList_exports, {
+  VirtualizedSectionList: () => VirtualizedSectionList,
+  default: () => VirtualizedSectionList_default
+});
+module.exports = __toCommonJS(VirtualizedSectionList_exports);
+var import_VirtualizedList = require("../VirtualizedList/index.cjs"),
+  React = __toESM(require("react"), 1),
+  import_jsx_runtime = require("react/jsx-runtime");
+const defaultProps = {
+  data: [],
+  key: null,
+  renderItem: null,
+  ItemSeparatorComponent: null,
+  keyExtractor: null
+};
+class VirtualizedSectionList extends React.PureComponent {
+  scrollToLocation(params) {
+    let index = params.itemIndex;
+    for (let i = 0; i < params.sectionIndex; i++) index += this.props.getItemCount(this.props.sections[i].data) + 2;
+    let viewOffset = params.viewOffset || 0;
+    if (this._listRef == null) return;
+    if (params.itemIndex > 0 && this.props.stickySectionHeadersEnabled) {
+      const frame = this._listRef.__getFrameMetricsApprox(index - params.itemIndex, this._listRef.props);
+      viewOffset += frame.length;
+    }
+    const toIndexParams = {
+      ...params,
+      viewOffset,
+      index
+    };
+    this._listRef.scrollToIndex(toIndexParams);
+  }
+  getListRef() {
+    return this._listRef;
+  }
+  render() {
+    const {
+        ItemSeparatorComponent,
+        SectionSeparatorComponent,
+        renderItem: _renderItem,
+        renderSectionFooter,
+        renderSectionHeader,
+        sections: _sections,
+        stickySectionHeadersEnabled,
+        ...passThroughProps
+      } = this.props,
+      listHeaderOffset = this.props.ListHeaderComponent ? 1 : 0,
+      stickyHeaderIndices = this.props.stickySectionHeadersEnabled ? [] : void 0;
+    let itemCount = 0;
+    for (const section of this.props.sections) stickyHeaderIndices?.push(itemCount + listHeaderOffset), itemCount += 2, itemCount += this.props.getItemCount(section.data);
+    const renderItem = this._renderItem(itemCount);
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_VirtualizedList.VirtualizedList, {
+      ...passThroughProps,
+      keyExtractor: this._keyExtractor,
+      stickyHeaderIndices,
+      renderItem,
+      data: this.props.sections,
+      getItem: (sections, index) => this._getItem(this.props, sections, index),
+      getItemCount: () => itemCount,
+      onViewableItemsChanged: this.props.onViewableItemsChanged ? this._onViewableItemsChanged : void 0,
+      ref: this._captureRef
+    });
+  }
+  _getItem(props, sections, index) {
+    if (!sections) return null;
+    let itemIdx = index - 1;
+    for (let i = 0; i < sections.length; i++) {
+      const section = sections[i],
+        sectionData = section.data,
+        itemCount = props.getItemCount(sectionData);
+      if (itemIdx === -1 || itemIdx === itemCount) return section;
+      if (itemIdx < itemCount) return props.getItem(sectionData, itemIdx);
+      itemIdx -= itemCount + 2;
+    }
+    return null;
+  }
+  _keyExtractor = (item, index) => (this.props.keyExtractor || this._defaultKeyExtractor)(item, index);
+  _defaultKeyExtractor = (item, index) => item.key != null ? item.key : String(index);
+  _captureRef = ref => {
+    this._listRef = ref;
+  };
+  _renderItem = itemCount => ({
+    item,
+    index
+  }) => index === 0 || index === itemCount - 1 ? null : (this.props.renderItem || this._defaultRenderItem)({
+    item,
+    index,
+    section: item
+  });
+  _defaultRenderItem = ({
+    item
+  }) => null;
+  _onViewableItemsChanged = info => {
+    this.props.onViewableItemsChanged && this.props.onViewableItemsChanged(info);
+  };
+}
+VirtualizedSectionList.defaultProps = defaultProps;
+var VirtualizedSectionList_default = VirtualizedSectionList;

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

@@ -0,0 +1,44 @@
+"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 deepDiffer_exports = {};
+__export(deepDiffer_exports, {
+  deepDiffer: () => deepDiffer,
+  default: () => deepDiffer_default
+});
+module.exports = __toCommonJS(deepDiffer_exports);
+const deepDiffer = function (one, two, maxDepth = -1) {
+  if (maxDepth === 0) return !0;
+  if (one === two || typeof one == "function" && typeof two == "function") return !1;
+  if (typeof one != "object" || one === null) return one !== two;
+  if (typeof two != "object" || two === null || one.constructor !== two.constructor) return !0;
+  if (Array.isArray(one)) {
+    const len = one.length;
+    if (two.length !== len) return !0;
+    for (let ii = 0; ii < len; ii++) if (deepDiffer(one[ii], two[ii], maxDepth - 1)) return !0;
+  } else {
+    for (const key in one) if (deepDiffer(one[key], two[key], maxDepth - 1)) return !0;
+    for (const twoKey in two) if (one[twoKey] === void 0 && two[twoKey] !== void 0) return !0;
+  }
+  return !1;
+};
+var deepDiffer_default = deepDiffer;

package/dist/cjs/vendor/react-native/emitter/EventEmitter.cjs

@@ -0,0 +1,30 @@
+"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 EventEmitter_exports = {};
+__export(EventEmitter_exports, {
+  EventEmitter: () => import_EventEmitter.EventEmitter,
+  default: () => EventEmitter_default
+});
+module.exports = __toCommonJS(EventEmitter_exports);
+var import_EventEmitter = require("./_EventEmitter.cjs");
+var EventEmitter_default = import_EventEmitter.EventEmitter;

package/dist/cjs/vendor/react-native/emitter/EventSubscription.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/vendor/react-native/emitter/_EmitterSubscription.cjs

@@ -0,0 +1,54 @@
+"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 EmitterSubscription_exports = {};
+__export(EmitterSubscription_exports, {
+  EmitterSubscription: () => EmitterSubscription,
+  default: () => EmitterSubscription_default
+});
+module.exports = __toCommonJS(EmitterSubscription_exports);
+var import_EventSubscription = require("./_EventSubscription.cjs");
+class EmitterSubscription extends import_EventSubscription._EventSubscription {
+  /**
+   * @param {EventEmitter} emitter - The event emitter that registered this
+   *   subscription
+   * @param {EventSubscriptionVendor} subscriber - The subscriber that controls
+   *   this subscription
+   * @param {function} listener - Function to invoke when the specified event is
+   *   emitted
+   * @param {*} context - Optional context object to use when invoking the
+   *   listener
+   */
+  constructor(emitter, subscriber, listener, context) {
+    super(subscriber), this.emitter = emitter, this.listener = listener, this.context = context;
+  }
+  /**
+   * Removes this subscription from the emitter that registered it.
+   * Note: we're overriding the `remove()` method of _EventSubscription here
+   * but deliberately not calling `super.remove()` as the responsibility
+   * for removing the subscription lies with the EventEmitter.
+   */
+  remove() {
+    this.emitter.removeSubscription(this);
+  }
+}
+var EmitterSubscription_default = EmitterSubscription;