@hanzogui/react-native-web-lite 2.0.0

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

@@ -0,0 +1,84 @@
+"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 useAnimatedProps_exports = {};
+__export(useAnimatedProps_exports, {
+  default: () => useAnimatedProps_default,
+  useAnimatedProps: () => useAnimatedProps
+});
+module.exports = __toCommonJS(useAnimatedProps_exports);
+var import_AnimatedProps = require("./nodes/AnimatedProps.cjs"),
+  import_AnimatedEvent = require("./AnimatedEvent.cjs"),
+  import_useRefEffect = require("../Utilities/useRefEffect.cjs"),
+  import_NativeAnimatedHelper = require("./NativeAnimatedHelper.cjs"),
+  import_react = require("react"),
+  import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+function useAnimatedProps(props) {
+  const [, scheduleUpdate] = (0, import_react.useReducer)(count => count + 1, 0),
+    onUpdateRef = (0, import_react.useRef)(null),
+    node = (0, import_react.useMemo)(() => new import_AnimatedProps.AnimatedProps(props, () => onUpdateRef.current?.()), [props]);
+  useAnimatedPropsLifecycle(node);
+  const refEffect = (0, import_react.useCallback)(instance => {
+      node.setNativeView(instance), onUpdateRef.current = () => {
+        scheduleUpdate();
+      };
+      const target = getEventTarget(instance),
+        events = [];
+      for (const propName in props) {
+        const propValue = props[propName];
+        propValue instanceof import_AnimatedEvent.AnimatedEvent && propValue.__isNative && (propValue.__attach(target, propName), events.push([propName, propValue]));
+      }
+      return () => {
+        onUpdateRef.current = null;
+        for (const [propName, propValue] of events) propValue.__detach(target, propName);
+      };
+    }, [props, node]),
+    callbackRef = (0, import_useRefEffect.useRefEffect)(refEffect);
+  return [reduceAnimatedProps(node), callbackRef];
+}
+function reduceAnimatedProps(node) {
+  return {
+    ...node.__getValue(),
+    collapsable: !1
+  };
+}
+function useAnimatedPropsLifecycle(node) {
+  const prevNodeRef = (0, import_react.useRef)(null),
+    isUnmountingRef = (0, import_react.useRef)(!1);
+  (0, import_react.useEffect)(() => {
+    import_NativeAnimatedHelper.NativeAnimatedHelper.API.flushQueue();
+  }), (0, import_react_native_web_internals.useLayoutEffect)(() => (isUnmountingRef.current = !1, () => {
+    isUnmountingRef.current = !0;
+  }), []), (0, import_react_native_web_internals.useLayoutEffect)(() => {
+    if (node.__attach(), prevNodeRef.current != null) {
+      const prevNode = prevNodeRef.current;
+      prevNode.__restoreDefaultValues(), prevNode.__detach(), prevNodeRef.current = null;
+    }
+    return () => {
+      isUnmountingRef.current ? node.__detach() : prevNodeRef.current = node;
+    };
+  }, [node]);
+}
+function getEventTarget(instance) {
+  return typeof instance == "object" && typeof instance?.getScrollableNode == "function" ? instance.getScrollableNode() : instance;
+}
+var useAnimatedProps_default = useAnimatedProps;

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

@@ -0,0 +1,60 @@
+"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 Batchinator_exports = {};
+__export(Batchinator_exports, {
+  Batchinator: () => Batchinator,
+  default: () => Batchinator_default
+});
+module.exports = __toCommonJS(Batchinator_exports);
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+class Batchinator {
+  _callback;
+  _delay;
+  _taskHandle;
+  constructor(callback, delayMS) {
+    this._delay = delayMS, this._callback = callback;
+  }
+  /*
+   * Cleanup any pending tasks.
+   *
+   * By default, if there is a pending task the callback is run immediately. Set the option abort to
+   * true to not call the callback if it was pending.
+   */
+  dispose(options = {
+    abort: !1
+  }) {
+    this._taskHandle && (this._taskHandle.cancel(), options.abort || this._callback(), this._taskHandle = null);
+  }
+  schedule() {
+    if (this._taskHandle) return;
+    const timeoutHandle = setTimeout(() => {
+      this._taskHandle = import_react_native_web_internals.InteractionManager.runAfterInteractions(() => {
+        this._taskHandle = null, this._callback();
+      });
+    }, this._delay);
+    this._taskHandle = {
+      cancel: () => clearTimeout(timeoutHandle)
+    };
+  }
+}
+var Batchinator_default = Batchinator;

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

