initial commit

node_modules/unenv/runtime/node/events/_events.cjs

@@ -0,0 +1,496 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EventEmitter = EventEmitter;
+exports.once = once;
+const R = typeof Reflect === "object" ? Reflect : null;
+const ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {
+  return Function.prototype.apply.call(target, receiver, args);
+};
+let ReflectOwnKeys;
+
+if (R && typeof R.ownKeys === "function") {
+  ReflectOwnKeys = R.ownKeys;
+} else if (Object.getOwnPropertySymbols) {
+  ReflectOwnKeys = function ReflectOwnKeys2(target) {
+    return [...Object.getOwnPropertyNames(target), ...Object.getOwnPropertySymbols(target)];
+  };
+} else {
+  ReflectOwnKeys = function ReflectOwnKeys2(target) {
+    return Object.getOwnPropertyNames(target);
+  };
+}
+
+function ProcessEmitWarning(warning) {
+  if (console && console.warn) {
+    console.warn(warning);
+  }
+}
+
+const NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
+  return value !== value;
+};
+
+function EventEmitter() {
+  EventEmitter.init.call(this);
+}
+
+EventEmitter.EventEmitter = EventEmitter;
+EventEmitter.prototype._events = void 0;
+EventEmitter.prototype._eventsCount = 0;
+EventEmitter.prototype._maxListeners = void 0;
+let defaultMaxListeners = 10;
+
+function checkListener(listener) {
+  if (typeof listener !== "function") {
+    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+  }
+}
+
+Object.defineProperty(EventEmitter, "defaultMaxListeners", {
+  enumerable: true,
+  get: function () {
+    return defaultMaxListeners;
+  },
+  set: function (arg) {
+    if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
+      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
+    }
+
+    defaultMaxListeners = arg;
+  }
+});
+
+EventEmitter.init = function () {
+  if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
+    this._events = /* @__PURE__ */Object.create(null);
+    this._eventsCount = 0;
+  }
+
+  this._maxListeners = this._maxListeners || void 0;
+};
+
+EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+  if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
+    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
+  }
+
+  this._maxListeners = n;
+  return this;
+};
+
+function _getMaxListeners(that) {
+  if (that._maxListeners === void 0) {
+    return EventEmitter.defaultMaxListeners;
+  }
+
+  return that._maxListeners;
+}
+
+EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+  return _getMaxListeners(this);
+};
+
+EventEmitter.prototype.emit = function emit(type) {
+  const args = [];
+
+  for (let i = 1; i < arguments.length; i++) {
+    args.push(arguments[i]);
+  }
+
+  let doError = type === "error";
+  const events = this._events;
+
+  if (events !== void 0) {
+    doError = doError && events.error === void 0;
+  } else if (!doError) {
+    return false;
+  }
+
+  if (doError) {
+    let er;
+
+    if (args.length > 0) {
+      er = args[0];
+    }
+
+    if (er instanceof Error) {
+      throw er;
+    }
+
+    const err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
+    err.context = er;
+    throw err;
+  }
+
+  const handler = events[type];
+
+  if (handler === void 0) {
+    return false;
+  }
+
+  if (typeof handler === "function") {
+    ReflectApply(handler, this, args);
+  } else {
+    const len = handler.length;
+    const listeners2 = arrayClone(handler, len);
+
+    for (let i = 0; i < len; ++i) {
+      ReflectApply(listeners2[i], this, args);
+    }
+  }
+
+  return true;
+};
+
+function _addListener(target, type, listener, prepend) {
+  let m;
+  let events;
+  let existing;
+  checkListener(listener);
+  events = target._events;
+
+  if (events === void 0) {
+    events = target._events = /* @__PURE__ */Object.create(null);
+    target._eventsCount = 0;
+  } else {
+    if (events.newListener !== void 0) {
+      target.emit("newListener", type, listener.listener ? listener.listener : listener);
+      events = target._events;
+    }
+
+    existing = events[type];
+  }
+
+  if (existing === void 0) {
+    existing = events[type] = listener;
+    ++target._eventsCount;
+  } else {
+    if (typeof existing === "function") {
+      existing = events[type] = prepend ? [listener, existing] : [existing, listener];
+    } else if (prepend) {
+      existing.unshift(listener);
+    } else {
+      existing.push(listener);
+    }
+
+    m = _getMaxListeners(target);
+
+    if (m > 0 && existing.length > m && !existing.warned) {
+      existing.warned = true;
+      const w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+      w.name = "MaxListenersExceededWarning";
+      w.emitter = target;
+      w.type = type;
+      w.count = existing.length;
+      ProcessEmitWarning(w);
+    }
+  }
+
+  return target;
+}
+
+EventEmitter.prototype.addListener = function addListener(type, listener) {
+  return _addListener(this, type, listener, false);
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.prependListener = function prependListener(type, listener) {
+  return _addListener(this, type, listener, true);
+};
+
+function onceWrapper() {
+  if (!this.fired) {
+    this.target.removeListener(this.type, this.wrapFn);
+    this.fired = true;
+
+    if (arguments.length === 0) {
+      return this.listener.call(this.target);
+    }
+
+    return this.listener.apply(this.target, arguments);
+  }
+}
+
+function _onceWrap(target, type, listener) {
+  const state = {
+    fired: false,
+    wrapFn: void 0,
+    target,
+    type,
+    listener
+  };
+  const wrapped = onceWrapper.bind(state);
+  wrapped.listener = listener;
+  state.wrapFn = wrapped;
+  return wrapped;
+}
+
+EventEmitter.prototype.once = function once2(type, listener) {
+  checkListener(listener);
+  this.on(type, _onceWrap(this, type, listener));
+  return this;
+};
+
+EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
+  checkListener(listener);
+  this.prependListener(type, _onceWrap(this, type, listener));
+  return this;
+};
+
+EventEmitter.prototype.removeListener = function removeListener(type, listener) {
+  let position, i, originalListener;
+  checkListener(listener);
+  const events = this._events;
+
+  if (events === void 0) {
+    return this;
+  }
+
+  const list = events[type];
+
+  if (list === void 0) {
+    return this;
+  }
+
+  if (list === listener || list.listener === listener) {
+    if (--this._eventsCount === 0) {
+      this._events = /* @__PURE__ */Object.create(null);
+    } else {
+      delete events[type];
+
+      if (events.removeListener) {
+        this.emit("removeListener", type, list.listener || listener);
+      }
+    }
+  } else if (typeof list !== "function") {
+    position = -1;
+
+    for (i = list.length - 1; i >= 0; i--) {
+      if (list[i] === listener || list[i].listener === listener) {
+        originalListener = list[i].listener;
+        position = i;
+        break;
+      }
+    }
+
+    if (position < 0) {
+      return this;
+    }
+
+    if (position === 0) {
+      list.shift();
+    } else {
+      spliceOne(list, position);
+    }
+
+    if (list.length === 1) {
+      events[type] = list[0];
+    }
+
+    if (events.removeListener !== void 0) {
+      this.emit("removeListener", type, originalListener || listener);
+    }
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+
+EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
+  let i;
+  const events = this._events;
+
+  if (events === void 0) {
+    return this;
+  }
+
+  if (events.removeListener === void 0) {
+    if (arguments.length === 0) {
+      this._events = /* @__PURE__ */Object.create(null);
+      this._eventsCount = 0;
+    } else if (events[type] !== void 0) {
+      if (--this._eventsCount === 0) {
+        this._events = /* @__PURE__ */Object.create(null);
+      } else {
+        delete events[type];
+      }
+    }
+
+    return this;
+  }
+
+  if (arguments.length === 0) {
+    const keys = Object.keys(events);
+    let key;
+
+    for (i = 0; i < keys.length; ++i) {
+      key = keys[i];
+
+      if (key === "removeListener") {
+        continue;
+      }
+
+      this.removeAllListeners(key);
+    }
+
+    this.removeAllListeners("removeListener");
+    this._events = /* @__PURE__ */Object.create(null);
+    this._eventsCount = 0;
+    return this;
+  }
+
+  const listeners2 = events[type];
+
+  if (typeof listeners2 === "function") {
+    this.removeListener(type, listeners2);
+  } else if (listeners2 !== void 0) {
+    for (i = listeners2.length - 1; i >= 0; i--) {
+      this.removeListener(type, listeners2[i]);
+    }
+  }
+
+  return this;
+};
+
+function _listeners(target, type, unwrap) {
+  const events = target._events;
+
+  if (events === void 0) {
+    return [];
+  }
+
+  const evlistener = events[type];
+
+  if (evlistener === void 0) {
+    return [];
+  }
+
+  if (typeof evlistener === "function") {
+    return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+  }
+
+  return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+}
+
+EventEmitter.prototype.listeners = function listeners(type) {
+  return _listeners(this, type, true);
+};
+
+EventEmitter.prototype.rawListeners = function rawListeners(type) {
+  return _listeners(this, type, false);
+};
+
+EventEmitter.listenerCount = function (emitter, type) {
+  return typeof emitter.listenerCount === "function" ? emitter.listenerCount(type) : listenerCount.call(emitter, type);
+};
+
+EventEmitter.prototype.listenerCount = listenerCount;
+
+function listenerCount(type) {
+  const events = this._events;
+
+  if (events !== void 0) {
+    const evlistener = events[type];
+
+    if (typeof evlistener === "function") {
+      return 1;
+    } else if (evlistener !== void 0) {
+      return evlistener.length;
+    }
+  }
+
+  return 0;
+}
+
+EventEmitter.prototype.eventNames = function eventNames() {
+  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+};
+
+function arrayClone(arr, n) {
+  const copy = new Array(n);
+
+  for (let i = 0; i < n; ++i) {
+    copy[i] = arr[i];
+  }
+
+  return copy;
+}
+
+function spliceOne(list, index) {
+  for (; index + 1 < list.length; index++) {
+    list[index] = list[index + 1];
+  }
+
+  list.pop();
+}
+
+function unwrapListeners(arr) {
+  const ret = Array.from({
+    length: arr.length
+  });
+
+  for (let i = 0; i < ret.length; ++i) {
+    ret[i] = arr[i].listener || arr[i];
+  }
+
+  return ret;
+}
+
+function once(emitter, name) {
+  return new Promise(function (resolve, reject) {
+    function errorListener(err) {
+      emitter.removeListener(name, resolver);
+      reject(err);
+    }
+
+    function resolver() {
+      if (typeof emitter.removeListener === "function") {
+        emitter.removeListener("error", errorListener);
+      }
+
+      resolve(Array.prototype.slice.call(arguments));
+    }
+
+    ;
+    eventTargetAgnosticAddListener(emitter, name, resolver, {
+      once: true
+    });
+
+    if (name !== "error") {
+      addErrorHandlerIfEventEmitter(emitter, errorListener, {
+        once: true
+      });
+    }
+  });
+}
+
+function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+  if (typeof emitter.on === "function") {
+    eventTargetAgnosticAddListener(emitter, "error", handler, flags);
+  }
+}
+
+function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+  if (typeof emitter.on === "function") {
+    if (flags.once) {
+      emitter.once(name, listener);
+    } else {
+      emitter.on(name, listener);
+    }
+  } else if (typeof emitter.addEventListener === "function") {
+    emitter.addEventListener(name, function wrapListener(arg) {
+      if (flags.once) {
+        emitter.removeEventListener(name, wrapListener);
+      }
+
+      listener(arg);
+    });
+  } else {
+    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+  }
+}

