diff --git a/lib/events.js b/lib/events.js
index dc08042578bc7a..7d18838566644b 100644
--- a/lib/events.js
+++ b/lib/events.js
@@ -22,10 +22,19 @@
 'use strict';
 
 const {
+  ArrayPrototypeForEach,
+  ArrayPrototypeIndexOf,
+  ArrayPrototypeJoin,
   ArrayPrototypePush,
+  ArrayPrototypeShift,
+  ArrayPrototypeSlice,
+  ArrayPrototypeSplice,
+  ArrayPrototypeUnshift,
   Boolean,
   Error,
   ErrorCaptureStackTrace,
+  FunctionPrototypeBind,
+  FunctionPrototypeCall,
   MathMin,
   NumberIsNaN,
   ObjectCreate,
@@ -39,6 +48,7 @@ const {
   ReflectApply,
   ReflectOwnKeys,
   String,
+  StringPrototypeSplit,
   Symbol,
   SymbolFor,
   SymbolAsyncIterator
@@ -173,7 +183,7 @@ EventEmitter.setMaxListeners =
         isEventTarget = require('internal/event_target').isEventTarget;
 
       // Performance for forEach is now comparable with regular for-loop
-      eventTargets.forEach((target) => {
+      ArrayPrototypeForEach(eventTargets, (target) => {
         if (isEventTarget(target)) {
           target[kMaxEventTargetListeners] = n;
           target[kMaxEventTargetListenersWarned] = false;
@@ -224,7 +234,7 @@ function addCatch(that, promise, type, args) {
     const then = promise.then;
 
     if (typeof then === 'function') {
-      then.call(promise, undefined, function(err) {
+      FunctionPrototypeCall(then, promise, undefined, function(err) {
         // The callback is called with nextTick to avoid a follow-up
         // rejection from this promise.
         process.nextTick(emitUnhandledRejectionOrErr, that, err, type, args);
@@ -281,7 +291,7 @@ EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
 function identicalSequenceRange(a, b) {
   for (let i = 0; i < a.length - 3; i++) {
     // Find the first entry of b that matches the current entry of a.
-    const pos = b.indexOf(a[i]);
+    const pos = ArrayPrototypeIndexOf(b, a[i]);
     if (pos !== -1) {
       const rest = b.length - pos;
       if (rest > 3) {
@@ -310,16 +320,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) {
@@ -343,7 +355,7 @@ EventEmitter.prototype.emit = function emit(type, ...args) {
         const capture = {};
         ErrorCaptureStackTrace(capture, EventEmitter.prototype.emit);
         ObjectDefineProperty(er, kEnhanceStackBeforeInspector, {
-          value: enhanceStackTrace.bind(this, er, capture),
+          value: FunctionPrototypeBind(enhanceStackTrace, this, er, capture),
           configurable: true
         });
       } catch {}
@@ -437,9 +449,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
@@ -486,7 +498,7 @@ function onceWrapper() {
 
 function _onceWrap(target, type, listener) {
   const state = { fired: false, wrapFn: undefined, target, type, listener };
-  const wrapped = onceWrapper.bind(state);
+  const wrapped = FunctionPrototypeBind(onceWrapper, state);
   wrapped.listener = listener;
   state.wrapFn = wrapped;
   return wrapped;
@@ -542,7 +554,7 @@ EventEmitter.prototype.removeListener =
           return this;
 
         if (position === 0)
-          list.shift();
+          ArrayPrototypeShift(list);
         else {
           if (spliceOne === undefined)
             spliceOne = require('internal/util').spliceOne;
@@ -636,7 +648,7 @@ EventEmitter.listenerCount = function(emitter, type) {
   if (typeof emitter.listenerCount === 'function') {
     return emitter.listenerCount(type);
   }
-  return listenerCount.call(emitter, type);
+  return FunctionPrototypeCall(listenerCount, emitter, type);
 };
 
 EventEmitter.prototype.listenerCount = listenerCount;
@@ -670,7 +682,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 +803,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 +825,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 +885,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);