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

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedValue.cjs

@@ -0,0 +1,239 @@
+"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 AnimatedValue_exports = {};
+__export(AnimatedValue_exports, {
+  AnimatedValue: () => AnimatedValue,
+  default: () => AnimatedValue_default
+});
+module.exports = __toCommonJS(AnimatedValue_exports);
+var import_AnimatedInterpolation = require("./AnimatedInterpolation.cjs");
+var import_AnimatedWithChildren = require("./AnimatedWithChildren.cjs");
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+var import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs");
+const NativeAnimatedAPI = import_NativeAnimatedHelper.NativeAnimatedHelper.API;
+function _flush(rootNode) {
+  const animatedStyles = /* @__PURE__ */new Set();
+  function findAnimatedStyles(node) {
+    if (typeof node.update === "function") {
+      animatedStyles.add(node);
+    } else {
+      node.__getChildren().forEach(findAnimatedStyles);
+    }
+  }
+  findAnimatedStyles(rootNode);
+  animatedStyles.forEach(animatedStyle => animatedStyle.update());
+}
+function _executeAsAnimatedBatch(id, operation) {
+  NativeAnimatedAPI.setWaitingForIdentifier(id);
+  operation();
+  NativeAnimatedAPI.unsetWaitingForIdentifier(id);
+}
+class AnimatedValue extends import_AnimatedWithChildren.AnimatedWithChildren {
+  _value;
+  _startingValue;
+  _offset;
+  _animation;
+  _tracking;
+  constructor(value, config) {
+    super();
+    if (typeof value !== "number") {
+      throw new Error("AnimatedValue: Attempting to set value to undefined");
+    }
+    this._startingValue = this._value = value;
+    this._offset = 0;
+    this._animation = null;
+    if (config && config.useNativeDriver) {
+      this.__makeNative();
+    }
+  }
+  __detach() {
+    if (this.__isNative) {
+      NativeAnimatedAPI.getValue(this.__getNativeTag(), value => {
+        this._value = value - this._offset;
+      });
+    }
+    this.stopAnimation();
+    super.__detach();
+  }
+  __getValue() {
+    return this._value + this._offset;
+  }
+  /**
+   * Directly set the value.  This will stop any animations running on the value
+   * and update all the bound properties.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#setvalue
+   */
+  setValue(value) {
+    if (this._animation) {
+      this._animation.stop();
+      this._animation = null;
+    }
+    this._updateValue(value, !this.__isNative
+    /* don't perform a flush for natively driven values */);
+    if (this.__isNative) {
+      _executeAsAnimatedBatch(this.__getNativeTag().toString(), () => NativeAnimatedAPI.setAnimatedNodeValue(this.__getNativeTag(), value));
+    }
+  }
+  /**
+   * Sets an offset that is applied on top of whatever value is set, whether via
+   * `setValue`, an animation, or `Animated.event`.  Useful for compensating
+   * things like the start of a pan gesture.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#setoffset
+   */
+  setOffset(offset) {
+    this._offset = offset;
+    if (this.__isNative) {
+      NativeAnimatedAPI.setAnimatedNodeOffset(this.__getNativeTag(), offset);
+    }
+  }
+  /**
+   * Merges the offset value into the base value and resets the offset to zero.
+   * The final output of the value is unchanged.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#flattenoffset
+   */
+  flattenOffset() {
+    this._value += this._offset;
+    this._offset = 0;
+    if (this.__isNative) {
+      NativeAnimatedAPI.flattenAnimatedNodeOffset(this.__getNativeTag());
+    }
+  }
+  /**
+   * Sets the offset value to the base value, and resets the base value to zero.
+   * The final output of the value is unchanged.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#extractoffset
+   */
+  extractOffset() {
+    this._offset += this._value;
+    this._value = 0;
+    if (this.__isNative) {
+      NativeAnimatedAPI.extractAnimatedNodeOffset(this.__getNativeTag());
+    }
+  }
+  /**
+   * Stops any running animation or tracking. `callback` is invoked with the
+   * final value after stopping the animation, which is useful for updating
+   * state to match the animation position with layout.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#stopanimation
+   */
+  stopAnimation(callback) {
+    this.stopTracking();
+    this._animation && this._animation.stop();
+    this._animation = null;
+    if (callback) {
+      if (this.__isNative) {
+        NativeAnimatedAPI.getValue(this.__getNativeTag(), callback);
+      } else {
+        callback(this.__getValue());
+      }
+    }
+  }
+  /**
+   * Stops any animation and resets the value to its original.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#resetanimation
+   */
+  resetAnimation(callback) {
+    this.stopAnimation(callback);
+    this._value = this._startingValue;
+    if (this.__isNative) {
+      NativeAnimatedAPI.setAnimatedNodeValue(this.__getNativeTag(), this._startingValue);
+    }
+  }
+  __onAnimatedValueUpdateReceived(value) {
+    this._updateValue(value, false
+    /*flush*/);
+  }
+  /**
+   * Interpolates the value before updating the property, e.g. mapping 0-1 to
+   * 0-10.
+   */
+  interpolate(config) {
+    return new import_AnimatedInterpolation.AnimatedInterpolation(this, config);
+  }
+  /**
+   * Typically only used internally, but could be used by a custom Animation
+   * class.
+   *
+   * See https://reactnative.dev/docs/animatedvalue#animate
+   */
+  animate(animation, callback) {
+    let handle = null;
+    if (animation.__isInteraction) {
+      handle = import_react_native_web_internals.InteractionManager.createInteractionHandle();
+    }
+    const previousAnimation = this._animation;
+    this._animation && this._animation.stop();
+    this._animation = animation;
+    animation.start(this._value, value => {
+      this._updateValue(value, true
+      /* flush */);
+    }, result => {
+      this._animation = null;
+      if (handle !== null) {
+        import_react_native_web_internals.InteractionManager.clearInteractionHandle(handle);
+      }
+      callback && callback(result);
+    }, previousAnimation, this);
+  }
+  /**
+   * Typically only used internally.
+   */
+  stopTracking() {
+    this._tracking && this._tracking.__detach();
+    this._tracking = null;
+  }
+  /**
+   * Typically only used internally.
+   */
+  track(tracking) {
+    this.stopTracking();
+    this._tracking = tracking;
+    this._tracking && this._tracking.update();
+  }
+  _updateValue(value, flush) {
+    if (value === void 0) {
+      throw new Error("AnimatedValue: Attempting to set value to undefined");
+    }
+    this._value = value;
+    if (flush) {
+      _flush(this);
+    }
+    super.__callListeners(this.__getValue());
+  }
+  __getNativeConfig() {
+    return {
+      type: "value",
+      value: this._value,
+      offset: this._offset
+    };
+  }
+}
+var AnimatedValue_default = AnimatedValue;

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedValueXY.cjs

