"use strict";
const kRejection = Symbol.for("nodejs.rejection");
import { inspect } from "./internal/util/inspect.mjs";import { AbortError, ERR_INVALID_ARG_TYPE, ERR_OUT_OF_RANGE, ERR_UNHANDLED_ERROR,} from "./internal/errors.ts";
import { validateAbortSignal, validateBoolean, validateFunction,} from "./internal/validators.mjs";import { spliceOne } from "./_utils.ts";
const kCapture = Symbol("kCapture");const kErrorMonitor = Symbol("events.errorMonitor");const kMaxEventTargetListeners = Symbol("events.maxEventTargetListeners");const kMaxEventTargetListenersWarned = Symbol( "events.maxEventTargetListenersWarned",);
export function EventEmitter(opts) { EventEmitter.init.call(this, opts);}export default EventEmitter;EventEmitter.on = on;EventEmitter.once = once;EventEmitter.getEventListeners = getEventListeners;EventEmitter.setMaxListeners = setMaxListeners;EventEmitter.listenerCount = listenerCount;EventEmitter.EventEmitter = EventEmitter;EventEmitter.usingDomains = false;
EventEmitter.captureRejectionSymbol = kRejection;export const captureRejectionSymbol = EventEmitter.captureRejectionSymbol;export const errorMonitor = EventEmitter.errorMonitor;
Object.defineProperty(EventEmitter, "captureRejections", { get() { return EventEmitter.prototype[kCapture]; }, set(value) { validateBoolean(value, "EventEmitter.captureRejections");
EventEmitter.prototype[kCapture] = value; }, enumerable: true,});
EventEmitter.errorMonitor = kErrorMonitor;
Object.defineProperty(EventEmitter.prototype, kCapture, { value: false, writable: true, enumerable: false,});
EventEmitter.prototype._events = undefined;EventEmitter.prototype._eventsCount = 0;EventEmitter.prototype._maxListeners = undefined;
export let defaultMaxListeners = 10;
function checkListener(listener) { validateFunction(listener, "listener");}
Object.defineProperty(EventEmitter, "defaultMaxListeners", { enumerable: true, get: function () { return defaultMaxListeners; }, set: function (arg) { if (typeof arg !== "number" || arg < 0 || Number.isNaN(arg)) { throw new ERR_OUT_OF_RANGE( "defaultMaxListeners", "a non-negative number", arg, ); } defaultMaxListeners = arg; },});
Object.defineProperties(EventEmitter, { kMaxEventTargetListeners: { value: kMaxEventTargetListeners, enumerable: false, configurable: false, writable: false, }, kMaxEventTargetListenersWarned: { value: kMaxEventTargetListenersWarned, enumerable: false, configurable: false, writable: false, },});
export function setMaxListeners( n = defaultMaxListeners, ...eventTargets) { if (typeof n !== "number" || n < 0 || Number.isNaN(n)) { throw new ERR_OUT_OF_RANGE("n", "a non-negative number", n); } if (eventTargets.length === 0) { defaultMaxListeners = n; } else { for (let i = 0; i < eventTargets.length; i++) { const target = eventTargets[i]; if (target instanceof EventTarget) { target[kMaxEventTargetListeners] = n; target[kMaxEventTargetListenersWarned] = false; } else if (typeof target.setMaxListeners === "function") { target.setMaxListeners(n); } else { throw new ERR_INVALID_ARG_TYPE( "eventTargets", ["EventEmitter", "EventTarget"], target, ); } } }}
EventEmitter.init = function (opts) { if ( this._events === undefined || this._events === Object.getPrototypeOf(this)._events ) { this._events = Object.create(null); this._eventsCount = 0; }
this._maxListeners = this._maxListeners || undefined;
if (opts?.captureRejections) { validateBoolean(opts.captureRejections, "options.captureRejections"); this[kCapture] = Boolean(opts.captureRejections); } else { this[kCapture] = EventEmitter.prototype[kCapture]; }};
function addCatch(that, promise, type, args) { if (!that[kCapture]) { return; }
try { const then = promise.then;
if (typeof then === "function") { then.call(promise, undefined, function (err) { process.nextTick(emitUnhandledRejectionOrErr, that, err, type, args); }); } } catch (err) { that.emit("error", err); }}
function emitUnhandledRejectionOrErr(ee, err, type, args) { if (typeof ee[kRejection] === "function") { ee[kRejection](err, type, ...args); } else { const prev = ee[kCapture];
try { ee[kCapture] = false; ee.emit("error", err); } finally { ee[kCapture] = prev; } }}
EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) { if (typeof n !== "number" || n < 0 || Number.isNaN(n)) { throw new ERR_OUT_OF_RANGE("n", "a non-negative number", n); } this._maxListeners = n; return this;};
function _getMaxListeners(that) { if (that._maxListeners === undefined) { return EventEmitter.defaultMaxListeners; } return that._maxListeners;}
EventEmitter.prototype.getMaxListeners = function getMaxListeners() { return _getMaxListeners(this);};
function identicalSequenceRange(a, b) { for (let i = 0; i < a.length - 3; i++) { const pos = b.indexOf(a[i]); if (pos !== -1) { const rest = b.length - pos; if (rest > 3) { let len = 1; const maxLen = Math.min(a.length - i, rest); while (maxLen > len && a[i + len] === b[pos + len]) { len++; } if (len > 3) { return [len, i]; } } } }
return [0, 0];}
function enhanceStackTrace(err, own) { let ctorInfo = ""; try { const { name } = this.constructor; if (name !== "EventEmitter") { ctorInfo = ` on ${name} instance`; } } catch { } const sep = `\nEmitted 'error' event${ctorInfo} at:\n`;
const errStack = err.stack.split("\n").slice(1); const ownStack = own.stack.split("\n").slice(1);
const { 0: len, 1: off } = identicalSequenceRange(ownStack, errStack); if (len > 0) { ownStack.splice( off + 1, len - 2, " [... lines matching original stack trace ...]", ); }
return err.stack + sep + ownStack.join("\n");}
EventEmitter.prototype.emit = function emit(type, ...args) { let doError = (type === "error");
const events = this._events; if (events !== undefined) { if (doError && events[kErrorMonitor] !== undefined) { this.emit(kErrorMonitor, ...args); } doError = doError && events.error === undefined; } else if (!doError) { return false; }
if (doError) { let er; if (args.length > 0) { er = args[0]; } if (er instanceof Error) { try { const capture = {}; Error.captureStackTrace(capture, EventEmitter.prototype.emit); } catch { }
throw er; }
let stringifiedEr; try { stringifiedEr = inspect(er); } catch { stringifiedEr = er; }
const err = new ERR_UNHANDLED_ERROR(stringifiedEr); err.context = er; throw err; }
const handler = events[type];
if (handler === undefined) { return false; }
if (typeof handler === "function") { const result = handler.apply(this, args);
if (result !== undefined && result !== null) { addCatch(this, result, type, args); } } else { const len = handler.length; const listeners = arrayClone(handler); for (let i = 0; i < len; ++i) { const result = listeners[i].apply(this, args);
if (result !== undefined && result !== null) { addCatch(this, result, type, args); } } }
return true;};
function _addListener(target, type, listener, prepend) { let m; let events; let existing;
checkListener(listener);
events = target._events; if (events === undefined) { events = target._events = Object.create(null); target._eventsCount = 0; } else { if (events.newListener !== undefined) { target.emit("newListener", type, listener.listener ?? listener);
events = target._events; } existing = events[type]; }
if (existing === undefined) { 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 to ${inspect(target, { depth: -1 })}. Use ` + "emitter.setMaxListeners() to increase limit", ); w.name = "MaxListenersExceededWarning"; w.emitter = target; w.type = type; w.count = existing.length; process.emitWarning(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: undefined, target, type, listener }; const wrapped = onceWrapper.bind(state); wrapped.listener = listener; state.wrapFn = wrapped; return wrapped;}
EventEmitter.prototype.once = function once(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,) { checkListener(listener);
const events = this._events; if (events === undefined) { return this; }
const list = events[type]; if (list === undefined) { return this; }
if (list === listener || list.listener === listener) { if (--this._eventsCount === 0) { this._events = Object.create(null); } else { delete events[type]; if (events.removeListener) { this.emit("removeListener", type, list.listener || listener); } } } else if (typeof list !== "function") { let position = -1;
for (let i = list.length - 1; i >= 0; i--) { if (list[i] === listener || list[i].listener === 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 !== undefined) { this.emit("removeListener", type, listener); } }
return this;};
EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
EventEmitter.prototype.removeAllListeners = function removeAllListeners(type) { const events = this._events; if (events === undefined) { return this; }
if (events.removeListener === undefined) { if (arguments.length === 0) { this._events = Object.create(null); this._eventsCount = 0; } else if (events[type] !== undefined) { if (--this._eventsCount === 0) { this._events = Object.create(null); } else { delete events[type]; } } return this; }
if (arguments.length === 0) { for (const key of Reflect.ownKeys(events)) { if (key === "removeListener") continue; this.removeAllListeners(key); } this.removeAllListeners("removeListener"); this._events = Object.create(null); this._eventsCount = 0; return this; }
const listeners = events[type];
if (typeof listeners === "function") { this.removeListener(type, listeners); } else if (listeners !== undefined) { for (let i = listeners.length - 1; i >= 0; i--) { this.removeListener(type, listeners[i]); } }
return this;};
function _listeners(target, type, unwrap) { const events = target._events;
if (events === undefined) { return []; }
const evlistener = events[type]; if (evlistener === undefined) { return []; }
if (typeof evlistener === "function") { return unwrap ? [evlistener.listener || evlistener] : [evlistener]; }
return unwrap ? unwrapListeners(evlistener) : arrayClone(evlistener);}
EventEmitter.prototype.listeners = function listeners(type) { return _listeners(this, type, true);};
EventEmitter.prototype.rawListeners = function rawListeners(type) { return _listeners(this, type, false);};
const _listenerCount = function listenerCount(type) { const events = this._events;
if (events !== undefined) { const evlistener = events[type];
if (typeof evlistener === "function") { return 1; } else if (evlistener !== undefined) { return evlistener.length; } }
return 0;};
EventEmitter.prototype.listenerCount = _listenerCount;
export function listenerCount(emitter, type) { if (typeof emitter.listenerCount === "function") { return emitter.listenerCount(type); } return _listenerCount.call(emitter, type);}
EventEmitter.prototype.eventNames = function eventNames() { return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];};
function arrayClone(arr) { switch (arr.length) { case 2: return [arr[0], arr[1]]; case 3: return [arr[0], arr[1], arr[2]]; case 4: return [arr[0], arr[1], arr[2], arr[3]]; case 5: return [arr[0], arr[1], arr[2], arr[3], arr[4]]; case 6: return [arr[0], arr[1], arr[2], arr[3], arr[4], arr[5]]; } return arr.slice();}
function unwrapListeners(arr) { const ret = arrayClone(arr); for (let i = 0; i < ret.length; ++i) { const orig = ret[i].listener; if (typeof orig === "function") { ret[i] = orig; } } return ret;}
export function getEventListeners(emitterOrTarget, type) { if (typeof emitterOrTarget.listeners === "function") { return emitterOrTarget.listeners(type); } if (emitterOrTarget instanceof EventTarget) { const root = emitterOrTarget[kEvents].get(type); const listeners = []; let handler = root?.next; while (handler?.listener !== undefined) { const listener = handler.listener?.deref ? handler.listener.deref() : handler.listener; listeners.push(listener); handler = handler.next; } return listeners; } throw new ERR_INVALID_ARG_TYPE( "emitter", ["EventEmitter", "EventTarget"], emitterOrTarget, );}
export async function once(emitter, name, options = {}) { const signal = options?.signal; validateAbortSignal(signal, "options.signal"); if (signal?.aborted) { throw new AbortError(); } return new Promise((resolve, reject) => { const errorListener = (err) => { emitter.removeListener(name, resolver); if (signal != null) { eventTargetAgnosticRemoveListener(signal, "abort", abortListener); } reject(err); }; const resolver = (...args) => { if (typeof emitter.removeListener === "function") { emitter.removeListener("error", errorListener); } if (signal != null) { eventTargetAgnosticRemoveListener(signal, "abort", abortListener); } resolve(args); }; eventTargetAgnosticAddListener(emitter, name, resolver, { once: true }); if (name !== "error" && typeof emitter.once === "function") { emitter.once("error", errorListener); } function abortListener() { eventTargetAgnosticRemoveListener(emitter, name, resolver); eventTargetAgnosticRemoveListener(emitter, "error", errorListener); reject(new AbortError()); } if (signal != null) { eventTargetAgnosticAddListener( signal, "abort", abortListener, { once: true }, ); } });}
const AsyncIteratorPrototype = Object.getPrototypeOf( Object.getPrototypeOf(async function* () {}).prototype,);
function createIterResult(value, done) { return { value, done };}
function eventTargetAgnosticRemoveListener(emitter, name, listener, flags) { if (typeof emitter.removeListener === "function") { emitter.removeListener(name, listener); } else if (typeof emitter.removeEventListener === "function") { emitter.removeEventListener(name, listener, flags); } else { throw new ERR_INVALID_ARG_TYPE("emitter", "EventEmitter", emitter); }}
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, (arg) => { listener(arg); }, flags); } else { throw new ERR_INVALID_ARG_TYPE("emitter", "EventEmitter", emitter); }}
export function on(emitter, event, options) { const signal = options?.signal; validateAbortSignal(signal, "options.signal"); if (signal?.aborted) { throw new AbortError(); }
const unconsumedEvents = []; const unconsumedPromises = []; let error = null; let finished = false;
const iterator = Object.setPrototypeOf({ next() { const value = unconsumedEvents.shift(); if (value) { return Promise.resolve(createIterResult(value, false)); }
if (error) { const p = Promise.reject(error); error = null; return p; }
if (finished) { return Promise.resolve(createIterResult(undefined, true)); }
return new Promise(function (resolve, reject) { unconsumedPromises.push({ resolve, reject }); }); },
return() { eventTargetAgnosticRemoveListener(emitter, event, eventHandler); eventTargetAgnosticRemoveListener(emitter, "error", errorHandler);
if (signal) { eventTargetAgnosticRemoveListener( signal, "abort", abortListener, { once: true }, ); }
finished = true;
for (const promise of unconsumedPromises) { promise.resolve(createIterResult(undefined, true)); }
return Promise.resolve(createIterResult(undefined, true)); },
throw(err) { if (!err || !(err instanceof Error)) { throw new ERR_INVALID_ARG_TYPE( "EventEmitter.AsyncIterator", "Error", err, ); } error = err; eventTargetAgnosticRemoveListener(emitter, event, eventHandler); eventTargetAgnosticRemoveListener(emitter, "error", errorHandler); },
[Symbol.asyncIterator]() { return this; }, }, AsyncIteratorPrototype);
eventTargetAgnosticAddListener(emitter, event, eventHandler); if (event !== "error" && typeof emitter.on === "function") { emitter.on("error", errorHandler); }
if (signal) { eventTargetAgnosticAddListener( signal, "abort", abortListener, { once: true }, ); }
return iterator;
function abortListener() { errorHandler(new AbortError()); }
function eventHandler(...args) { const promise = unconsumedPromises.shift(); if (promise) { promise.resolve(createIterResult(args, false)); } else { unconsumedEvents.push(args); } }
function errorHandler(err) { finished = true;
const toError = unconsumedPromises.shift();
if (toError) { toError.reject(err); } else { error = err; }
iterator.return(); }}