@hanzogui/react-native-web-lite 2.0.0-rc.41-hanzoai.5

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

@@ -0,0 +1,31 @@
+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: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__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: true
+}), 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,35 @@
+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: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__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: true
+}), mod);
+var FeatureFlags_exports = {};
+__export(FeatureFlags_exports, {
+  ReactNativeFeatureFlags: () => ReactNativeFeatureFlags
+});
+module.exports = __toCommonJS(FeatureFlags_exports);
+const ReactNativeFeatureFlags = {
+  isLayoutAnimationEnabled: () => true,
+  shouldEmitW3CPointerEvents: () => false,
+  shouldPressibilityUseW3CPointerEventsForHover: () => false,
+  animatedShouldDebounceQueueFlush: () => false,
+  animatedShouldUseSingleOp: () => false,
+  enableCppComponents: () => false
+};

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

@@ -0,0 +1,189 @@
+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: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__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: true
+}), 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 = false;
+let _listeners = [];
+let _minSampleCount = 10;
+let _sampleRate = DEBUG ? 1 : null;
+class FillRateHelper {
+  _anyBlankStartTime = null;
+  _enabled = false;
+  _getFrameMetrics;
+  _info = new Info();
+  _mostlyBlankStartTime = null;
+  _samplesStartTime = null;
+  static addListener(callback) {
+    if (_sampleRate === null) {
+      console.warn("Call `FillRateHelper.setSampleRate` before `addListener`.");
+    }
+    _listeners.push(callback);
+    return {
+      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() {
+    if (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;
+    const 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);
+    const now = global.performance.now();
+    if (this._anyBlankStartTime != null) {
+      this._info.any_blank_ms += now - this._anyBlankStartTime;
+    }
+    this._anyBlankStartTime = null;
+    if (this._mostlyBlankStartTime != null) {
+      this._info.mostly_blank_ms += now - this._mostlyBlankStartTime;
+    }
+    this._mostlyBlankStartTime = null;
+    let blankTop = 0;
+    let first = cellsAroundViewport.first;
+    let firstFrame = this._getFrameMetrics(first, props);
+    while (first <= cellsAroundViewport.last && (!firstFrame || !firstFrame.inLayout)) {
+      firstFrame = this._getFrameMetrics(first, props);
+      first++;
+    }
+    if (firstFrame && first > 0) {
+      blankTop = Math.min(visibleLength, Math.max(0, firstFrame.offset - offset));
+    }
+    let blankBottom = 0;
+    let last = cellsAroundViewport.last;
+    let lastFrame = this._getFrameMetrics(last, props);
+    while (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);
+    const blankness = pixels_blank / visibleLength;
+    if (blankness > 0) {
+      this._anyBlankStartTime = now;
+      this._info.any_blank_speed_sum += scrollSpeed;
+      this._info.any_blank_count++;
+      this._info.pixels_blank += pixels_blank;
+      if (blankness > 0.5) {
+        this._mostlyBlankStartTime = now;
+        this._info.mostly_blank_count++;
+      }
+    } else if (scrollSpeed < 0.01 || Math.abs(dOffset) < 1) {
+      this.deactivateAndFlush();
+    }
+    return 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,324 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__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: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var FlatList_exports = {};
+__export(FlatList_exports, {
+  FlatList: () => FlatList,
+  default: () => FlatList_default
+});
+module.exports = __toCommonJS(FlatList_exports);
+var import_View = require("../../../View/index.cjs");
+var import_deepDiffer = require("../deepDiffer/index.cjs");
+var import_Platform = require("../../../exports/Platform");
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+var React = __toESM(require("react"), 1);
+var import_VirtualizedList = require("../VirtualizedList/index.cjs");
+var import_VirtualizeUtils = require("../VirtualizeUtils/index.cjs");
+var import_memoize_one = __toESM(require("memoize-one"), 1);
+var 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) {
+    if (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) {
+    if (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) {
+    if (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) {
+    if (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() {
+    if (this._listRef) {
+      this._listRef.recordInteraction();
+    }
+  }
+  /**
+   * Displays the scroll indicators momentarily.
+   *
+   * @platform ios
+   */
+  flashScrollIndicators() {
+    if (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);
+    if (this.props.viewabilityConfigCallbackPairs) {
+      this._virtualizedListPairs = this.props.viewabilityConfigCallbackPairs.map(pair => ({
+        viewabilityConfig: pair.viewabilityConfig,
+        onViewableItemsChanged: this._createOnViewableItemsChanged(pair.onViewableItemsChanged)
+      }));
+    } else if (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;
+    const numColumns = numColumnsOrDefault(this.props.numColumns);
+    (0, import_react_native_web_internals.invariant)(!getItem && !getItemCount, "FlatList does not support custom data formats.");
+    if (numColumns > 1) {
+      (0, import_react_native_web_internals.invariant)(!horizontal, "numColumns does not support horizontal.");
+    } else {
+      (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);
+    const keyExtractor = this.props.keyExtractor ?? import_VirtualizeUtils.keyExtractor;
+    if (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);
+      return items.map((item, kk) => keyExtractor(item, index * numColumns + kk)).join(":");
+    }
+    return keyExtractor(items, index);
+  };
+  _pushMultiColumnViewable(arr, v) {
+    const numColumns = numColumnsOrDefault(this.props.numColumns);
+    const 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 = [];
+          const 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);
+    const render = props => {
+      if (ListItemComponent) {
+        return /* @__PURE__ */(0, import_jsx_runtime.jsx)(ListItemComponent, {
+          ...props
+        });
+      } else if (renderItem) {
+        return renderItem(props);
+      } else {
+        return null;
+      }
+    };
+    const renderProp = info => {
+      if (cols > 1) {
+        const {
+          item,
+          index
+        } = info;
+        (0, import_react_native_web_internals.invariant)(Array.isArray(item), "Expected array of items with numColumns > 1");
+        return /* @__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 = false,
+      ...restProps
+    } = this.props;
+    const 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;

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

@@ -0,0 +1,93 @@
+"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: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__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: true
+}), 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
+  }) {
+    acceptableBusyTime = thresholdMS;
+    if (installed) {
+      return;
+    }
+    installed = true;
+    lastInterval = window.performance.now();
+    function iteration() {
+      const now = window.performance.now();
+      const 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;
+let installed = false;
+let totalStallTime = 0;
+let stallCount = 0;
+let longestStall = 0;
+let lastInterval = 0;
+const handlers = [];
+var JSEventLoopWatchdog_default = JSEventLoopWatchdog;