node_modules/unenv/runtime/node/events/_events.d.ts

@@ -0,0 +1,7 @@
+export declare function EventEmitter(): void;
+export declare namespace EventEmitter {
+    var EventEmitter: typeof import("./_events").EventEmitter;
+    var init: () => void;
+    var listenerCount: (emitter: any, type: any) => any;
+}
+export declare function once(emitter: any, name: any): Promise<unknown>;

node_modules/unenv/runtime/node/events/_events.mjs

@@ -0,0 +1,380 @@
+const R = typeof Reflect === "object" ? Reflect : null;
+const ReflectApply = R && typeof R.apply === "function" ? R.apply : function ReflectApply2(target, receiver, args) {
+  return Function.prototype.apply.call(target, receiver, args);
+};
+let ReflectOwnKeys;
+if (R && typeof R.ownKeys === "function") {
+  ReflectOwnKeys = R.ownKeys;
+} else if (Object.getOwnPropertySymbols) {
+  ReflectOwnKeys = function ReflectOwnKeys2(target) {
+    return [
+      ...Object.getOwnPropertyNames(target),
+      ...Object.getOwnPropertySymbols(target)
+    ];
+  };
+} else {
+  ReflectOwnKeys = function ReflectOwnKeys2(target) {
+    return Object.getOwnPropertyNames(target);
+  };
+}
+function ProcessEmitWarning(warning) {
+  if (console && console.warn) {
+    console.warn(warning);
+  }
+}
+const NumberIsNaN = Number.isNaN || function NumberIsNaN2(value) {
+  return value !== value;
+};
+export function EventEmitter() {
+  EventEmitter.init.call(this);
+}
+EventEmitter.EventEmitter = EventEmitter;
+EventEmitter.prototype._events = void 0;
+EventEmitter.prototype._eventsCount = 0;
+EventEmitter.prototype._maxListeners = void 0;
+let defaultMaxListeners = 10;
+function checkListener(listener) {
+  if (typeof listener !== "function") {
+    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+  }
+}
+Object.defineProperty(EventEmitter, "defaultMaxListeners", {
+  enumerable: true,
+  get: function() {
+    return defaultMaxListeners;
+  },
+  set: function(arg) {
+    if (typeof arg !== "number" || arg < 0 || NumberIsNaN(arg)) {
+      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + ".");
+    }
+    defaultMaxListeners = arg;
+  }
+});
+EventEmitter.init = function() {
+  if (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) {
+    this._events = /* @__PURE__ */ Object.create(null);
+    this._eventsCount = 0;
+  }
+  this._maxListeners = this._maxListeners || void 0;
+};
+EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+  if (typeof n !== "number" || n < 0 || NumberIsNaN(n)) {
+    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + ".");
+  }
+  this._maxListeners = n;
+  return this;
+};
+function _getMaxListeners(that) {
+  if (that._maxListeners === void 0) {
+    return EventEmitter.defaultMaxListeners;
+  }
+  return that._maxListeners;
+}
+EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+  return _getMaxListeners(this);
+};
+EventEmitter.prototype.emit = function emit(type) {
+  const args = [];
+  for (let i = 1; i < arguments.length; i++) {
+    args.push(arguments[i]);
+  }
+  let doError = type === "error";
+  const events = this._events;
+  if (events !== void 0) {
+    doError = doError && events.error === void 0;
+  } else if (!doError) {
+    return false;
+  }
+  if (doError) {
+    let er;
+    if (args.length > 0) {
+      er = args[0];
+    }
+    if (er instanceof Error) {
+      throw er;
+    }
+    const err = new Error("Unhandled error." + (er ? " (" + er.message + ")" : ""));
+    err.context = er;
+    throw err;
+  }
+  const handler = events[type];
+  if (handler === void 0) {
+    return false;
+  }
+  if (typeof handler === "function") {
+    ReflectApply(handler, this, args);
+  } else {
+    const len = handler.length;
+    const listeners2 = arrayClone(handler, len);
+    for (let i = 0; i < len; ++i) {
+      ReflectApply(listeners2[i], this, args);
+    }
+  }
+  return true;
+};
+function _addListener(target, type, listener, prepend) {
+  let m;
+  let events;
+  let existing;
+  checkListener(listener);
+  events = target._events;
+  if (events === void 0) {
+    events = target._events = /* @__PURE__ */ Object.create(null);
+    target._eventsCount = 0;
+  } else {
+    if (events.newListener !== void 0) {
+      target.emit("newListener", type, listener.listener ? listener.listener : listener);
+      events = target._events;
+    }
+    existing = events[type];
+  }
+  if (existing === void 0) {
+    existing = events[type] = listener;
+    ++target._eventsCount;
+  } else {
+    if (typeof existing === "function") {
+      existing = events[type] = prepend ? [listener, existing] : [existing, listener];
+    } else if (prepend) {
+      existing.unshift(listener);
+    } else {
+      existing.push(listener);
+    }
+    m = _getMaxListeners(target);
+    if (m > 0 && existing.length > m && !existing.warned) {
+      existing.warned = true;
+      const w = new Error("Possible EventEmitter memory leak detected. " + existing.length + " " + String(type) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+      w.name = "MaxListenersExceededWarning";
+      w.emitter = target;
+      w.type = type;
+      w.count = existing.length;
+      ProcessEmitWarning(w);
+    }
+  }
+  return target;
+}
+EventEmitter.prototype.addListener = function addListener(type, listener) {
+  return _addListener(this, type, listener, false);
+};
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+EventEmitter.prototype.prependListener = function prependListener(type, listener) {
+  return _addListener(this, type, listener, true);
+};
+function onceWrapper() {
+  if (!this.fired) {
+    this.target.removeListener(this.type, this.wrapFn);
+    this.fired = true;
+    if (arguments.length === 0) {
+      return this.listener.call(this.target);
+    }
+    return this.listener.apply(this.target, arguments);
+  }
+}
+function _onceWrap(target, type, listener) {
+  const state = { fired: false, wrapFn: void 0, target, type, listener };
+  const wrapped = onceWrapper.bind(state);
+  wrapped.listener = listener;
+  state.wrapFn = wrapped;
+  return wrapped;
+}
+EventEmitter.prototype.once = function once2(type, listener) {
+  checkListener(listener);
+  this.on(type, _onceWrap(this, type, listener));
+  return this;
+};
+EventEmitter.prototype.prependOnceListener = function prependOnceListener(type, listener) {
+  checkListener(listener);
+  this.prependListener(type, _onceWrap(this, type, listener));
+  return this;
+};
+EventEmitter.prototype.removeListener = function removeListener(type, listener) {
+  let position, i, originalListener;
+  checkListener(listener);
+  const events = this._events;
+  if (events === void 0) {
+    return this;
+  }
+  const list = events[type];
+  if (list === void 0) {
+    return this;
+  }
+  if (list === listener || list.listener === listener) {
+    if (--this._eventsCount === 0) {
+      this._events = /* @__PURE__ */ Object.create(null);
+    } else {
+      delete events[type];
+      if (events.removeListener) {
+        this.emit("removeListener", type, list.listener || listener);
+      }
+    }
+  } else if (typeof list !== "function") {
+    position = -1;
+    for (i = list.length - 1; i >= 0; i--) {
+      if (list[i] === listener || list[i].listener === listener) {
+        originalListener = list[i].listener;
+        position = i;
+        break;
+      }
+    }
+    if (position < 0) {
+      return this;
+    }
+    if (position === 0) {
+      list.shift();
+    } else {
+      spliceOne(list, position);
+    }
+    if (list.length === 1) {
+      events[type] = list[0];
+    }
+    if (events.removeListener !== void 0) {
+      this.emit("removeListener", type, originalListener || listener);
+    }
+  }
+  return this;
+};
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) {
+  let i;
+  const events = this._events;
+  if (events === void 0) {
+    return this;
+  }
+  if (events.removeListener === void 0) {
+    if (arguments.length === 0) {
+      this._events = /* @__PURE__ */ Object.create(null);
+      this._eventsCount = 0;
+    } else if (events[type] !== void 0) {
+      if (--this._eventsCount === 0) {
+        this._events = /* @__PURE__ */ Object.create(null);
+      } else {
+        delete events[type];
+      }
+    }
+    return this;
+  }
+  if (arguments.length === 0) {
+    const keys = Object.keys(events);
+    let key;
+    for (i = 0; i < keys.length; ++i) {
+      key = keys[i];
+      if (key === "removeListener") {
+        continue;
+      }
+      this.removeAllListeners(key);
+    }
+    this.removeAllListeners("removeListener");
+    this._events = /* @__PURE__ */ Object.create(null);
+    this._eventsCount = 0;
+    return this;
+  }
+  const listeners2 = events[type];
+  if (typeof listeners2 === "function") {
+    this.removeListener(type, listeners2);
+  } else if (listeners2 !== void 0) {
+    for (i = listeners2.length - 1; i >= 0; i--) {
+      this.removeListener(type, listeners2[i]);
+    }
+  }
+  return this;
+};
+function _listeners(target, type, unwrap) {
+  const events = target._events;
+  if (events === void 0) {
+    return [];
+  }
+  const evlistener = events[type];
+  if (evlistener === void 0) {
+    return [];
+  }
+  if (typeof evlistener === "function") {
+    return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+  }
+  return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+}
+EventEmitter.prototype.listeners = function listeners(type) {
+  return _listeners(this, type, true);
+};
+EventEmitter.prototype.rawListeners = function rawListeners(type) {
+  return _listeners(this, type, false);
+};
+EventEmitter.listenerCount = function(emitter, type) {
+  return typeof emitter.listenerCount === "function" ? emitter.listenerCount(type) : listenerCount.call(emitter, type);
+};
+EventEmitter.prototype.listenerCount = listenerCount;
+function listenerCount(type) {
+  const events = this._events;
+  if (events !== void 0) {
+    const evlistener = events[type];
+    if (typeof evlistener === "function") {
+      return 1;
+    } else if (evlistener !== void 0) {
+      return evlistener.length;
+    }
+  }
+  return 0;
+}
+EventEmitter.prototype.eventNames = function eventNames() {
+  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+};
+function arrayClone(arr, n) {
+  const copy = new Array(n);
+  for (let i = 0; i < n; ++i) {
+    copy[i] = arr[i];
+  }
+  return copy;
+}
+function spliceOne(list, index) {
+  for (; index + 1 < list.length; index++) {
+    list[index] = list[index + 1];
+  }
+  list.pop();
+}
+function unwrapListeners(arr) {
+  const ret = Array.from({ length: arr.length });
+  for (let i = 0; i < ret.length; ++i) {
+    ret[i] = arr[i].listener || arr[i];
+  }
+  return ret;
+}
+export function once(emitter, name) {
+  return new Promise(function(resolve, reject) {
+    function errorListener(err) {
+      emitter.removeListener(name, resolver);
+      reject(err);
+    }
+    function resolver() {
+      if (typeof emitter.removeListener === "function") {
+        emitter.removeListener("error", errorListener);
+      }
+      resolve(Array.prototype.slice.call(arguments));
+    }
+    ;
+    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+    if (name !== "error") {
+      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+    }
+  });
+}
+function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+  if (typeof emitter.on === "function") {
+    eventTargetAgnosticAddListener(emitter, "error", handler, flags);
+  }
+}
+function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+  if (typeof emitter.on === "function") {
+    if (flags.once) {
+      emitter.once(name, listener);
+    } else {
+      emitter.on(name, listener);
+    }
+  } else if (typeof emitter.addEventListener === "function") {
+    emitter.addEventListener(name, function wrapListener(arg) {
+      if (flags.once) {
+        emitter.removeEventListener(name, wrapListener);
+      }
+      listener(arg);
+    });
+  } else {
+    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+  }
+}

node_modules/unenv/runtime/node/events/index.cjs

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+module.exports = exports.EventEmitter = void 0;
+
+var _events = require("./_events.cjs");
+
+const EventEmitter = _events.EventEmitter;
+exports.EventEmitter = EventEmitter;
+var _default = {
+  EventEmitter
+};
+module.exports = _default;

node_modules/unenv/runtime/node/events/index.d.ts

@@ -0,0 +1,3 @@
+export declare const EventEmitter: any;
+declare const _default: any;
+export default _default;

node_modules/unenv/runtime/node/events/index.mjs

@@ -0,0 +1,5 @@
+import { EventEmitter as _EventEmitter } from "./_events.mjs";
+export const EventEmitter = _EventEmitter;
+export default {
+  EventEmitter
+};