@@ -0,0 +1,61 @@
+"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 NativeEventEmitter_exports = {};
+__export(NativeEventEmitter_exports, {
+  NativeEventEmitter: () => NativeEventEmitter,
+  default: () => NativeEventEmitter_default
+});
+module.exports = __toCommonJS(NativeEventEmitter_exports);
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals"),
+  import_RCTDeviceEventEmitter = require("./RCTDeviceEventEmitter.cjs");
+class NativeEventEmitter {
+  _nativeModule;
+  constructor(nativeModule) {
+    import_react_native_web_internals.Platform.OS === "ios" && ((0, import_react_native_web_internals.invariant)(nativeModule != null, "`new NativeEventEmitter()` requires a non-null argument."), this._nativeModule = nativeModule);
+  }
+  addListener(eventType, listener, context) {
+    this._nativeModule?.addListener(eventType);
+    let subscription = import_RCTDeviceEventEmitter.RCTDeviceEventEmitter.addListener(eventType, listener, context);
+    return {
+      remove: () => {
+        subscription != null && (this._nativeModule?.removeListeners(1), subscription.remove(), subscription = null);
+      }
+    };
+  }
+  /**
+   * @deprecated Use `remove` on the EventSubscription from `addListener`.
+   */
+  removeListener(eventType, listener) {
+    this._nativeModule?.removeListeners(1), import_RCTDeviceEventEmitter.RCTDeviceEventEmitter.removeListener(eventType, listener);
+  }
+  emit(eventType, ...args) {
+    import_RCTDeviceEventEmitter.RCTDeviceEventEmitter.emit(eventType, ...args);
+  }
+  removeAllListeners(eventType) {
+    (0, import_react_native_web_internals.invariant)(eventType != null, "`NativeEventEmitter.removeAllListener()` requires a non-null argument."), this._nativeModule?.removeListeners(this.listenerCount(eventType)), import_RCTDeviceEventEmitter.RCTDeviceEventEmitter.removeAllListeners(eventType);
+  }
+  listenerCount(eventType) {
+    return import_RCTDeviceEventEmitter.RCTDeviceEventEmitter.listenerCount(eventType);
+  }
+}
+var NativeEventEmitter_default = NativeEventEmitter;

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

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

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

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

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

