GeezerVison

const kCapture = Symbol('kCapture');

const kErrorMonitor = Symbol('events.errorMonitor');

const kShapeMode = Symbol('shapeMode');

const kEmitting = Symbol('events.emitting');

const kMaxEventTargetListeners = Symbol('events.maxEventTargetListeners');

const kMaxEventTargetListenersWarned =

this._events === ObjectGetPrototypeOf(this)._events) {

this._events = { __proto__: null };

this._eventsCount = 0;

this[kShapeMode] = false;

} else {

this[kShapeMode] = true;

}

this._maxListeners ||= undefined;

return err.stack + sep + ArrayPrototypeJoin(ownStack, '\n');

function getUnhandledErrorException(ee, args) {

let er;

if (args.length > 0)

er = args[0];

if (er instanceof Error) {

try {

const capture = {};

ErrorCaptureStackTrace(capture, EventEmitter.prototype.emit);

ObjectDefineProperty(er, kEnhanceStackBeforeInspector, {

__proto__: null,

value: FunctionPrototypeBind(enhanceStackTrace, ee, er, capture),

configurable: true,

});

} catch {

// Continue regardless of error.

}

return er;

}

let stringifiedEr;

try {

stringifiedEr = inspect(er);

} catch {

stringifiedEr = er;

}

// At least give some kind of context to the user

const err = new ERR_UNHANDLED_ERROR(stringifiedEr);

err.context = er;

return err;

// If there is no 'error' event listener then throw.

if (doError) {

let er;

if (args.length > 0)

er = args[0];

if (er instanceof Error) {

try {

const capture = {};

ErrorCaptureStackTrace(capture, EventEmitter.prototype.emit);

ObjectDefineProperty(er, kEnhanceStackBeforeInspector, {

__proto__: null,

value: FunctionPrototypeBind(enhanceStackTrace, this, er, capture),

configurable: true,

});

} catch {

// Continue regardless of error.

}

// Note: The comments on the `throw` lines are intentional, they show

// up in Node's output if this results in an unhandled exception.

throw er; // Unhandled 'error' event

}

let stringifiedEr;

try {

stringifiedEr = inspect(er);

} catch {

stringifiedEr = er;

}

// At least give some kind of context to the user

const err = new ERR_UNHANDLED_ERROR(stringifiedEr);

err.context = er;

throw err; // Unhandled 'error' event

const er = getUnhandledErrorException(this, args);

// Note: The comments on the `throw` lines are intentional, they show

// up in Node's output if this results in an unhandled exception.

throw er; // Unhandled 'error' event

}

const handler = events[type];

// Check for listener leak

m = _getMaxListeners(target);

if (m > 0 && existing.length > m && !existing.warned) {

existing.warned = true;

// No error code for this since it is a Warning

const w = genericNodeError(

`Possible EventEmitter memory leak detected. ${existing.length} ${String(type)} listeners ` +

`added to ${inspect(target, { depth: -1 })}. MaxListeners is ${m}. Use emitter.setMaxListeners() to increase limit`,

{ name: 'MaxListenersExceededWarning', emitter: target, type: type, count: existing.length });

process.emitWarning(w);

}

if (m > 0 && existing.length > m && !existing.warned)

warnMaxListenersExceeded(target, type, existing, m);

}

return target;

function warnMaxListenersExceeded(target, type, existing, m) {

existing.warned = true;

// No error code for this since it is a Warning

const w = genericNodeError(

`Possible EventEmitter memory leak detected. ${existing.length} ${String(type)} listeners ` +

`added to ${inspect(target, { depth: -1 })}. MaxListeners is ${m}. Use emitter.setMaxListeners() to increase limit`,

{ name: 'MaxListenersExceededWarning', emitter: target, type: type, count: existing.length });

process.emitWarning(w);

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;

let fired = false;

function wrapper(...args) {

if (fired) return;

fired = true;

target.removeListener(type, wrapper);

return ReflectApply(listener, target, args);

}

wrapper.listener = listener;

return wrapper;

if (list === listener || list.listener === listener) {

this._eventsCount -= 1;

if (this[kShapeMode]) {

events[type] = undefined;

} else if (this._eventsCount === 0) {

this._events = { __proto__: null };

} else {

delete events[type];

}

// Leave the key in place with an `undefined` value: repeatedly

// adding and removing a listener for the same event this way keeps

// the `events` object in the same shape and avoids both a `delete`

// (which would put the object into dictionary mode) and allocating

// a fresh object when the last listener is removed.

events[type] = undefined;

if (events.removeListener !== undefined)

this.emit('removeListener', type, list.listener || listener);

else

delete events[type];

}

this[kShapeMode] = false;

return this;

}

this.removeAllListeners('removeListener');

this._events = { __proto__: null };

this._eventsCount = 0;

this[kShapeMode] = false;

return this;

}

EventEmitter.prototype.eventNames = function eventNames() {

return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];

if (this._eventsCount === 0)

return [];

const events = this._events;

const names = [];

for (const key of ReflectOwnKeys(events)) {

// Removed listeners leave the key in place with an `undefined` value.

if (events[key] !== undefined)

ArrayPrototypePush(names, key);

}

return names;

function arrayClone(arr) {

node:events:<line>

throw er; // Unhandled 'error' event

^

throw er; // Unhandled 'error' event

^

Error: foo:bar

at bar (<project-root>/test/fixtures/errors/events_unhandled_error_common_trace.js:9:12)

node:events:<line>

throw er; // Unhandled 'error' event

^

throw er; // Unhandled 'error' event

^

Error

at Object.<anonymous> (<project-root>/test/fixtures/errors/events_unhandled_error_nexttick.js:6:12)

node:events:<line>

throw er; // Unhandled 'error' event

^

throw er; // Unhandled 'error' event

^

Error

at Object.<anonymous> (<project-root>/test/fixtures/errors/events_unhandled_error_sameline.js:6:34)

node:events:<line>

throw er; // Unhandled 'error' event

^

throw er; // Unhandled 'error' event

^

Error

at Object.<anonymous> (<project-root>/test/fixtures/errors/events_unhandled_error_subclass.js:7:25)