@@ -0,0 +1,119 @@
+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 AnimatedValueXY_exports = {};
+__export(AnimatedValueXY_exports, {
+  AnimatedValueXY: () => AnimatedValueXY,
+  default: () => AnimatedValueXY_default
+});
+module.exports = __toCommonJS(AnimatedValueXY_exports);
+var import_AnimatedValue = require("./AnimatedValue.cjs");
+var import_AnimatedWithChildren = require("./AnimatedWithChildren.cjs");
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+let _uniqueId = 1;
+class AnimatedValueXY extends import_AnimatedWithChildren.AnimatedWithChildren {
+  constructor(valueIn) {
+    super();
+    const value = valueIn || {
+      x: 0,
+      y: 0
+    };
+    if (typeof value.x === "number" && typeof value.y === "number") {
+      this.x = new import_AnimatedValue.AnimatedValue(value.x);
+      this.y = new import_AnimatedValue.AnimatedValue(value.y);
+    } else {
+      (0, import_react_native_web_internals.invariant)(value.x instanceof import_AnimatedValue.AnimatedValue && value.y instanceof import_AnimatedValue.AnimatedValue, "AnimatedValueXY must be initialized with an object of numbers or AnimatedValues.");
+      this.x = value.x;
+      this.y = value.y;
+    }
+    this._listeners = {};
+  }
+  setValue(value) {
+    this.x.setValue(value.x);
+    this.y.setValue(value.y);
+  }
+  setOffset(offset) {
+    this.x.setOffset(offset.x);
+    this.y.setOffset(offset.y);
+  }
+  flattenOffset() {
+    this.x.flattenOffset();
+    this.y.flattenOffset();
+  }
+  extractOffset() {
+    this.x.extractOffset();
+    this.y.extractOffset();
+  }
+  __getValue() {
+    return {
+      x: this.x.__getValue(),
+      y: this.y.__getValue()
+    };
+  }
+  resetAnimation(callback) {
+    this.x.resetAnimation();
+    this.y.resetAnimation();
+    callback && callback(this.__getValue());
+  }
+  stopAnimation(callback) {
+    this.x.stopAnimation();
+    this.y.stopAnimation();
+    callback && callback(this.__getValue());
+  }
+  addListener(callback) {
+    const id = String(_uniqueId++);
+    const jointCallback = ({
+      value
+    }) => {
+      callback(this.__getValue());
+    };
+    this._listeners[id] = {
+      x: this.x.addListener(jointCallback),
+      y: this.y.addListener(jointCallback)
+    };
+    return id;
+  }
+  removeListener(id) {
+    this.x.removeListener(this._listeners[id].x);
+    this.y.removeListener(this._listeners[id].y);
+    delete this._listeners[id];
+  }
+  removeAllListeners() {
+    this.x.removeAllListeners();
+    this.y.removeAllListeners();
+    this._listeners = {};
+  }
+  getLayout() {
+    return {
+      left: this.x,
+      top: this.y
+    };
+  }
+  getTranslateTransform() {
+    return [{
+      translateX: this.x
+    }, {
+      translateY: this.y
+    }];
+  }
+}
+var AnimatedValueXY_default = AnimatedValueXY;