@@ -0,0 +1,139 @@
+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 FillRateHelper_exports = {};
+__export(FillRateHelper_exports, {
+  FillRateHelper: () => FillRateHelper,
+  default: () => FillRateHelper_default
+});
+module.exports = __toCommonJS(FillRateHelper_exports);
+class Info {
+  any_blank_count = 0;
+  any_blank_ms = 0;
+  any_blank_speed_sum = 0;
+  mostly_blank_count = 0;
+  mostly_blank_ms = 0;
+  pixels_blank = 0;
+  pixels_sampled = 0;
+  pixels_scrolled = 0;
+  total_time_spent = 0;
+  sample_count = 0;
+}
+const DEBUG = !1;
+let _listeners = [],
+  _minSampleCount = 10,
+  _sampleRate = DEBUG ? 1 : null;
+class FillRateHelper {
+  _anyBlankStartTime = null;
+  _enabled = !1;
+  _getFrameMetrics;
+  _info = new Info();
+  _mostlyBlankStartTime = null;
+  _samplesStartTime = null;
+  static addListener(callback) {
+    return _sampleRate === null && console.warn("Call `FillRateHelper.setSampleRate` before `addListener`."), _listeners.push(callback), {
+      remove: () => {
+        _listeners = _listeners.filter(listener => callback !== listener);
+      }
+    };
+  }
+  static setSampleRate(sampleRate) {
+    _sampleRate = sampleRate;
+  }
+  static setMinSampleCount(minSampleCount) {
+    _minSampleCount = minSampleCount;
+  }
+  constructor(getFrameMetrics) {
+    this._getFrameMetrics = getFrameMetrics, this._enabled = (_sampleRate || 0) > Math.random(), this._resetData();
+  }
+  activate() {
+    this._enabled && this._samplesStartTime == null && (DEBUG && console.debug("FillRateHelper: activate"), this._samplesStartTime = global.performance.now());
+  }
+  deactivateAndFlush() {
+    if (!this._enabled) return;
+    const start = this._samplesStartTime;
+    if (start == null) {
+      DEBUG && console.debug("FillRateHelper: bail on deactivate with no start time");
+      return;
+    }
+    if (this._info.sample_count < _minSampleCount) {
+      this._resetData();
+      return;
+    }
+    const total_time_spent = global.performance.now() - start,
+      info = {
+        ...this._info,
+        total_time_spent
+      };
+    if (DEBUG) {
+      const derived = {
+        avg_blankness: this._info.pixels_blank / this._info.pixels_sampled,
+        avg_speed: this._info.pixels_scrolled / (total_time_spent / 1e3),
+        avg_speed_when_any_blank: this._info.any_blank_speed_sum / this._info.any_blank_count,
+        any_blank_per_min: this._info.any_blank_count / (total_time_spent / 1e3 / 60),
+        any_blank_time_frac: this._info.any_blank_ms / total_time_spent,
+        mostly_blank_per_min: this._info.mostly_blank_count / (total_time_spent / 1e3 / 60),
+        mostly_blank_time_frac: this._info.mostly_blank_ms / total_time_spent
+      };
+      for (const key in derived) derived[key] = Math.round(1e3 * derived[key]) / 1e3;
+      console.debug("FillRateHelper deactivateAndFlush: ", {
+        derived,
+        info
+      });
+    }
+    _listeners.forEach(listener => listener(info)), this._resetData();
+  }
+  computeBlankness(props, cellsAroundViewport, scrollMetrics) {
+    if (!this._enabled || props.getItemCount(props.data) === 0 || cellsAroundViewport.last < cellsAroundViewport.first || this._samplesStartTime == null) return 0;
+    const {
+      dOffset,
+      offset,
+      velocity,
+      visibleLength
+    } = scrollMetrics;
+    this._info.sample_count++, this._info.pixels_sampled += Math.round(visibleLength), this._info.pixels_scrolled += Math.round(Math.abs(dOffset));
+    const scrollSpeed = Math.round(Math.abs(velocity) * 1e3),
+      now = global.performance.now();
+    this._anyBlankStartTime != null && (this._info.any_blank_ms += now - this._anyBlankStartTime), this._anyBlankStartTime = null, this._mostlyBlankStartTime != null && (this._info.mostly_blank_ms += now - this._mostlyBlankStartTime), this._mostlyBlankStartTime = null;
+    let blankTop = 0,
+      first = cellsAroundViewport.first,
+      firstFrame = this._getFrameMetrics(first, props);
+    for (; first <= cellsAroundViewport.last && (!firstFrame || !firstFrame.inLayout);) firstFrame = this._getFrameMetrics(first, props), first++;
+    firstFrame && first > 0 && (blankTop = Math.min(visibleLength, Math.max(0, firstFrame.offset - offset)));
+    let blankBottom = 0,
+      last = cellsAroundViewport.last,
+      lastFrame = this._getFrameMetrics(last, props);
+    for (; last >= cellsAroundViewport.first && (!lastFrame || !lastFrame.inLayout);) lastFrame = this._getFrameMetrics(last, props), last--;
+    if (lastFrame && last < props.getItemCount(props.data) - 1) {
+      const bottomEdge = lastFrame.offset + lastFrame.length;
+      blankBottom = Math.min(visibleLength, Math.max(0, offset + visibleLength - bottomEdge));
+    }
+    const pixels_blank = Math.round(blankTop + blankBottom),
+      blankness = pixels_blank / visibleLength;
+    return blankness > 0 ? (this._anyBlankStartTime = now, this._info.any_blank_speed_sum += scrollSpeed, this._info.any_blank_count++, this._info.pixels_blank += pixels_blank, blankness > 0.5 && (this._mostlyBlankStartTime = now, this._info.mostly_blank_count++)) : (scrollSpeed < 0.01 || Math.abs(dOffset) < 1) && this.deactivateAndFlush(), blankness;
+  }
+  enabled() {
+    return this._enabled;
+  }
+  _resetData() {
+    this._anyBlankStartTime = null, this._info = new Info(), this._mostlyBlankStartTime = null, this._samplesStartTime = null;
+  }
+}
+var FillRateHelper_default = FillRateHelper;

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

