From 206310ddaca01b089d39c235ca3ad7bad3da08ee Mon Sep 17 00:00:00 2001
From: raisinten <raisinten@gmail.com>
Date: Tue, 15 Dec 2020 20:58:27 +0530
Subject: [PATCH 1/2] lib: refactor to use optional chaining in events.js

---
 lib/events.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/lib/events.js b/lib/events.js
index dc08042578bc7a..d280f04d395199 100644
--- a/lib/events.js
+++ b/lib/events.js
@@ -200,7 +200,7 @@ EventEmitter.init = function(opts) {
   this._maxListeners = this._maxListeners || undefined;
 
 
-  if (opts && opts.captureRejections) {
+  if (opts?.captureRejections) {
     if (typeof opts.captureRejections !== 'boolean') {
       throw new ERR_INVALID_ARG_TYPE('options.captureRejections',
                                      'boolean', opts.captureRejections);
@@ -706,9 +706,9 @@ function getEventListeners(emitterOrTarget, type) {
 }
 
 async function once(emitter, name, options = {}) {
-  const signal = options ? options.signal : undefined;
+  const signal = options?.signal;
   validateAbortSignal(signal, 'options.signal');
-  if (signal && signal.aborted)
+  if (signal?.aborted)
     throw lazyDOMException('The operation was aborted', 'AbortError');
   return new Promise((resolve, reject) => {
     const errorListener = (err) => {
@@ -762,7 +762,7 @@ function eventTargetAgnosticRemoveListener(emitter, name, listener, flags) {
 
 function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
   if (typeof emitter.on === 'function') {
-    if (flags && flags.once) {
+    if (flags?.once) {
       emitter.once(name, listener);
     } else {
       emitter.on(name, listener);
@@ -779,7 +779,7 @@ function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
 function on(emitter, event, options) {
   const { signal } = { ...options };
   validateAbortSignal(signal, 'options.signal');
-  if (signal && signal.aborted) {
+  if (signal?.aborted) {
     throw lazyDOMException('The operation was aborted', 'AbortError');
   }
 

From 3f16e7349d6fe864458bbe6042051314c936114f Mon Sep 17 00:00:00 2001
From: raisinten <raisinten@gmail.com>
Date: Tue, 15 Dec 2020 21:22:23 +0530
Subject: [PATCH 2/2] lib: refactor to use more primordials in events.js

---
 lib/events.js | 36 ++++++++++++++++++++++--------------
 1 file changed, 22 insertions(+), 14 deletions(-)

diff --git a/lib/events.js b/lib/events.js
index d280f04d395199..7291b42ef6fae7 100644
--- a/lib/events.js
+++ b/lib/events.js
@@ -22,7 +22,12 @@
 'use strict';
 
 const {
+  ArrayPrototypeJoin,
   ArrayPrototypePush,
+  ArrayPrototypeShift,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSplice,
+  ArrayPrototypeUnshift,
   Boolean,
   Error,
   ErrorCaptureStackTrace,
@@ -39,6 +44,7 @@ const {
   ReflectApply,
   ReflectOwnKeys,
   String,
+  StringPrototypeSplit,
   Symbol,
   SymbolFor,
   SymbolAsyncIterator
@@ -310,16 +316,18 @@ function enhanceStackTrace(err, own) {
   } 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 errStack = ArrayPrototypeSlice(StringPrototypeSplit(err.stack, '\n'),
+                                       1);
+  const ownStack = ArrayPrototypeSlice(StringPrototypeSplit(own.stack, '\n'),
+                                       1);
 
   const [ len, off ] = identicalSequenceRange(ownStack, errStack);
   if (len > 0) {
-    ownStack.splice(off + 1, len - 2,
-                    '    [... lines matching original stack trace ...]');
+    ArrayPrototypeSplice(ownStack, off + 1, len - 2,
+                         '    [... lines matching original stack trace ...]');
   }
 
-  return err.stack + sep + ownStack.join('\n');
+  return err.stack + sep + ArrayPrototypeJoin(ownStack, '\n');
 }
 
 EventEmitter.prototype.emit = function emit(type, ...args) {
@@ -437,9 +445,9 @@ function _addListener(target, type, listener, prepend) {
         prepend ? [listener, existing] : [existing, listener];
       // If we've already got an array, just append.
     } else if (prepend) {
-      existing.unshift(listener);
+      ArrayPrototypeUnshift(existing, listener);
     } else {
-      existing.push(listener);
+      ArrayPrototypePush(existing, listener);
     }
 
     // Check for listener leak
@@ -542,7 +550,7 @@ EventEmitter.prototype.removeListener =
           return this;
 
         if (position === 0)
-          list.shift();
+          ArrayPrototypeShift(list);
         else {
           if (spliceOne === undefined)
             spliceOne = require('internal/util').spliceOne;
@@ -670,7 +678,7 @@ function arrayClone(arr) {
     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();
+  return ArrayPrototypeSlice(arr);
 }
 
 function unwrapListeners(arr) {
@@ -791,7 +799,7 @@ function on(emitter, event, options) {
   const iterator = ObjectSetPrototypeOf({
     next() {
       // First, we consume all unread events
-      const value = unconsumedEvents.shift();
+      const value = ArrayPrototypeShift(unconsumedEvents);
       if (value) {
         return PromiseResolve(createIterResult(value, false));
       }
@@ -813,7 +821,7 @@ function on(emitter, event, options) {
 
       // Wait until an event happens
       return new Promise(function(resolve, reject) {
-        unconsumedPromises.push({ resolve, reject });
+        ArrayPrototypePush(unconsumedPromises, ({ resolve, reject }));
       });
     },
 
@@ -873,18 +881,18 @@ function on(emitter, event, options) {
   }
 
   function eventHandler(...args) {
-    const promise = unconsumedPromises.shift();
+    const promise = ArrayPrototypeShift(unconsumedPromises);
     if (promise) {
       promise.resolve(createIterResult(args, false));
     } else {
-      unconsumedEvents.push(args);
+      ArrayPrototypePush(unconsumedEvents, args);
     }
   }
 
   function errorHandler(err) {
     finished = true;
 
-    const toError = unconsumedPromises.shift();
+    const toError = ArrayPrototypeShift(unconsumedPromises);
 
     if (toError) {
       toError.reject(err);