package/dist/cjs/vendor/react-native/Animated/nodes/AnimatedWithChildren.cjs

@@ -0,0 +1,87 @@
+"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 AnimatedWithChildren_exports = {};
+__export(AnimatedWithChildren_exports, {
+  AnimatedWithChildren: () => AnimatedWithChildren,
+  default: () => AnimatedWithChildren_default
+});
+module.exports = __toCommonJS(AnimatedWithChildren_exports);
+var import_AnimatedNode = require("./AnimatedNode.cjs");
+var import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs");
+class AnimatedWithChildren extends import_AnimatedNode.AnimatedNode {
+  _children;
+  constructor() {
+    super();
+    this._children = [];
+  }
+  __makeNative(platformConfig) {
+    if (!this.__isNative) {
+      this.__isNative = true;
+      for (const child of this._children) {
+        child.__makeNative(platformConfig);
+        import_NativeAnimatedHelper.NativeAnimatedHelper.API.connectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
+      }
+    }
+    super.__makeNative(platformConfig);
+  }
+  __addChild(child) {
+    if (this._children.length === 0) {
+      this.__attach();
+    }
+    this._children.push(child);
+    if (this.__isNative) {
+      child.__makeNative(this.__getPlatformConfig());
+      import_NativeAnimatedHelper.NativeAnimatedHelper.API.connectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
+    }
+  }
+  __removeChild(child) {
+    const index = this._children.indexOf(child);
+    if (index === -1) {
+      console.warn("Trying to remove a child that doesn't exist");
+      return;
+    }
+    if (this.__isNative && child.__isNative) {
+      import_NativeAnimatedHelper.NativeAnimatedHelper.API.disconnectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
+    }
+    this._children.splice(index, 1);
+    if (this._children.length === 0) {
+      this.__detach();
+    }
+  }
+  __getChildren() {
+    return this._children;
+  }
+  __callListeners(value) {
+    super.__callListeners(value);
+    if (!this.__isNative) {
+      for (const child of this._children) {
+        if (child.__getValue) {
+          child.__callListeners(child.__getValue());
+        }
+      }
+    }
+  }
+}
+var AnimatedWithChildren_default = AnimatedWithChildren;

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

@@ -0,0 +1,104 @@
+"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 useAnimatedProps_exports = {};
+__export(useAnimatedProps_exports, {
+  default: () => useAnimatedProps_default,
+  useAnimatedProps: () => useAnimatedProps
+});
+module.exports = __toCommonJS(useAnimatedProps_exports);
+var import_AnimatedProps = require("./nodes/AnimatedProps.cjs");
+var import_AnimatedEvent = require("./AnimatedEvent.cjs");
+var import_useRefEffect = require("../Utilities/useRefEffect.cjs");
+var import_NativeAnimatedHelper = require("./NativeAnimatedHelper.cjs");
+var import_react = require("react");
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+function useAnimatedProps(props) {
+  const [, scheduleUpdate] = (0, import_react.useReducer)(count => count + 1, 0);
+  const onUpdateRef = (0, import_react.useRef)(null);
+  const 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);
+    const events = [];
+    for (const propName in props) {
+      const propValue = props[propName];
+      if (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]);
+  const callbackRef = (0, import_useRefEffect.useRefEffect)(refEffect);
+  return [reduceAnimatedProps(node), callbackRef];
+}
+function reduceAnimatedProps(node) {
+  return {
+    ...node.__getValue(),
+    collapsable: false
+  };
+}
+function useAnimatedPropsLifecycle(node) {
+  const prevNodeRef = (0, import_react.useRef)(null);
+  const isUnmountingRef = (0, import_react.useRef)(false);
+  (0, import_react.useEffect)(() => {
+    import_NativeAnimatedHelper.NativeAnimatedHelper.API.flushQueue();
+  });
+  (0, import_react_native_web_internals.useLayoutEffect)(() => {
+    isUnmountingRef.current = false;
+    return () => {
+      isUnmountingRef.current = true;
+    };
+  }, []);
+  (0, import_react_native_web_internals.useLayoutEffect)(() => {
+    node.__attach();
+    if (prevNodeRef.current != null) {
+      const prevNode = prevNodeRef.current;
+      prevNode.__restoreDefaultValues();
+      prevNode.__detach();
+      prevNodeRef.current = null;
+    }
+    return () => {
+      if (isUnmountingRef.current) {
+        node.__detach();
+      } else {
+        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,72 @@
+"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 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: false
+  }) {
+    if (this._taskHandle) {
+      this._taskHandle.cancel();
+      if (!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,73 @@
+"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 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");
+var import_RCTDeviceEventEmitter = require("./RCTDeviceEventEmitter.cjs");
+class NativeEventEmitter {
+  _nativeModule;
+  constructor(nativeModule) {
+    if (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: () => {
+        if (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;