@@ -0,0 +1,263 @@
+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 FlatList_exports = {};
+__export(FlatList_exports, {
+  FlatList: () => FlatList,
+  default: () => FlatList_default
+});
+module.exports = __toCommonJS(FlatList_exports);
+var import_View = require("../../../View/index.cjs"),
+  import_deepDiffer = require("../deepDiffer/index.cjs"),
+  import_Platform = require("../../../exports/Platform"),
+  import_react_native_web_internals = require("@hanzogui/react-native-web-internals"),
+  React = __toESM(require("react"), 1),
+  import_VirtualizedList = require("../VirtualizedList/index.cjs"),
+  import_VirtualizeUtils = require("../VirtualizeUtils/index.cjs"),
+  import_memoize_one = __toESM(require("memoize-one"), 1),
+  import_jsx_runtime = require("react/jsx-runtime");
+function removeClippedSubviewsOrDefault(removeClippedSubviews) {
+  return removeClippedSubviews ?? import_Platform.Platform.OS === "android";
+}
+function numColumnsOrDefault(numColumns) {
+  return numColumns ?? 1;
+}
+function isArrayLike(data) {
+  return typeof Object(data).length == "number";
+}
+class FlatList extends React.PureComponent {
+  /**
+   * Scrolls to the end of the content. May be janky without `getItemLayout` prop.
+   */
+  scrollToEnd(params) {
+    this._listRef && this._listRef.scrollToEnd(params);
+  }
+  /**
+   * Scrolls to the item at the specified index such that it is positioned in the viewable area
+   * such that `viewPosition` 0 places it at the top, 1 at the bottom, and 0.5 centered in the
+   * middle. `viewOffset` is a fixed number of pixels to offset the final target position.
+   *
+   * Note: cannot scroll to locations outside the render window without specifying the
+   * `getItemLayout` prop.
+   */
+  scrollToIndex(params) {
+    this._listRef && this._listRef.scrollToIndex(params);
+  }
+  /**
+   * Requires linear scan through data - use `scrollToIndex` instead if possible.
+   *
+   * Note: cannot scroll to locations outside the render window without specifying the
+   * `getItemLayout` prop.
+   */
+  scrollToItem(params) {
+    this._listRef && this._listRef.scrollToItem(params);
+  }
+  /**
+   * Scroll to a specific content pixel offset in the list.
+   *
+   * Check out [scrollToOffset](docs/virtualizedlist.html#scrolltooffset) of VirtualizedList
+   */
+  scrollToOffset(params) {
+    this._listRef && this._listRef.scrollToOffset(params);
+  }
+  /**
+   * Tells the list an interaction has occurred, which should trigger viewability calculations, e.g.
+   * if `waitForInteractions` is true and the user has not scrolled. This is typically called by
+   * taps on items or by navigation actions.
+   */
+  recordInteraction() {
+    this._listRef && this._listRef.recordInteraction();
+  }
+  /**
+   * Displays the scroll indicators momentarily.
+   *
+   * @platform ios
+   */
+  flashScrollIndicators() {
+    this._listRef && this._listRef.flashScrollIndicators();
+  }
+  /**
+   * Provides a handle to the underlying scroll responder.
+   */
+  getScrollResponder() {
+    if (this._listRef) return this._listRef.getScrollResponder();
+  }
+  /**
+   * Provides a reference to the underlying host component
+   */
+  getNativeScrollRef() {
+    if (this._listRef) return this._listRef.getScrollRef();
+  }
+  getScrollableNode() {
+    if (this._listRef) return this._listRef.getScrollableNode();
+  }
+  constructor(props) {
+    super(props), this._checkProps(this.props), this.props.viewabilityConfigCallbackPairs ? this._virtualizedListPairs = this.props.viewabilityConfigCallbackPairs.map(pair => ({
+      viewabilityConfig: pair.viewabilityConfig,
+      onViewableItemsChanged: this._createOnViewableItemsChanged(pair.onViewableItemsChanged)
+    })) : this.props.onViewableItemsChanged && this._virtualizedListPairs.push({
+      viewabilityConfig: this.props.viewabilityConfig,
+      onViewableItemsChanged: this._createOnViewableItemsChanged(this.props.onViewableItemsChanged)
+    });
+  }
+  componentDidUpdate(prevProps) {
+    (0, import_react_native_web_internals.invariant)(prevProps.numColumns === this.props.numColumns, "Changing numColumns on the fly is not supported. Change the key prop on FlatList when changing the number of columns to force a fresh render of the component."), (0, import_react_native_web_internals.invariant)(prevProps.onViewableItemsChanged === this.props.onViewableItemsChanged, "Changing onViewableItemsChanged on the fly is not supported"), (0, import_react_native_web_internals.invariant)(!(0, import_deepDiffer.deepDiffer)(prevProps.viewabilityConfig, this.props.viewabilityConfig), "Changing viewabilityConfig on the fly is not supported"), (0, import_react_native_web_internals.invariant)(prevProps.viewabilityConfigCallbackPairs === this.props.viewabilityConfigCallbackPairs, "Changing viewabilityConfigCallbackPairs on the fly is not supported"), this._checkProps(this.props);
+  }
+  _listRef;
+  _virtualizedListPairs = [];
+  _captureRef = ref => {
+    this._listRef = ref;
+  };
+  _checkProps(props) {
+    const {
+        getItem,
+        getItemCount,
+        horizontal,
+        columnWrapperStyle,
+        onViewableItemsChanged,
+        viewabilityConfigCallbackPairs
+      } = props,
+      numColumns = numColumnsOrDefault(this.props.numColumns);
+    (0, import_react_native_web_internals.invariant)(!getItem && !getItemCount, "FlatList does not support custom data formats."), numColumns > 1 ? (0, import_react_native_web_internals.invariant)(!horizontal, "numColumns does not support horizontal.") : (0, import_react_native_web_internals.invariant)(!columnWrapperStyle, "columnWrapperStyle not supported for single column lists"), (0, import_react_native_web_internals.invariant)(!(onViewableItemsChanged && viewabilityConfigCallbackPairs), "FlatList does not support setting both onViewableItemsChanged and viewabilityConfigCallbackPairs.");
+  }
+  _getItem = (data, index) => {
+    const numColumns = numColumnsOrDefault(this.props.numColumns);
+    if (numColumns > 1) {
+      const ret = [];
+      for (let kk = 0; kk < numColumns; kk++) {
+        const itemIndex = index * numColumns + kk;
+        if (itemIndex < data.length) {
+          const item = data[itemIndex];
+          ret.push(item);
+        }
+      }
+      return ret;
+    } else return data[index];
+  };
+  _getItemCount = data => {
+    if (data != null && isArrayLike(data)) {
+      const numColumns = numColumnsOrDefault(this.props.numColumns);
+      return numColumns > 1 ? Math.ceil(data.length / numColumns) : data.length;
+    } else return 0;
+  };
+  _keyExtractor = (items, index) => {
+    const numColumns = numColumnsOrDefault(this.props.numColumns),
+      keyExtractor = this.props.keyExtractor ?? import_VirtualizeUtils.keyExtractor;
+    return numColumns > 1 ? ((0, import_react_native_web_internals.invariant)(Array.isArray(items), "FlatList: Encountered internal consistency error, expected each item to consist of an array with 1-%s columns; instead, received a single item.", numColumns), items.map((item, kk) => keyExtractor(item, index * numColumns + kk)).join(":")) : keyExtractor(items, index);
+  };
+  _pushMultiColumnViewable(arr, v) {
+    const numColumns = numColumnsOrDefault(this.props.numColumns),
+      keyExtractor = this.props.keyExtractor ?? import_VirtualizeUtils.keyExtractor;
+    v.item.forEach((item, ii) => {
+      (0, import_react_native_web_internals.invariant)(v.index != null, "Missing index!");
+      const index = v.index * numColumns + ii;
+      arr.push({
+        ...v,
+        item,
+        key: keyExtractor(item, index),
+        index
+      });
+    });
+  }
+  _createOnViewableItemsChanged(onViewableItemsChanged) {
+    return info => {
+      const numColumns = numColumnsOrDefault(this.props.numColumns);
+      if (onViewableItemsChanged) if (numColumns > 1) {
+        const changed = [],
+          viewableItems = [];
+        info.viewableItems.forEach(v => this._pushMultiColumnViewable(viewableItems, v)), info.changed.forEach(v => this._pushMultiColumnViewable(changed, v)), onViewableItemsChanged({
+          viewableItems,
+          changed
+        });
+      } else onViewableItemsChanged(info);
+    };
+  }
+  _renderer = (ListItemComponent, renderItem, columnWrapperStyle, numColumns, extraData) => {
+    const cols = numColumnsOrDefault(numColumns),
+      render = props => ListItemComponent ? /* @__PURE__ */(0, import_jsx_runtime.jsx)(ListItemComponent, {
+        ...props
+      }) : renderItem ? renderItem(props) : null,
+      renderProp = info => {
+        if (cols > 1) {
+          const {
+            item,
+            index
+          } = info;
+          return (0, import_react_native_web_internals.invariant)(Array.isArray(item), "Expected array of items with numColumns > 1"), /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_View.View, {
+            style: [styles.row, columnWrapperStyle],
+            children: item.map((it, kk) => {
+              const element = render({
+                item: it,
+                index: index * cols + kk,
+                separators: info.separators
+              });
+              return element != null ? /* @__PURE__ */(0, import_jsx_runtime.jsx)(React.Fragment, {
+                children: element
+              }, kk) : null;
+            })
+          });
+        } else return render(info);
+      };
+    return ListItemComponent ? {
+      ListItemComponent: renderProp
+    } : {
+      renderItem: renderProp
+    };
+  };
+  // $FlowFixMe[missing-local-annot]
+  _memoizedRenderer = (0, import_memoize_one.default)(this._renderer);
+  render() {
+    const {
+        numColumns,
+        columnWrapperStyle,
+        removeClippedSubviews: _removeClippedSubviews,
+        strictMode = !1,
+        ...restProps
+      } = this.props,
+      renderer = strictMode ? this._memoizedRenderer : this._renderer;
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_VirtualizedList.VirtualizedList, {
+      ...restProps,
+      getItem: this._getItem,
+      getItemCount: this._getItemCount,
+      keyExtractor: this._keyExtractor,
+      ref: this._captureRef,
+      viewabilityConfigCallbackPairs: this._virtualizedListPairs,
+      removeClippedSubviews: removeClippedSubviewsOrDefault(_removeClippedSubviews),
+      ...renderer(this.props.ListItemComponent, this.props.renderItem, columnWrapperStyle, numColumns, this.props.extraData)
+    });
+  }
+}
+const styles = import_react_native_web_internals.StyleSheet.create({
+  row: {
+    flexDirection: "row"
+  }
+});
+var FlatList_default = FlatList;