lib: port remaining errors to new system

PR-URL: https://github.com/nodejs/node/pull/19137
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>

32 files changed, 613 insertions, 512 deletions

diff --git a/lib/internal/async_hooks.js b/lib/internal/async_hooks.js
index 44be2990d6..72d74243d8 100644
--- a/lib/internal/async_hooks.js
+++ b/lib/internal/async_hooks.js
@@ -1,6 +1,9 @@
 'use strict';
 
-const errors = require('internal/errors');
+const {
+  ERR_ASYNC_TYPE,
+  ERR_INVALID_ASYNC_ID
+} = require('internal/errors').codes;
 const async_wrap = process.binding('async_wrap');
 /* async_hook_fields is a Uint32Array wrapping the uint32_t array of
  * Environment::AsyncHooks::fields_[]. Each index tracks the number of active
@@ -115,7 +118,7 @@ function validateAsyncId(asyncId, type) {
   if (async_hook_fields[kCheck] <= 0) return;
 
   if (!Number.isSafeInteger(asyncId) || asyncId < -1) {
-    fatalError(new errors.RangeError('ERR_INVALID_ASYNC_ID', type, asyncId));
+    fatalError(new ERR_INVALID_ASYNC_ID(type, asyncId));
   }
 }
 
@@ -313,7 +316,7 @@ function emitInitScript(asyncId, type, triggerAsyncId, resource) {
     validateAsyncId(triggerAsyncId, 'triggerAsyncId');
   if (async_hook_fields[kCheck] > 0 &&
       (typeof type !== 'string' || type.length <= 0)) {
-    throw new errors.TypeError('ERR_ASYNC_TYPE', type);
+    throw new ERR_ASYNC_TYPE(type);
   }
 
   // Short circuit all checks for the common case. Which is that no hooks have
diff --git a/lib/internal/buffer.js b/lib/internal/buffer.js
index b5da69a5b3..fe10b20c80 100644
--- a/lib/internal/buffer.js
+++ b/lib/internal/buffer.js
@@ -1,7 +1,11 @@
 'use strict';
 
 const binding = process.binding('buffer');
-const { TypeError, RangeError } = require('internal/errors');
+const {
+  ERR_BUFFER_OUT_OF_BOUNDS,
+  ERR_INVALID_ARG_TYPE,
+  ERR_OUT_OF_RANGE
+} = require('internal/errors').codes;
 const { setupBufferJS } = binding;
 
 // Remove from the binding so that function is only available as exported here.
@@ -26,33 +30,29 @@ function checkBounds(buf, offset, byteLength) {
 
 function checkInt(value, min, max, buf, offset, byteLength) {
   if (value > max || value < min) {
-    throw new RangeError('ERR_OUT_OF_RANGE',
-                         'value', `>= ${min} and <= ${max}`, value);
+    throw new ERR_OUT_OF_RANGE('value', `>= ${min} and <= ${max}`, value);
   }
   checkBounds(buf, offset, byteLength);
 }
 
 function checkNumberType(value, type) {
   if (typeof value !== 'number') {
-    throw new TypeError('ERR_INVALID_ARG_TYPE',
-                        type || 'offset', 'number', value);
+    throw new ERR_INVALID_ARG_TYPE(type || 'offset', 'number', value);
   }
 }
 
 function boundsError(value, length, type) {
   if (Math.floor(value) !== value) {
     checkNumberType(value, type);
-    throw new RangeError('ERR_OUT_OF_RANGE',
-                         type || 'offset', 'an integer', value);
+    throw new ERR_OUT_OF_RANGE(type || 'offset', 'an integer', value);
   }
 
   if (length < 0)
-    throw new RangeError('ERR_BUFFER_OUT_OF_BOUNDS', null, true);
+    throw new ERR_BUFFER_OUT_OF_BOUNDS(null, true);
 
-  throw new RangeError('ERR_OUT_OF_RANGE',
-                       type || 'offset',
-                       `>= ${type ? 1 : 0} and <= ${length}`,
-                       value);
+  throw new ERR_OUT_OF_RANGE(type || 'offset',
+                             `>= ${type ? 1 : 0} and <= ${length}`,
+                             value);
 }
 
 // Read integers.
@@ -545,9 +545,7 @@ function writeU_Int8(buf, value, offset, min, max) {
   // `checkInt()` can not be used here because it checks two entries.
   checkNumberType(offset);
   if (value > max || value < min) {
-    throw new RangeError('ERR_OUT_OF_RANGE',
-                         'value',
-                         `>= ${min} and <= ${max}`, value);
+    throw new ERR_OUT_OF_RANGE('value', `>= ${min} and <= ${max}`, value);
   }
   if (buf[offset] === undefined)
     boundsError(offset, buf.length - 1);
diff --git a/lib/internal/child_process.js b/lib/internal/child_process.js
index 58bb46e8a2..3c8a314bf0 100644
--- a/lib/internal/child_process.js
+++ b/lib/internal/child_process.js
@@ -1,6 +1,19 @@
 'use strict';
 
-const errors = require('internal/errors');
+const {
+  errnoException,
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_HANDLE_TYPE,
+    ERR_INVALID_OPT_VALUE,
+    ERR_INVALID_SYNC_FORK_INPUT,
+    ERR_IPC_CHANNEL_CLOSED,
+    ERR_IPC_DISCONNECTED,
+    ERR_IPC_ONE_PIPE,
+    ERR_IPC_SYNC_FORK,
+    ERR_MISSING_ARGS
+  }
+} = require('internal/errors');
 const { StringDecoder } = require('string_decoder');
 const EventEmitter = require('events');
 const net = require('net');
@@ -29,7 +42,6 @@ const {
   UV_ESRCH
 } = process.binding('uv');
 
-const errnoException = errors.errnoException;
 const { SocketListSend, SocketListReceive } = SocketList;
 
 const MAX_HANDLE_RETRANSMISSIONS = 3;
@@ -263,8 +275,7 @@ ChildProcess.prototype.spawn = function(options) {
   var i;
 
   if (options === null || typeof options !== 'object') {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'options', 'Object',
-                               options);
+    throw new ERR_INVALID_ARG_TYPE('options', 'Object', options);
   }
 
   // If no `stdio` option was given - use default
@@ -281,16 +292,16 @@ ChildProcess.prototype.spawn = function(options) {
     if (options.envPairs === undefined)
       options.envPairs = [];
     else if (!Array.isArray(options.envPairs)) {
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'options.envPairs',
-                                 'Array', options.envPairs);
+      throw new ERR_INVALID_ARG_TYPE('options.envPairs',
+                                     'Array',
+                                     options.envPairs);
     }
 
     options.envPairs.push('NODE_CHANNEL_FD=' + ipcFd);
   }
 
   if (typeof options.file !== 'string') {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'options.file', 'string',
-                               options.file);
+    throw new ERR_INVALID_ARG_TYPE('options.file', 'string', options.file);
   }
   this.spawnfile = options.file;
 
@@ -299,8 +310,7 @@ ChildProcess.prototype.spawn = function(options) {
   else if (options.args === undefined)
     this.spawnargs = [];
   else
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'options.args', 'Array',
-                               options.args);
+    throw new ERR_INVALID_ARG_TYPE('options.args', 'Array', options.args);
 
   var err = this._handle.spawn(options);
 
@@ -587,8 +597,7 @@ function setupChannel(target, channel) {
       options = undefined;
     } else if (options !== undefined &&
                (options === null || typeof options !== 'object')) {
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'options', 'Object',
-                                 options);
+      throw new ERR_INVALID_ARG_TYPE('options', 'Object', options);
     }
 
     options = Object.assign({ swallowErrors: false }, options);
@@ -596,7 +605,7 @@ function setupChannel(target, channel) {
     if (this.connected) {
       return this._send(message, handle, options, callback);
     }
-    const ex = new errors.Error('ERR_IPC_CHANNEL_CLOSED');
+    const ex = new ERR_IPC_CHANNEL_CLOSED();
     if (typeof callback === 'function') {
       process.nextTick(callback, ex);
     } else {
@@ -609,7 +618,7 @@ function setupChannel(target, channel) {
     assert(this.connected || this.channel);
 
     if (message === undefined)
-      throw new errors.TypeError('ERR_MISSING_ARGS', 'message');
+      throw new ERR_MISSING_ARGS('message');
 
     // Support legacy function signature
     if (typeof options === 'boolean') {
@@ -636,7 +645,7 @@ function setupChannel(target, channel) {
       } else if (handle instanceof UDP) {
         message.type = 'dgram.Native';
       } else {
-        throw new errors.TypeError('ERR_INVALID_HANDLE_TYPE');
+        throw new ERR_INVALID_HANDLE_TYPE();
       }
 
       // Queue-up message and handle if we haven't received ACK yet.
@@ -736,7 +745,7 @@ function setupChannel(target, channel) {
 
   target.disconnect = function() {
     if (!this.connected) {
-      this.emit('error', new errors.Error('ERR_IPC_DISCONNECTED'));
+      this.emit('error', new ERR_IPC_DISCONNECTED());
       return;
     }
 
@@ -818,11 +827,10 @@ function _validateStdio(stdio, sync) {
       case 'pipe': stdio = ['pipe', 'pipe', 'pipe']; break;
       case 'inherit': stdio = [0, 1, 2]; break;
       default:
-        throw new errors.TypeError('ERR_INVALID_OPT_VALUE', 'stdio', stdio);
+        throw new ERR_INVALID_OPT_VALUE('stdio', stdio);
     }
   } else if (!Array.isArray(stdio)) {
-    throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                               'stdio', util.inspect(stdio));
+    throw new ERR_INVALID_OPT_VALUE('stdio', util.inspect(stdio));
   }
 
   // At least 3 stdio will be created
@@ -864,9 +872,9 @@ function _validateStdio(stdio, sync) {
         // Cleanup previously created pipes
         cleanup();
         if (!sync)
-          throw new errors.Error('ERR_IPC_ONE_PIPE');
+          throw new ERR_IPC_ONE_PIPE();
         else
-          throw new errors.Error('ERR_IPC_SYNC_FORK');
+          throw new ERR_IPC_SYNC_FORK();
       }
 
       ipc = new Pipe(PipeConstants.IPC);
@@ -901,14 +909,12 @@ function _validateStdio(stdio, sync) {
     } else if (isUint8Array(stdio) || typeof stdio === 'string') {
       if (!sync) {
         cleanup();
-        throw new errors.TypeError('ERR_INVALID_SYNC_FORK_INPUT',
-                                   util.inspect(stdio));
+        throw new ERR_INVALID_SYNC_FORK_INPUT(util.inspect(stdio));
       }
     } else {
       // Cleanup
       cleanup();
-      throw new errors.TypeError('ERR_INVALID_OPT_VALUE', 'stdio',
-                                 util.inspect(stdio));
+      throw new ERR_INVALID_OPT_VALUE('stdio', util.inspect(stdio));
     }
 
     return acc;
diff --git a/lib/internal/crypto/certificate.js b/lib/internal/crypto/certificate.js
index b6b6ef8f5f..5eaa5ce056 100644
--- a/lib/internal/crypto/certificate.js
+++ b/lib/internal/crypto/certificate.js
@@ -6,7 +6,7 @@ const {
   certVerifySpkac
 } = process.binding('crypto');
 
-const errors = require('internal/errors');
+const { ERR_INVALID_ARG_TYPE } = require('internal/errors').codes;
 const { isArrayBufferView } = require('internal/util/types');
 
 const {
@@ -15,8 +15,10 @@ const {
 
 function verifySpkac(spkac) {
   if (!isArrayBufferView(spkac)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'spkac',
-                               ['Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE(
+      'spkac',
+      ['Buffer', 'TypedArray', 'DataView']
+    );
   }
   return certVerifySpkac(spkac);
 }
@@ -24,8 +26,10 @@ function verifySpkac(spkac) {
 function exportPublicKey(spkac, encoding) {
   spkac = toBuf(spkac, encoding);
   if (!isArrayBufferView(spkac)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'spkac',
-                               ['string', 'Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE(
+      'spkac',
+      ['string', 'Buffer', 'TypedArray', 'DataView']
+    );
   }
   return certExportPublicKey(spkac);
 }
@@ -33,8 +37,10 @@ function exportPublicKey(spkac, encoding) {
 function exportChallenge(spkac, encoding) {
   spkac = toBuf(spkac, encoding);
   if (!isArrayBufferView(spkac)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'spkac',
-                               ['string', 'Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE(
+      'spkac',
+      ['string', 'Buffer', 'TypedArray', 'DataView']
+    );
   }
   return certExportChallenge(spkac);
 }
diff --git a/lib/internal/crypto/cipher.js b/lib/internal/crypto/cipher.js
index 5426c7e6ed..0d468c3b13 100644
--- a/lib/internal/crypto/cipher.js
+++ b/lib/internal/crypto/cipher.js
@@ -5,7 +5,10 @@ const {
   RSA_PKCS1_PADDING
 } = process.binding('constants').crypto;
 
-const errors = require('internal/errors');
+const {
+  ERR_CRYPTO_INVALID_STATE,
+  ERR_INVALID_ARG_TYPE
+} = require('internal/errors').codes;
 
 const {
   getDefaultEncoding,
@@ -64,12 +67,14 @@ function Cipher(cipher, password, options) {
     return new Cipher(cipher, password, options);
 
   if (typeof cipher !== 'string')
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'cipher', 'string');
+    throw new ERR_INVALID_ARG_TYPE('cipher', 'string');
 
   password = toBuf(password);
   if (!isArrayBufferView(password)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'password',
-                               ['string', 'Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE(
+      'password',
+      ['string', 'Buffer', 'TypedArray', 'DataView']
+    );
   }
 
   this._handle = new CipherBase(true);
@@ -103,8 +108,10 @@ Cipher.prototype.update = function update(data, inputEncoding, outputEncoding) {
   outputEncoding = outputEncoding || encoding;
 
   if (typeof data !== 'string' && !isArrayBufferView(data)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'data',
-                               ['string', 'Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE(
+      'data',
+      ['string', 'Buffer', 'TypedArray', 'DataView']
+    );
   }
 
   const ret = this._handle.update(data, inputEncoding);
@@ -133,38 +140,38 @@ Cipher.prototype.final = function final(outputEncoding) {
 
 Cipher.prototype.setAutoPadding = function setAutoPadding(ap) {
   if (this._handle.setAutoPadding(ap) === false)
-    throw new errors.Error('ERR_CRYPTO_INVALID_STATE', 'setAutoPadding');
+    throw new ERR_CRYPTO_INVALID_STATE('setAutoPadding');
   return this;
 };
 
 Cipher.prototype.getAuthTag = function getAuthTag() {
   const ret = this._handle.getAuthTag();
   if (ret === undefined)
-    throw new errors.Error('ERR_CRYPTO_INVALID_STATE', 'getAuthTag');
+    throw new ERR_CRYPTO_INVALID_STATE('getAuthTag');
   return ret;
 };
 
 
 Cipher.prototype.setAuthTag = function setAuthTag(tagbuf) {
   if (!isArrayBufferView(tagbuf)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'buffer',
-                               ['Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE('buffer',
+                                   ['Buffer', 'TypedArray', 'DataView']);
   }
   // Do not do a normal falsy check because the method returns
   // undefined if it succeeds. Returns false specifically if it
   // errored
   if (this._handle.setAuthTag(tagbuf) === false)
-    throw new errors.Error('ERR_CRYPTO_INVALID_STATE', 'setAuthTag');
+    throw new ERR_CRYPTO_INVALID_STATE('setAuthTag');
   return this;
 };
 
 Cipher.prototype.setAAD = function setAAD(aadbuf) {
   if (!isArrayBufferView(aadbuf)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'buffer',
-                               ['Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE('buffer',
+                                   ['Buffer', 'TypedArray', 'DataView']);
   }
   if (this._handle.setAAD(aadbuf) === false)
-    throw new errors.Error('ERR_CRYPTO_INVALID_STATE', 'setAAD');
+    throw new ERR_CRYPTO_INVALID_STATE('setAAD');
   return this;
 };
 
@@ -173,18 +180,22 @@ function Cipheriv(cipher, key, iv, options) {
     return new Cipheriv(cipher, key, iv, options);
 
   if (typeof cipher !== 'string')
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'cipher', 'string');
+    throw new ERR_INVALID_ARG_TYPE('cipher', 'string');
 
   key = toBuf(key);
   if (!isArrayBufferView(key)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'key',
-                               ['string', 'Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE(
+      'key',
+      ['string', 'Buffer', 'TypedArray', 'DataView']
+    );
   }
 
   iv = toBuf(iv);
   if (iv !== null && !isArrayBufferView(iv)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'iv',
-                               ['string', 'Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE(
+      'iv',
+      ['string', 'Buffer', 'TypedArray', 'DataView']
+    );
   }
 
   this._handle = new CipherBase(true);
@@ -211,12 +222,14 @@ function Decipher(cipher, password, options) {
     return new Decipher(cipher, password, options);
 
   if (typeof cipher !== 'string')
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'cipher', 'string');
+    throw new ERR_INVALID_ARG_TYPE('cipher', 'string');
 
   password = toBuf(password);
   if (!isArrayBufferView(password)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'password',
-                               ['string', 'Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE(
+      'password',
+      ['string', 'Buffer', 'TypedArray', 'DataView']
+    );
   }
 
   this._handle = new CipherBase(false);
@@ -244,18 +257,22 @@ function Decipheriv(cipher, key, iv, options) {
     return new Decipheriv(cipher, key, iv, options);
 
   if (typeof cipher !== 'string')
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'cipher', 'string');
+    throw new ERR_INVALID_ARG_TYPE('cipher', 'string');
 
   key = toBuf(key);
   if (!isArrayBufferView(key)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'key',
-                               ['string', 'Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE(
+      'key',
+      ['string', 'Buffer', 'TypedArray', 'DataView']
+    );
   }
 
   iv = toBuf(iv);
   if (iv !== null && !isArrayBufferView(iv)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'iv',
-                               ['string', 'Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE(
+      'iv',
+      ['string', 'Buffer', 'TypedArray', 'DataView']
+    );
   }
 
   this._handle = new CipherBase(false);
diff --git a/lib/internal/crypto/diffiehellman.js b/lib/internal/crypto/diffiehellman.js
index 687bae83fd..f6d525c215 100644
--- a/lib/internal/crypto/diffiehellman.js
+++ b/lib/internal/crypto/diffiehellman.js
@@ -1,7 +1,11 @@
 'use strict';
 
 const { Buffer } = require('buffer');
-const errors = require('internal/errors');
+const {
+  ERR_CRYPTO_ECDH_INVALID_FORMAT,
+  ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY,
+  ERR_INVALID_ARG_TYPE
+} = require('internal/errors').codes;
 const { isArrayBufferView } = require('internal/util/types');
 const {
   getDefaultEncoding,
@@ -27,9 +31,10 @@ function DiffieHellman(sizeOrKey, keyEncoding, generator, genEncoding) {
   if (typeof sizeOrKey !== 'number' &&
       typeof sizeOrKey !== 'string' &&
       !isArrayBufferView(sizeOrKey)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'sizeOrKey',
-                               ['number', 'string', 'Buffer', 'TypedArray',
-                                'DataView']);
+    throw new ERR_INVALID_ARG_TYPE(
+      'sizeOrKey',
+      ['number', 'string', 'Buffer', 'TypedArray', 'DataView']
+    );
   }
 
   if (keyEncoding) {
@@ -97,7 +102,7 @@ function dhComputeSecret(key, inEnc, outEnc) {
   outEnc = outEnc || encoding;
   var ret = this._handle.computeSecret(toBuf(key, inEnc));
   if (typeof ret === 'string')
-    throw new errors.Error('ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY');
+    throw new ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY();
   if (outEnc && outEnc !== 'buffer')
     ret = ret.toString(outEnc);
   return ret;
@@ -175,7 +180,7 @@ function ECDH(curve) {
     return new ECDH(curve);
 
   if (typeof curve !== 'string')
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'curve', 'string');
+    throw new ERR_INVALID_ARG_TYPE('curve', 'string');
 
   this._handle = new _ECDH(curve);
 }
@@ -202,7 +207,7 @@ ECDH.prototype.getPublicKey = function getPublicKey(encoding, format) {
     else if (format === 'uncompressed')
       f = POINT_CONVERSION_UNCOMPRESSED;
     else
-      throw new errors.TypeError('ERR_CRYPTO_ECDH_INVALID_FORMAT', format);
+      throw new ERR_CRYPTO_ECDH_INVALID_FORMAT(format);
   } else {
     f = POINT_CONVERSION_UNCOMPRESSED;
   }
diff --git a/lib/internal/crypto/hash.js b/lib/internal/crypto/hash.js
index 952cc34d21..41e00b88b9 100644
--- a/lib/internal/crypto/hash.js
+++ b/lib/internal/crypto/hash.js
@@ -12,7 +12,12 @@ const {
 
 const { Buffer } = require('buffer');
 
-const errors = require('internal/errors');
+const {
+  ERR_CRYPTO_HASH_DIGEST_NO_UTF16,
+  ERR_CRYPTO_HASH_FINALIZED,
+  ERR_CRYPTO_HASH_UPDATE_FAILED,
+  ERR_INVALID_ARG_TYPE
+} = require('internal/errors').codes;
 const { inherits } = require('util');
 const { normalizeEncoding } = require('internal/util');
 const { isArrayBufferView } = require('internal/util/types');
@@ -24,7 +29,7 @@ function Hash(algorithm, options) {
   if (!(this instanceof Hash))
     return new Hash(algorithm, options);
   if (typeof algorithm !== 'string')
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'algorithm', 'string');
+    throw new ERR_INVALID_ARG_TYPE('algorithm', 'string');
   this._handle = new _Hash(algorithm);
   this[kState] = {
     [kFinalized]: false
@@ -47,15 +52,15 @@ Hash.prototype._flush = function _flush(callback) {
 Hash.prototype.update = function update(data, encoding) {
   const state = this[kState];
   if (state[kFinalized])
-    throw new errors.Error('ERR_CRYPTO_HASH_FINALIZED');
+    throw new ERR_CRYPTO_HASH_FINALIZED();
 
   if (typeof data !== 'string' && !isArrayBufferView(data)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'data',
-                               ['string', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE('data',
+                                   ['string', 'TypedArray', 'DataView']);
   }
 
   if (!this._handle.update(data, encoding || getDefaultEncoding()))
-    throw new errors.Error('ERR_CRYPTO_HASH_UPDATE_FAILED');
+    throw new ERR_CRYPTO_HASH_UPDATE_FAILED();
   return this;
 };
 
@@ -63,10 +68,10 @@ Hash.prototype.update = function update(data, encoding) {
 Hash.prototype.digest = function digest(outputEncoding) {
   const state = this[kState];
   if (state[kFinalized])
-    throw new errors.Error('ERR_CRYPTO_HASH_FINALIZED');
+    throw new ERR_CRYPTO_HASH_FINALIZED();
   outputEncoding = outputEncoding || getDefaultEncoding();
   if (normalizeEncoding(outputEncoding) === 'utf16le')
-    throw new errors.Error('ERR_CRYPTO_HASH_DIGEST_NO_UTF16');
+    throw new ERR_CRYPTO_HASH_DIGEST_NO_UTF16();
 
   // Explicit conversion for backward compatibility.
   const ret = this._handle.digest(`${outputEncoding}`);
@@ -79,10 +84,9 @@ function Hmac(hmac, key, options) {
   if (!(this instanceof Hmac))
     return new Hmac(hmac, key, options);
   if (typeof hmac !== 'string')
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'hmac', 'string');
+    throw new ERR_INVALID_ARG_TYPE('hmac', 'string');
   if (typeof key !== 'string' && !isArrayBufferView(key)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'key',
-                               ['string', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE('key', ['string', 'TypedArray', 'DataView']);
   }
   this._handle = new _Hmac();
   this._handle.init(hmac, toBuf(key));
@@ -100,7 +104,7 @@ Hmac.prototype.digest = function digest(outputEncoding) {
   const state = this[kState];
   outputEncoding = outputEncoding || getDefaultEncoding();
   if (normalizeEncoding(outputEncoding) === 'utf16le')
-    throw new errors.Error('ERR_CRYPTO_HASH_DIGEST_NO_UTF16');
+    throw new ERR_CRYPTO_HASH_DIGEST_NO_UTF16();
 
   if (state[kFinalized]) {
     const buf = Buffer.from('');
diff --git a/lib/internal/crypto/pbkdf2.js b/lib/internal/crypto/pbkdf2.js
index e967e0a794..fdffcffad6 100644
--- a/lib/internal/crypto/pbkdf2.js
+++ b/lib/internal/crypto/pbkdf2.js
@@ -1,6 +1,11 @@
 'use strict';
 
-const errors = require('internal/errors');
+const {
+  ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_CALLBACK,
+  ERR_CRYPTO_INVALID_DIGEST,
+  ERR_OUT_OF_RANGE
+} = require('internal/errors').codes;
 const {
   getDefaultEncoding,
   toBuf
@@ -20,7 +25,7 @@ function pbkdf2(password, salt, iterations, keylen, digest, callback) {
   }
 
   if (typeof callback !== 'function')
-    throw new errors.TypeError('ERR_INVALID_CALLBACK');
+    throw new ERR_INVALID_CALLBACK();
 
   return _pbkdf2(password, salt, iterations, keylen, digest, callback);
 }
@@ -32,38 +37,35 @@ function pbkdf2Sync(password, salt, iterations, keylen, digest) {
 function _pbkdf2(password, salt, iterations, keylen, digest, callback) {
 
   if (digest !== null && typeof digest !== 'string')
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'digest',
-                               ['string', 'null']);
+    throw new ERR_INVALID_ARG_TYPE('digest', ['string', 'null']);
 
   password = toBuf(password);
   salt = toBuf(salt);
 
   if (!isArrayBufferView(password)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'password',
-                               ['string', 'Buffer', 'TypedArray']);
+    throw new ERR_INVALID_ARG_TYPE('password',
+                                   ['string', 'Buffer', 'TypedArray']);
   }
 
   if (!isArrayBufferView(salt)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'salt',
-                               ['string', 'Buffer', 'TypedArray']);
+    throw new ERR_INVALID_ARG_TYPE('salt', ['string', 'Buffer', 'TypedArray']);
   }
 
   if (typeof iterations !== 'number')
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'iterations', 'number');
+    throw new ERR_INVALID_ARG_TYPE('iterations', 'number');
 
   if (iterations < 0)
-    throw new errors.RangeError('ERR_OUT_OF_RANGE',
-                                'iterations',
-                                'a non-negative number',
-                                iterations);
+    throw new ERR_OUT_OF_RANGE('iterations',
+                               'a non-negative number',
+                               iterations);
 
   if (typeof keylen !== 'number')
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'keylen', 'number');
+    throw new ERR_INVALID_ARG_TYPE('keylen', 'number');
 
   if (keylen < 0 ||
       !Number.isFinite(keylen) ||
       keylen > INT_MAX) {
-    throw new errors.RangeError('ERR_OUT_OF_RANGE', 'keylen');
+    throw new ERR_OUT_OF_RANGE('keylen');
   }
 
   const encoding = getDefaultEncoding();
@@ -71,7 +73,7 @@ function _pbkdf2(password, salt, iterations, keylen, digest, callback) {
   if (encoding === 'buffer') {
     const ret = PBKDF2(password, salt, iterations, keylen, digest, callback);
     if (ret === -1)
-      throw new errors.TypeError('ERR_CRYPTO_INVALID_DIGEST', digest);
+      throw new ERR_CRYPTO_INVALID_DIGEST(digest);
     return ret;
   }
 
@@ -83,11 +85,11 @@ function _pbkdf2(password, salt, iterations, keylen, digest, callback) {
       callback(er, ret);
     }
     if (PBKDF2(password, salt, iterations, keylen, digest, next) === -1)
-      throw new errors.TypeError('ERR_CRYPTO_INVALID_DIGEST', digest);
+      throw new ERR_CRYPTO_INVALID_DIGEST(digest);
   } else {
     const ret = PBKDF2(password, salt, iterations, keylen, digest);
     if (ret === -1)
-      throw new errors.TypeError('ERR_CRYPTO_INVALID_DIGEST', digest);
+      throw new ERR_CRYPTO_INVALID_DIGEST(digest);
     return ret.toString(encoding);
   }
 }
diff --git a/lib/internal/crypto/random.js b/lib/internal/crypto/random.js
index 9ffaa4de76..77ad06ee7b 100644
--- a/lib/internal/crypto/random.js
+++ b/lib/internal/crypto/random.js
@@ -1,6 +1,10 @@
 'use strict';
 
-const errors = require('internal/errors');
+const {
+  ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_CALLBACK,
+  ERR_OUT_OF_RANGE
+} = require('internal/errors').codes;
 const { isArrayBufferView } = require('internal/util/types');
 const {
   randomBytes: _randomBytes,
@@ -12,43 +16,42 @@ const kMaxUint32 = Math.pow(2, 32) - 1;
 
 function assertOffset(offset, length) {
   if (typeof offset !== 'number' || Number.isNaN(offset)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'offset', 'number');
+    throw new ERR_INVALID_ARG_TYPE('offset', 'number');
   }
 
   if (offset > kMaxUint32 || offset < 0) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'offset', 'uint32');
+    throw new ERR_INVALID_ARG_TYPE('offset', 'uint32');
   }
 
   if (offset > kMaxLength || offset > length) {
-    throw new errors.RangeError('ERR_OUT_OF_RANGE', 'offset');
+    throw new ERR_OUT_OF_RANGE('offset');
   }
 }
 
 function assertSize(size, offset = 0, length = Infinity) {
   if (typeof size !== 'number' || Number.isNaN(size)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'size', 'number');
+    throw new ERR_INVALID_ARG_TYPE('size', 'number');
   }
 
   if (size > kMaxUint32 || size < 0) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'size', 'uint32');
+    throw new ERR_INVALID_ARG_TYPE('size', 'uint32');
   }
 
   if (size + offset > length || size > kMaxLength) {
-    throw new errors.RangeError('ERR_OUT_OF_RANGE', 'size');
+    throw new ERR_OUT_OF_RANGE('size');
   }
 }
 
 function randomBytes(size, cb) {
   assertSize(size);
   if (cb !== undefined && typeof cb !== 'function')
-    throw new errors.TypeError('ERR_INVALID_CALLBACK');
+    throw new ERR_INVALID_CALLBACK();
   return _randomBytes(size, cb);
 }
 
 function randomFillSync(buf, offset = 0, size) {
   if (!isArrayBufferView(buf)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
-                               'buf', 'ArrayBufferView');
+    throw new ERR_INVALID_ARG_TYPE('buf', 'ArrayBufferView');
   }
 
   const elementSize = buf.BYTES_PER_ELEMENT || 1;
@@ -69,8 +72,7 @@ function randomFillSync(buf, offset = 0, size) {
 
 function randomFill(buf, offset, size, cb) {
   if (!isArrayBufferView(buf)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
-                               'buf', 'ArrayBufferView');
+    throw new ERR_INVALID_ARG_TYPE('buf', 'ArrayBufferView');
   }
 
   const elementSize = buf.BYTES_PER_ELEMENT || 1;
@@ -84,7 +86,7 @@ function randomFill(buf, offset, size, cb) {
     offset *= elementSize;
     size = buf.byteLength - offset;
   } else if (typeof cb !== 'function') {
-    throw new errors.TypeError('ERR_INVALID_CALLBACK');
+    throw new ERR_INVALID_CALLBACK();
   }
   if (size === undefined) {
     size = buf.byteLength - offset;
diff --git a/lib/internal/crypto/sig.js b/lib/internal/crypto/sig.js
index 9f1938290f..688ad43ddd 100644
--- a/lib/internal/crypto/sig.js
+++ b/lib/internal/crypto/sig.js
@@ -1,6 +1,10 @@
 'use strict';
 
-const errors = require('internal/errors');
+const {
+  ERR_CRYPTO_SIGN_KEY_REQUIRED,
+  ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_OPT_VALUE
+} = require('internal/errors').codes;
 const {
   Sign: _Sign,
   Verify: _Verify
@@ -21,7 +25,7 @@ function Sign(algorithm, options) {
   if (!(this instanceof Sign))
     return new Sign(algorithm, options);
   if (typeof algorithm !== 'string')
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'algorithm', 'string');
+    throw new ERR_INVALID_ARG_TYPE('algorithm', 'string');
   this._handle = new _Sign();
   this._handle.init(algorithm);
 
@@ -39,8 +43,10 @@ Sign.prototype.update = function update(data, encoding) {
   encoding = encoding || getDefaultEncoding();
   data = toBuf(data, encoding);
   if (!isArrayBufferView(data)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'data',
-                               ['string', 'Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE(
+      'data',
+      ['string', 'Buffer', 'TypedArray', 'DataView']
+    );
   }
   this._handle.update(data);
   return this;
@@ -48,7 +54,7 @@ Sign.prototype.update = function update(data, encoding) {
 
 Sign.prototype.sign = function sign(options, encoding) {
   if (!options)
-    throw new errors.Error('ERR_CRYPTO_SIGN_KEY_REQUIRED');
+    throw new ERR_CRYPTO_SIGN_KEY_REQUIRED();
 
   var key = options.key || options;
   var passphrase = options.passphrase || null;
@@ -59,9 +65,7 @@ Sign.prototype.sign = function sign(options, encoding) {
     if (options.padding === options.padding >> 0) {
       rsaPadding = options.padding;
     } else {
-      throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                 'padding',
-                                 options.padding);
+      throw new ERR_INVALID_OPT_VALUE('padding', options.padding);
     }
   }
 
@@ -70,16 +74,16 @@ Sign.prototype.sign = function sign(options, encoding) {
     if (options.saltLength === options.saltLength >> 0) {
       pssSaltLength = options.saltLength;
     } else {
-      throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                 'saltLength',
-                                 options.saltLength);
+      throw new ERR_INVALID_OPT_VALUE('saltLength', options.saltLength);
     }
   }
 
   key = toBuf(key);
   if (!isArrayBufferView(key)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'key',
-                               ['string', 'Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE(
+      'key',
+      ['string', 'Buffer', 'TypedArray', 'DataView']
+    );
   }
 
   var ret = this._handle.sign(key, passphrase, rsaPadding, pssSaltLength);
@@ -96,7 +100,7 @@ function Verify(algorithm, options) {
   if (!(this instanceof Verify))
     return new Verify(algorithm, options);
   if (typeof algorithm !== 'string')
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'algorithm', 'string');
+    throw new ERR_INVALID_ARG_TYPE('algorithm', 'string');
   this._handle = new _Verify();
   this._handle.init(algorithm);
 
@@ -118,9 +122,7 @@ Verify.prototype.verify = function verify(options, signature, sigEncoding) {
     if (options.padding === options.padding >> 0) {
       rsaPadding = options.padding;
     } else {
-      throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                 'padding',
-                                 options.padding);
+      throw new ERR_INVALID_OPT_VALUE('padding', options.padding);
     }
   }
 
@@ -129,22 +131,24 @@ Verify.prototype.verify = function verify(options, signature, sigEncoding) {
     if (options.saltLength === options.saltLength >> 0) {
       pssSaltLength = options.saltLength;
     } else {
-      throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                 'saltLength',
-                                 options.saltLength);
+      throw new ERR_INVALID_OPT_VALUE('saltLength', options.saltLength);
     }
   }
 
   key = toBuf(key);
   if (!isArrayBufferView(key)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'key',
-                               ['string', 'Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE(
+      'key',
+      ['string', 'Buffer', 'TypedArray', 'DataView']
+    );
   }
 
   signature = toBuf(signature, sigEncoding);
   if (!isArrayBufferView(signature)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'signature',
-                               ['string', 'Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE(
+      'signature',
+      ['string', 'Buffer', 'TypedArray', 'DataView']
+    );
   }
 
   return this._handle.verify(key, signature, rsaPadding, pssSaltLength);
diff --git a/lib/internal/crypto/util.js b/lib/internal/crypto/util.js
index ac01a447bc..19c35ac4cd 100644
--- a/lib/internal/crypto/util.js
+++ b/lib/internal/crypto/util.js
@@ -12,7 +12,11 @@ const {
   ENGINE_METHOD_ALL
 } = process.binding('constants').crypto;
 
-const errors = require('internal/errors');
+const {
+  ERR_CRYPTO_ENGINE_UNKNOWN,
+  ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH,
+  ERR_INVALID_ARG_TYPE
+} = require('internal/errors').codes;
 const { Buffer } = require('buffer');
 const {
   cachedResult,
@@ -50,10 +54,10 @@ const getCurves = cachedResult(() => filterDuplicateStrings(_getCurves()));
 
 function setEngine(id, flags) {
   if (typeof id !== 'string')
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'id', 'string');
+    throw new ERR_INVALID_ARG_TYPE('id', 'string');
 
   if (flags && typeof flags !== 'number')
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'flags', 'number');
+    throw new ERR_INVALID_ARG_TYPE('flags', 'number');
   flags = flags >>> 0;
 
   // Use provided engine for everything by default
@@ -61,20 +65,18 @@ function setEngine(id, flags) {
     flags = ENGINE_METHOD_ALL;
 
   if (!_setEngine(id, flags))
-    throw new errors.Error('ERR_CRYPTO_ENGINE_UNKNOWN', id);
+    throw new ERR_CRYPTO_ENGINE_UNKNOWN(id);
 }
 
 function timingSafeEqual(a, b) {
   if (!isArrayBufferView(a)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'a',
-                               ['Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE('a', ['Buffer', 'TypedArray', 'DataView']);
   }
   if (!isArrayBufferView(b)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'b',
-                               ['Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE('b', ['Buffer', 'TypedArray', 'DataView']);
   }
   if (a.length !== b.length) {
-    throw new errors.RangeError('ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH');
+    throw new ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH();
   }
   return _timingSafeEqual(a, b);
 }
diff --git a/lib/internal/encoding.js b/lib/internal/encoding.js
index fc8ac555fc..1846fc5527 100644
--- a/lib/internal/encoding.js
+++ b/lib/internal/encoding.js
@@ -3,7 +3,13 @@
 // An implementation of the WHATWG Encoding Standard
 // https://encoding.spec.whatwg.org
 
-const errors = require('internal/errors');
+const {
+  ERR_ENCODING_INVALID_ENCODED_DATA,
+  ERR_ENCODING_NOT_SUPPORTED,
+  ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_THIS,
+  ERR_NO_ICU
+} = require('internal/errors').codes;
 const kHandle = Symbol('handle');
 const kFlags = Symbol('flags');
 const kEncoding = Symbol('encoding');
@@ -35,17 +41,17 @@ function lazyBuffer() {
 
 function validateEncoder(obj) {
   if (obj == null || obj[kEncoder] !== true)
-    throw new errors.TypeError('ERR_INVALID_THIS', 'TextEncoder');
+    throw new ERR_INVALID_THIS('TextEncoder');
 }
 
 function validateDecoder(obj) {
   if (obj == null || obj[kDecoder] !== true)
-    throw new errors.TypeError('ERR_INVALID_THIS', 'TextDecoder');
+    throw new ERR_INVALID_THIS('TextDecoder');
 }
 
 function validateArgument(prop, expected, propName, expectedName) {
   if (typeof prop !== expected)
-    throw new errors.Error('ERR_INVALID_ARG_TYPE', propName, expectedName);
+    throw new ERR_INVALID_ARG_TYPE(propName, expectedName);
 }
 
 const CONVERTER_FLAGS_FLUSH = 0x1;
@@ -360,7 +366,7 @@ function makeTextDecoderICU() {
 
       const enc = getEncodingFromLabel(encoding);
       if (enc === undefined)
-        throw new errors.RangeError('ERR_ENCODING_NOT_SUPPORTED', encoding);
+        throw new ERR_ENCODING_NOT_SUPPORTED(encoding);
 
       var flags = 0;
       if (options !== null) {
@@ -370,7 +376,7 @@ function makeTextDecoderICU() {
 
       const handle = getConverter(enc, flags);
       if (handle === undefined)
-        throw new errors.Error('ERR_ENCODING_NOT_SUPPORTED', encoding);
+        throw new ERR_ENCODING_NOT_SUPPORTED(encoding);
 
       this[kDecoder] = true;
       this[kHandle] = handle;
@@ -384,8 +390,8 @@ function makeTextDecoderICU() {
       if (isArrayBuffer(input)) {
         input = lazyBuffer().from(input);
       } else if (!isArrayBufferView(input)) {
-        throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'input',
-                                   ['ArrayBuffer', 'ArrayBufferView']);
+        throw new ERR_INVALID_ARG_TYPE('input',
+                                       ['ArrayBuffer', 'ArrayBufferView']);
       }
       validateArgument(options, 'object', 'options', 'Object');
 
@@ -395,8 +401,7 @@ function makeTextDecoderICU() {
 
       const ret = _decode(this[kHandle], input, flags);
       if (typeof ret === 'number') {
-        const err = new errors.TypeError('ERR_ENCODING_INVALID_ENCODED_DATA',
-                                         this.encoding);
+        const err = new ERR_ENCODING_INVALID_ENCODED_DATA(this.encoding);
         err.errno = ret;
         throw err;
       }
@@ -428,12 +433,12 @@ function makeTextDecoderJS() {
 
       const enc = getEncodingFromLabel(encoding);
       if (enc === undefined || !hasConverter(enc))
-        throw new errors.RangeError('ERR_ENCODING_NOT_SUPPORTED', encoding);
+        throw new ERR_ENCODING_NOT_SUPPORTED(encoding);
 
       var flags = 0;
       if (options !== null) {
         if (options.fatal) {
-          throw new errors.TypeError('ERR_NO_ICU', '"fatal" option');
+          throw new ERR_NO_ICU('"fatal" option');
         }
         flags |= options.ignoreBOM ? CONVERTER_FLAGS_IGNORE_BOM : 0;
       }
@@ -454,8 +459,8 @@ function makeTextDecoderJS() {
         input = lazyBuffer().from(input.buffer, input.byteOffset,
                                   input.byteLength);
       } else {
-        throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'input',
-                                   ['ArrayBuffer', 'ArrayBufferView']);
+        throw new ERR_INVALID_ARG_TYPE('input',
+                                       ['ArrayBuffer', 'ArrayBufferView']);
       }
       validateArgument(options, 'object', 'options', 'Object');
 
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index 0fdf795433..d5a5c4fc59 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -320,7 +320,7 @@ function createErrDiff(actual, expected, operator) {
 class AssertionError extends Error {
   constructor(options) {
     if (typeof options !== 'object' || options === null) {
-      throw new exports.TypeError('ERR_INVALID_ARG_TYPE', 'options', 'Object');
+      throw new codes.ERR_INVALID_ARG_TYPE('options', 'Object');
     }
     var {
       actual,
@@ -600,7 +600,7 @@ module.exports = exports = {
 // Note: Node.js specific errors must begin with the prefix ERR_
 
 E('ERR_ARG_NOT_ITERABLE', '%s must be iterable', TypeError);
-E('ERR_ASSERTION', '%s', AssertionError);
+E('ERR_ASSERTION', '%s', Error);
 E('ERR_ASYNC_CALLBACK', '%s must be a function', TypeError);
 E('ERR_ASYNC_TYPE', 'Invalid name for async "type": %s', TypeError);
 E('ERR_BUFFER_OUT_OF_BOUNDS', bufferOutOfBounds, RangeError);
@@ -622,7 +622,7 @@ E('ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED',
   'Custom engines not supported by this OpenSSL', Error);
 E('ERR_CRYPTO_ECDH_INVALID_FORMAT', 'Invalid ECDH format: %s', TypeError);
 E('ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY',
-  'Public key is not valid for specified curve', TypeError);
+  'Public key is not valid for specified curve', Error);
 E('ERR_CRYPTO_ENGINE_UNKNOWN', 'Engine "%s" was not found', Error);
 E('ERR_CRYPTO_FIPS_FORCED',
   'Cannot set FIPS mode, it was forced with --force-fips at startup.', Error);
@@ -653,7 +653,7 @@ E('ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE',
 E('ERR_ENCODING_INVALID_ENCODED_DATA',
   'The encoded data was not valid for encoding %s', TypeError);
 E('ERR_ENCODING_NOT_SUPPORTED', 'The "%s" encoding is not supported',
-  RangeError); // One entry is currently falsy implemented as "Error"
+  RangeError);
 E('ERR_FALSY_VALUE_REJECTION', 'Promise was rejected with falsy value', Error);
 E('ERR_FS_INVALID_SYMLINK_TYPE',
   'Symlink type must be one of "dir", "file", or "junction". Received "%s"',
@@ -846,7 +846,7 @@ E('ERR_SOCKET_DGRAM_NOT_RUNNING', 'Not running', Error);
 E('ERR_STDERR_CLOSE', 'process.stderr cannot be closed', Error);
 E('ERR_STDOUT_CLOSE', 'process.stdout cannot be closed', Error);
 E('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable', Error);
-E('ERR_STREAM_DESTROYED', 'Cannot call %s after a stream was destroyed');
+E('ERR_STREAM_DESTROYED', 'Cannot call %s after a stream was destroyed', Error);
 E('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
 E('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF', Error);
 E('ERR_STREAM_READ_NOT_IMPLEMENTED', '_read() is not implemented', Error);
diff --git a/lib/internal/fs.js b/lib/internal/fs.js
index 04844248b0..36155d4d67 100644
--- a/lib/internal/fs.js
+++ b/lib/internal/fs.js
@@ -2,7 +2,14 @@
 
 const { Buffer, kMaxLength } = require('buffer');
 const { Writable } = require('stream');
-const errors = require('internal/errors');
+const {
+  ERR_FS_INVALID_SYMLINK_TYPE,
+  ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_ARG_VALUE,
+  ERR_INVALID_OPT_VALUE,
+  ERR_INVALID_OPT_VALUE_ENCODING,
+  ERR_OUT_OF_RANGE
+} = require('internal/errors').codes;
 const { isUint8Array } = require('internal/util/types');
 const fs = require('fs');
 const pathModule = require('path');
@@ -34,7 +41,7 @@ const isWindows = process.platform === 'win32';
 
 function assertEncoding(encoding) {
   if (encoding && !Buffer.isEncoding(encoding)) {
-    throw new errors.TypeError('ERR_INVALID_OPT_VALUE_ENCODING', encoding);
+    throw new ERR_INVALID_OPT_VALUE_ENCODING(encoding);
   }
 }
 
@@ -56,10 +63,7 @@ function getOptions(options, defaultOptions) {
     defaultOptions.encoding = options;
     options = defaultOptions;
   } else if (typeof options !== 'object') {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
-                               'options',
-                               ['string', 'Object'],
-                               options);
+    throw new ERR_INVALID_ARG_TYPE('options', ['string', 'Object'], options);
   }
 
   if (options.encoding !== 'buffer')
@@ -97,9 +101,11 @@ function nullCheck(path, propName, throwError = true) {
     return;
   }
 
-  const err = new errors.Error(
-    'ERR_INVALID_ARG_VALUE', propName, path,
-    'must be a string or Uint8Array without null bytes');
+  const err = new ERR_INVALID_ARG_VALUE(
+    propName,
+    path,
+    'must be a string or Uint8Array without null bytes'
+  );
 
   if (throwError) {
     Error.captureStackTrace(err, nullCheck);
@@ -233,7 +239,7 @@ function stringToFlags(flags) {
     case 'sa+': return O_APPEND | O_CREAT | O_RDWR | O_SYNC;
   }
 
-  throw new errors.TypeError('ERR_INVALID_OPT_VALUE', 'flags', flags);
+  throw new ERR_INVALID_OPT_VALUE('flags', flags);
 }
 
 function stringToSymlinkType(type) {
@@ -249,7 +255,7 @@ function stringToSymlinkType(type) {
       case 'file':
         break;
       default:
-        const err = new errors.Error('ERR_FS_INVALID_SYMLINK_TYPE', type);
+        const err = new ERR_FS_INVALID_SYMLINK_TYPE(type);
         Error.captureStackTrace(err, stringToSymlinkType);
         throw err;
     }
@@ -312,16 +318,12 @@ function toUnixTimestamp(time, name = 'time') {
     // convert to 123.456 UNIX timestamp
     return time.getTime() / 1000;
   }
-  throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
-                             name,
-                             ['Date', 'Time in seconds'],
-                             time);
+  throw new ERR_INVALID_ARG_TYPE(name, ['Date', 'Time in seconds'], time);
 }
 
 function validateBuffer(buffer) {
   if (!isUint8Array(buffer)) {
-    const err = new errors.TypeError('ERR_INVALID_ARG_TYPE', 'buffer',
-                                     ['Buffer', 'Uint8Array']);
+    const err = new ERR_INVALID_ARG_TYPE('buffer', ['Buffer', 'Uint8Array']);
     Error.captureStackTrace(err, validateBuffer);
     throw err;
   }
@@ -331,7 +333,7 @@ function validateLen(len) {
   let err;
 
   if (!isInt32(len))
-    err = new errors.TypeError('ERR_INVALID_ARG_TYPE', 'len', 'integer');
+    err = new ERR_INVALID_ARG_TYPE('len', 'integer');
 
   if (err !== undefined) {
     Error.captureStackTrace(err, validateLen);
@@ -343,9 +345,9 @@ function validateOffsetLengthRead(offset, length, bufferLength) {
   let err;
 
   if (offset < 0 || offset >= bufferLength) {
-    err = new errors.RangeError('ERR_OUT_OF_RANGE', 'offset');
+    err = new ERR_OUT_OF_RANGE('offset');
   } else if (length < 0 || offset + length > bufferLength) {
-    err = new errors.RangeError('ERR_OUT_OF_RANGE', 'length');
+    err = new ERR_OUT_OF_RANGE('length');
   }
 
   if (err !== undefined) {
@@ -358,9 +360,9 @@ function validateOffsetLengthWrite(offset, length, byteLength) {
   let err;
 
   if (offset > byteLength) {
-    err = new errors.RangeError('ERR_OUT_OF_RANGE', 'offset');
+    err = new ERR_OUT_OF_RANGE('offset');
   } else if (offset + length > byteLength || offset + length > kMaxLength) {
-    err = new errors.RangeError('ERR_OUT_OF_RANGE', 'length');
+    err = new ERR_OUT_OF_RANGE('length');
   }
 
   if (err !== undefined) {
@@ -377,8 +379,7 @@ function validatePath(path, propName) {
   }
 
   if (typeof path !== 'string' && !isUint8Array(path)) {
-    err = new errors.TypeError('ERR_INVALID_ARG_TYPE', propName,
-                               ['string', 'Buffer', 'URL']);
+    err = new ERR_INVALID_ARG_TYPE(propName, ['string', 'Buffer', 'URL']);
   } else {
     err = nullCheck(path, propName, false);
   }
@@ -393,7 +394,7 @@ function validateUint32(value, propName) {
   let err;
 
   if (!isUint32(value))
-    err = new errors.TypeError('ERR_INVALID_ARG_TYPE', propName, 'integer');
+    err = new ERR_INVALID_ARG_TYPE(propName, 'integer');
 
   if (err !== undefined) {
     Error.captureStackTrace(err, validateUint32);
diff --git a/lib/internal/http2/compat.js b/lib/internal/http2/compat.js
index 9670843176..6ec6cb33cb 100644
--- a/lib/internal/http2/compat.js
+++ b/lib/internal/http2/compat.js
@@ -4,7 +4,18 @@ const Stream = require('stream');
 const Readable = Stream.Readable;
 const binding = process.binding('http2');
 const constants = binding.constants;
-const errors = require('internal/errors');
+const {
+  ERR_HTTP2_HEADERS_SENT,
+  ERR_HTTP2_INFO_STATUS_NOT_ALLOWED,
+  ERR_HTTP2_INVALID_HEADER_VALUE,
+  ERR_HTTP2_INVALID_STREAM,
+  ERR_HTTP2_NO_SOCKET_MANIPULATION,
+  ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED,
+  ERR_HTTP2_STATUS_INVALID,
+  ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_CALLBACK,
+  ERR_INVALID_HTTP_TOKEN
+} = require('internal/errors').codes;
 const { kSocket } = require('internal/http2/util');
 
 const kFinish = Symbol('finish');
@@ -42,11 +53,11 @@ let statusMessageWarned = false;
 function assertValidHeader(name, value) {
   let err;
   if (name === '' || typeof name !== 'string') {
-    err = new errors.TypeError('ERR_INVALID_HTTP_TOKEN', 'Header name', name);
+    err = new ERR_INVALID_HTTP_TOKEN('Header name', name);
   } else if (isPseudoHeader(name)) {
-    err = new errors.Error('ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED');
+    err = new ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED();
   } else if (value === undefined || value === null) {
-    err = new errors.TypeError('ERR_HTTP2_INVALID_HEADER_VALUE', value, name);
+    err = new ERR_HTTP2_INVALID_HEADER_VALUE(value, name);
   }
   if (err !== undefined) {
     Error.captureStackTrace(err, assertValidHeader);
@@ -163,7 +174,7 @@ const proxySocketHandler = {
       case 'read':
       case 'pause':
       case 'resume':
-        throw new errors.Error('ERR_HTTP2_NO_SOCKET_MANIPULATION');
+        throw new ERR_HTTP2_NO_SOCKET_MANIPULATION();
       default:
         const ref = stream.session !== undefined ?
           stream.session[kSocket] : stream;
@@ -199,7 +210,7 @@ const proxySocketHandler = {
       case 'read':
       case 'pause':
       case 'resume':
-        throw new errors.Error('ERR_HTTP2_NO_SOCKET_MANIPULATION');
+        throw new ERR_HTTP2_NO_SOCKET_MANIPULATION();
       default:
         const ref = stream.session !== undefined ?
           stream.session[kSocket] : stream;
@@ -292,7 +303,7 @@ class Http2ServerRequest extends Readable {
       state.didRead = true;
       process.nextTick(resumeStream, this[kStream]);
     } else {
-      this.emit('error', new errors.Error('ERR_HTTP2_INVALID_STREAM'));
+      this.emit('error', new ERR_HTTP2_INVALID_STREAM());
     }
   }
 
@@ -302,7 +313,7 @@ class Http2ServerRequest extends Readable {
 
   set method(method) {
     if (typeof method !== 'string' || method.trim() === '')
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'method', 'string');
+      throw new ERR_INVALID_ARG_TYPE('method', 'string');
 
     this[kHeaders][HTTP2_HEADER_METHOD] = method;
   }
@@ -419,15 +430,15 @@ class Http2ServerResponse extends Stream {
   set statusCode(code) {
     code |= 0;
     if (code >= 100 && code < 200)
-      throw new errors.RangeError('ERR_HTTP2_INFO_STATUS_NOT_ALLOWED');
+      throw new ERR_HTTP2_INFO_STATUS_NOT_ALLOWED();
     if (code < 100 || code > 599)
-      throw new errors.RangeError('ERR_HTTP2_STATUS_INVALID', code);
+      throw new ERR_HTTP2_STATUS_INVALID(code);
     this[kState].statusCode = code;
   }
 
   setTrailer(name, value) {
     if (typeof name !== 'string')
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'name', 'string');
+      throw new ERR_INVALID_ARG_TYPE('name', 'string');
 
     name = name.trim().toLowerCase();
     assertValidHeader(name, value);
@@ -445,7 +456,7 @@ class Http2ServerResponse extends Stream {
 
   getHeader(name) {
     if (typeof name !== 'string')
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'name', 'string');
+      throw new ERR_INVALID_ARG_TYPE('name', 'string');
 
     name = name.trim().toLowerCase();
     return this[kHeaders][name];
@@ -461,7 +472,7 @@ class Http2ServerResponse extends Stream {
 
   hasHeader(name) {
     if (typeof name !== 'string')
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'name', 'string');
+      throw new ERR_INVALID_ARG_TYPE('name', 'string');
 
     name = name.trim().toLowerCase();
     return Object.prototype.hasOwnProperty.call(this[kHeaders], name);
@@ -469,10 +480,10 @@ class Http2ServerResponse extends Stream {
 
   removeHeader(name) {
     if (typeof name !== 'string')
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'name', 'string');
+      throw new ERR_INVALID_ARG_TYPE('name', 'string');
 
     if (this[kStream].headersSent)
-      throw new errors.Error('ERR_HTTP2_HEADERS_SENT');
+      throw new ERR_HTTP2_HEADERS_SENT();
 
     name = name.trim().toLowerCase();
     delete this[kHeaders][name];
@@ -480,10 +491,10 @@ class Http2ServerResponse extends Stream {
 
   setHeader(name, value) {
     if (typeof name !== 'string')
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'name', 'string');
+      throw new ERR_INVALID_ARG_TYPE('name', 'string');
 
     if (this[kStream].headersSent)
-      throw new errors.Error('ERR_HTTP2_HEADERS_SENT');
+      throw new ERR_HTTP2_HEADERS_SENT();
 
     this[kSetHeader](name, value);
   }
@@ -514,9 +525,9 @@ class Http2ServerResponse extends Stream {
     const state = this[kState];
 
     if (state.closed)
-      throw new errors.Error('ERR_HTTP2_INVALID_STREAM');
+      throw new ERR_HTTP2_INVALID_STREAM();
     if (this[kStream].headersSent)
-      throw new errors.Error('ERR_HTTP2_HEADERS_SENT');
+      throw new ERR_HTTP2_HEADERS_SENT();
 
     if (typeof statusMessage === 'string')
       statusMessageWarn();
@@ -544,7 +555,7 @@ class Http2ServerResponse extends Stream {
     }
 
     if (this[kState].closed) {
-      const err = new errors.Error('ERR_HTTP2_INVALID_STREAM');
+      const err = new ERR_HTTP2_INVALID_STREAM();
       if (typeof cb === 'function')
         process.nextTick(cb, err);
       else
@@ -614,9 +625,9 @@ class Http2ServerResponse extends Stream {
 
   createPushResponse(headers, callback) {
     if (typeof callback !== 'function')
-      throw new errors.TypeError('ERR_INVALID_CALLBACK');
+      throw new ERR_INVALID_CALLBACK();
     if (this[kState].closed) {
-      process.nextTick(callback, new errors.Error('ERR_HTTP2_INVALID_STREAM'));
+      process.nextTick(callback, new ERR_HTTP2_INVALID_STREAM());
       return;
     }
     this[kStream].pushStream(headers, {}, (err, stream, headers, options) => {
diff --git a/lib/internal/http2/core.js b/lib/internal/http2/core.js
index f60c6388af..c764cd0297 100644
--- a/lib/internal/http2/core.js
+++ b/lib/internal/http2/core.js
@@ -14,7 +14,47 @@ const net = require('net');
 const tls = require('tls');
 const util = require('util');
 const fs = require('fs');
-const errors = require('internal/errors');
+const {
+  errnoException,
+  codes: {
+    ERR_HTTP2_ALTSVC_INVALID_ORIGIN,
+    ERR_HTTP2_ALTSVC_LENGTH,
+    ERR_HTTP2_CONNECT_AUTHORITY,
+    ERR_HTTP2_CONNECT_PATH,
+    ERR_HTTP2_CONNECT_SCHEME,
+    ERR_HTTP2_GOAWAY_SESSION,
+    ERR_HTTP2_HEADERS_AFTER_RESPOND,
+    ERR_HTTP2_HEADERS_SENT,
+    ERR_HTTP2_INVALID_INFO_STATUS,
+    ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH,
+    ERR_HTTP2_INVALID_SESSION,
+    ERR_HTTP2_INVALID_SETTING_VALUE,
+    ERR_HTTP2_INVALID_STREAM,
+    ERR_HTTP2_MAX_PENDING_SETTINGS_ACK,
+    ERR_HTTP2_NO_SOCKET_MANIPULATION,
+    ERR_HTTP2_OUT_OF_STREAMS,
+    ERR_HTTP2_PAYLOAD_FORBIDDEN,
+    ERR_HTTP2_PING_CANCEL,
+    ERR_HTTP2_PING_LENGTH,
+    ERR_HTTP2_PUSH_DISABLED,
+    ERR_HTTP2_SEND_FILE,
+    ERR_HTTP2_SESSION_ERROR,
+    ERR_HTTP2_SETTINGS_CANCEL,
+    ERR_HTTP2_SOCKET_BOUND,
+    ERR_HTTP2_STATUS_101,
+    ERR_HTTP2_STATUS_INVALID,
+    ERR_HTTP2_STREAM_CANCEL,
+    ERR_HTTP2_STREAM_ERROR,
+    ERR_HTTP2_STREAM_SELF_DEPENDENCY,
+    ERR_HTTP2_UNSUPPORTED_PROTOCOL,
+    ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_CALLBACK,
+    ERR_INVALID_CHAR,
+    ERR_INVALID_OPT_VALUE,
+    ERR_OUT_OF_RANGE,
+    ERR_SOCKET_CLOSED
+  }
+} = require('internal/errors');
 const { StreamWrap } = require('_stream_wrap');
 const { Duplex } = require('stream');
 const { URL } = require('url');
@@ -437,7 +477,7 @@ function onGoawayData(code, lastStreamID, buf) {
     // goaway using NGHTTP2_NO_ERROR because there was no error
     // condition on this side of the session that caused the
     // shutdown.
-    session.destroy(new errors.Error('ERR_HTTP2_SESSION_ERROR', code),
+    session.destroy(new ERR_HTTP2_SESSION_ERROR(code),
                     { errorCode: NGHTTP2_NO_ERROR });
   }
 }
@@ -468,7 +508,7 @@ function requestOnConnect(headers, options) {
   // If the session was closed while waiting for the connect, destroy
   // the stream and do not continue with the request.
   if (session.closed) {
-    const err = new errors.Error('ERR_HTTP2_GOAWAY_SESSION');
+    const err = new ERR_HTTP2_GOAWAY_SESSION();
     this.destroy(err);
     return;
   }
@@ -506,11 +546,11 @@ function requestOnConnect(headers, options) {
     let err;
     switch (ret) {
       case NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE:
-        err = new errors.Error('ERR_HTTP2_OUT_OF_STREAMS');
+        err = new ERR_HTTP2_OUT_OF_STREAMS();
         this.destroy(err);
         break;
       case NGHTTP2_ERR_INVALID_ARGUMENT:
-        err = new errors.Error('ERR_HTTP2_STREAM_SELF_DEPENDENCY');
+        err = new ERR_HTTP2_STREAM_SELF_DEPENDENCY();
         this.destroy(err);
         break;
       default:
@@ -533,33 +573,25 @@ function validatePriorityOptions(options) {
   if (options.weight === undefined) {
     options.weight = NGHTTP2_DEFAULT_WEIGHT;
   } else if (typeof options.weight !== 'number') {
-    err = new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                               'weight',
-                               options.weight);
+    err = new ERR_INVALID_OPT_VALUE('weight', options.weight);
   }
 
   if (options.parent === undefined) {
     options.parent = 0;
   } else if (typeof options.parent !== 'number' || options.parent < 0) {
-    err = new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                               'parent',
-                               options.parent);
+    err = new ERR_INVALID_OPT_VALUE('parent', options.parent);
   }
 
   if (options.exclusive === undefined) {
     options.exclusive = false;
   } else if (typeof options.exclusive !== 'boolean') {
-    err = new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                               'exclusive',
-                               options.exclusive);
+    err = new ERR_INVALID_OPT_VALUE('exclusive', options.exclusive);
   }
 
   if (options.silent === undefined) {
     options.silent = false;
   } else if (typeof options.silent !== 'boolean') {
-    err = new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                               'silent',
-                               options.silent);
+    err = new ERR_INVALID_OPT_VALUE('silent', options.silent);
   }
 
   if (err) {
@@ -587,7 +619,7 @@ function settingsCallback(cb, ack, duration) {
   } else {
     debug(`Http2Session ${sessionName(this[kType])}: settings canceled`);
     if (typeof cb === 'function')
-      cb(new errors.Error('ERR_HTTP2_SETTINGS_CANCEL'));
+      cb(new ERR_HTTP2_SETTINGS_CANCEL());
   }
 }
 
@@ -599,7 +631,7 @@ function submitSettings(settings, callback) {
   this[kUpdateTimer]();
   updateSettingsBuffer(settings);
   if (!this[kHandle].settings(settingsCallback.bind(this, callback))) {
-    this.destroy(new errors.Error('ERR_HTTP2_MAX_PENDING_SETTINGS_ACK'));
+    this.destroy(new ERR_HTTP2_MAX_PENDING_SETTINGS_ACK());
   }
 }
 
@@ -646,7 +678,7 @@ const proxySocketHandler = {
       case 'read':
       case 'resume':
       case 'write':
-        throw new errors.Error('ERR_HTTP2_NO_SOCKET_MANIPULATION');
+        throw new ERR_HTTP2_NO_SOCKET_MANIPULATION();
       default:
         const socket = session[kSocket];
         const value = socket[prop];
@@ -668,7 +700,7 @@ const proxySocketHandler = {
       case 'read':
       case 'resume':
       case 'write':
-        throw new errors.Error('ERR_HTTP2_NO_SOCKET_MANIPULATION');
+        throw new ERR_HTTP2_NO_SOCKET_MANIPULATION();
       default:
         session[kSocket][prop] = value;
         return true;
@@ -684,7 +716,7 @@ const proxySocketHandler = {
 // data received on the PING acknowlegement.
 function pingCallback(cb) {
   return function pingCallback(ack, duration, payload) {
-    const err = ack ? null : new errors.Error('ERR_HTTP2_PING_CANCEL');
+    const err = ack ? null : new ERR_HTTP2_PING_CANCEL();
     cb(err, duration, payload);
   };
 }
@@ -716,8 +748,8 @@ function validateSettings(settings) {
                     0, kMaxInt);
   if (settings.enablePush !== undefined &&
       typeof settings.enablePush !== 'boolean') {
-    const err = new errors.TypeError('ERR_HTTP2_INVALID_SETTING_VALUE',
-                                     'enablePush', settings.enablePush);
+    const err = new ERR_HTTP2_INVALID_SETTING_VALUE('enablePush',
+                                                    settings.enablePush);
     err.actual = settings.enablePush;
     Error.captureStackTrace(err, 'validateSettings');
     throw err;
@@ -838,7 +870,7 @@ class Http2Session extends EventEmitter {
     // then it has already been bound to an Http2Session instance
     // and cannot be attached again.
     if (socket[kSession] !== undefined)
-      throw new errors.Error('ERR_HTTP2_SOCKET_BOUND');
+      throw new ERR_HTTP2_SOCKET_BOUND();
 
     socket[kSession] = this;
 
@@ -945,13 +977,12 @@ class Http2Session extends EventEmitter {
   // value also needs to be larger than the current next stream ID.
   setNextStreamID(id) {
     if (this.destroyed)
-      throw new errors.Error('ERR_HTTP2_INVALID_SESSION');
+      throw new ERR_HTTP2_INVALID_SESSION();
 
     if (typeof id !== 'number')
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'id', 'number');
+      throw new ERR_INVALID_ARG_TYPE('id', 'number');
     if (id <= 0 || id > kMaxStreams)
-      throw new errors.RangeError('ERR_OUT_OF_RANGE', 'id',
-                                  `> 0 and <= ${kMaxStreams}`, id);
+      throw new ERR_OUT_OF_RANGE('id', `> 0 and <= ${kMaxStreams}`, id);
     this[kHandle].setNextStreamID(id);
   }
 
@@ -960,22 +991,21 @@ class Http2Session extends EventEmitter {
   // cancelled error and a duration of 0.0.
   ping(payload, callback) {
     if (this.destroyed)
-      throw new errors.Error('ERR_HTTP2_INVALID_SESSION');
+      throw new ERR_HTTP2_INVALID_SESSION();
 
     if (typeof payload === 'function') {
       callback = payload;
       payload = undefined;
     }
     if (payload && !isArrayBufferView(payload)) {
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
-                                 'payload',
-                                 ['Buffer', 'TypedArray', 'DataView']);
+      throw new ERR_INVALID_ARG_TYPE('payload',
+                                     ['Buffer', 'TypedArray', 'DataView']);
     }
     if (payload && payload.length !== 8) {
-      throw new errors.RangeError('ERR_HTTP2_PING_LENGTH');
+      throw new ERR_HTTP2_PING_LENGTH();
     }
     if (typeof callback !== 'function')
-      throw new errors.TypeError('ERR_INVALID_CALLBACK');
+      throw new ERR_INVALID_CALLBACK();
 
     const cb = pingCallback(callback);
     if (this.connecting || this.closed) {
@@ -1060,12 +1090,12 @@ class Http2Session extends EventEmitter {
   // Submits a SETTINGS frame to be sent to the remote peer.
   settings(settings, callback) {
     if (this.destroyed)
-      throw new errors.Error('ERR_HTTP2_INVALID_SESSION');
+      throw new ERR_HTTP2_INVALID_SESSION();
     assertIsObject(settings, 'settings');
     settings = validateSettings(settings);
 
     if (callback && typeof callback !== 'function')
-      throw new errors.TypeError('ERR_INVALID_CALLBACK');
+      throw new ERR_INVALID_CALLBACK();
     debug(`Http2Session ${sessionName(this[kType])}: sending settings`);
 
     this[kState].pendingAck++;
@@ -1084,19 +1114,17 @@ class Http2Session extends EventEmitter {
   // be rejected automatically.
   goaway(code = NGHTTP2_NO_ERROR, lastStreamID = 0, opaqueData) {
     if (this.destroyed)
-      throw new errors.Error('ERR_HTTP2_INVALID_SESSION');
+      throw new ERR_HTTP2_INVALID_SESSION();
 
     if (opaqueData !== undefined && !isArrayBufferView(opaqueData)) {
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
-                                 'opaqueData',
-                                 ['Buffer', 'TypedArray', 'DataView']);
+      throw new ERR_INVALID_ARG_TYPE('opaqueData',
+                                     ['Buffer', 'TypedArray', 'DataView']);
     }
     if (typeof code !== 'number') {
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'code', 'number');
+      throw new ERR_INVALID_ARG_TYPE('code', 'number');
     }
     if (typeof lastStreamID !== 'number') {
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
-                                 'lastStreamID', 'number');
+      throw new ERR_INVALID_ARG_TYPE('lastStreamID', 'number');
     }
 
     const goawayFn = submitGoaway.bind(this, code, lastStreamID, opaqueData);
@@ -1118,7 +1146,7 @@ class Http2Session extends EventEmitter {
       code = error;
       error =
         code !== NGHTTP2_NO_ERROR ?
-          new errors.Error('ERR_HTTP2_SESSION_ERROR', code) : undefined;
+          new ERR_HTTP2_SESSION_ERROR(code) : undefined;
     }
     if (code === undefined && error != null)
       code = NGHTTP2_INTERNAL_ERROR;
@@ -1131,7 +1159,7 @@ class Http2Session extends EventEmitter {
     this.removeAllListeners('timeout');
 
     // Destroy any pending and open streams
-    const cancel = new errors.Error('ERR_HTTP2_STREAM_CANCEL');
+    const cancel = new ERR_HTTP2_STREAM_CANCEL();
     if (error) {
       cancel.cause = error;
       if (typeof error.message === 'string')
@@ -1265,7 +1293,7 @@ class ServerHttp2Session extends Http2Session {
   // API is provided for that.
   altsvc(alt, originOrStream) {
     if (this.destroyed)
-      throw new errors.Error('ERR_HTTP2_INVALID_SESSION');
+      throw new ERR_HTTP2_INVALID_SESSION();
 
     let stream = 0;
     let origin;
@@ -1273,10 +1301,10 @@ class ServerHttp2Session extends Http2Session {
     if (typeof originOrStream === 'string') {
       origin = (new URL(originOrStream)).origin;
       if (origin === 'null')
-        throw new errors.TypeError('ERR_HTTP2_ALTSVC_INVALID_ORIGIN');
+        throw new ERR_HTTP2_ALTSVC_INVALID_ORIGIN();
     } else if (typeof originOrStream === 'number') {
       if (originOrStream >>> 0 !== originOrStream || originOrStream === 0)
-        throw new errors.RangeError('ERR_OUT_OF_RANGE', 'originOrStream');
+        throw new ERR_OUT_OF_RANGE('originOrStream');
       stream = originOrStream;
     } else if (originOrStream !== undefined) {
       // Allow origin to be passed a URL or object with origin property
@@ -1288,21 +1316,21 @@ class ServerHttp2Session extends Http2Session {
       // ensure they are doing the right thing or the payload data will
       // be invalid.
       if (typeof origin !== 'string') {
-        throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'originOrStream',
-                                   ['string', 'number', 'URL', 'object']);
+        throw new ERR_INVALID_ARG_TYPE('originOrStream',
+                                       ['string', 'number', 'URL', 'object']);
       } else if (origin === 'null' || origin.length === 0) {
-        throw new errors.TypeError('ERR_HTTP2_ALTSVC_INVALID_ORIGIN');
+        throw new ERR_HTTP2_ALTSVC_INVALID_ORIGIN();
       }
     }
 
     if (typeof alt !== 'string')
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'alt', 'string');
+      throw new ERR_INVALID_ARG_TYPE('alt', 'string');
     if (!kQuotedString.test(alt))
-      throw new errors.TypeError('ERR_INVALID_CHAR', 'alt');
+      throw new ERR_INVALID_CHAR('alt');
 
     // Max length permitted for ALTSVC
     if ((alt.length + (origin !== undefined ? origin.length : 0)) > 16382)
-      throw new errors.TypeError('ERR_HTTP2_ALTSVC_LENGTH');
+      throw new ERR_HTTP2_ALTSVC_LENGTH();
 
     this[kHandle].altsvc(stream, origin || '', alt);
   }
@@ -1323,10 +1351,10 @@ class ClientHttp2Session extends Http2Session {
     debug(`Http2Session ${sessionName(this[kType])}: initiating request`);
 
     if (this.destroyed)
-      throw new errors.Error('ERR_HTTP2_INVALID_SESSION');
+      throw new ERR_HTTP2_INVALID_SESSION();
 
     if (this.closed)
-      throw new errors.Error('ERR_HTTP2_GOAWAY_SESSION');
+      throw new ERR_HTTP2_GOAWAY_SESSION();
 
     this[kUpdateTimer]();
 
@@ -1350,11 +1378,11 @@ class ClientHttp2Session extends Http2Session {
         headers[HTTP2_HEADER_PATH] = '/';
     } else {
       if (headers[HTTP2_HEADER_AUTHORITY] === undefined)
-        throw new errors.Error('ERR_HTTP2_CONNECT_AUTHORITY');
+        throw new ERR_HTTP2_CONNECT_AUTHORITY();
       if (headers[HTTP2_HEADER_SCHEME] !== undefined)
-        throw new errors.Error('ERR_HTTP2_CONNECT_SCHEME');
+        throw new ERR_HTTP2_CONNECT_SCHEME();
       if (headers[HTTP2_HEADER_PATH] !== undefined)
-        throw new errors.Error('ERR_HTTP2_CONNECT_PATH');
+        throw new ERR_HTTP2_CONNECT_PATH();
     }
 
     validatePriorityOptions(options);
@@ -1365,16 +1393,12 @@ class ClientHttp2Session extends Http2Session {
       // preference.
       options.endStream = isPayloadMeaningless(headers[HTTP2_HEADER_METHOD]);
     } else if (typeof options.endStream !== 'boolean') {
-      throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                 'endStream',
-                                 options.endStream);
+      throw new ERR_INVALID_OPT_VALUE('endStream', options.endStream);
     }
 
     if (options.getTrailers !== undefined &&
       typeof options.getTrailers !== 'function') {
-      throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                 'getTrailers',
-                                 options.getTrailers);
+      throw new ERR_INVALID_OPT_VALUE('getTrailers', options.getTrailers);
     }
 
     const headersList = mapToHeaders(headers);
@@ -1653,7 +1677,7 @@ class Http2Stream extends Duplex {
     req.async = false;
     const err = createWriteReq(req, handle, data, encoding);
     if (err)
-      throw errors.errnoException(err, 'write', req.error);
+      throw errnoException(err, 'write', req.error);
     trackWriteState(this, req.bytes);
   }
 
@@ -1696,7 +1720,7 @@ class Http2Stream extends Duplex {
     }
     const err = handle.writev(req, chunks);
     if (err)
-      throw errors.errnoException(err, 'write', req.error);
+      throw errnoException(err, 'write', req.error);
     trackWriteState(this, req.bytes);
   }
 
@@ -1731,7 +1755,7 @@ class Http2Stream extends Duplex {
 
   priority(options) {
     if (this.destroyed)
-      throw new errors.Error('ERR_HTTP2_INVALID_STREAM');
+      throw new ERR_HTTP2_INVALID_STREAM();
 
     assertIsObject(options, 'options');
     options = Object.assign({}, options);
@@ -1767,11 +1791,11 @@ class Http2Stream extends Duplex {
   // but no DATA and HEADERS frames may be sent.
   close(code = NGHTTP2_NO_ERROR, callback) {
     if (typeof code !== 'number')
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'code', 'number');
+      throw new ERR_INVALID_ARG_TYPE('code', 'number');
     if (code < 0 || code > kMaxInt)
-      throw new errors.RangeError('ERR_OUT_OF_RANGE', 'code');
+      throw new ERR_OUT_OF_RANGE('code');
     if (callback !== undefined && typeof callback !== 'function')
-      throw new errors.TypeError('ERR_INVALID_CALLBACK');
+      throw new ERR_INVALID_CALLBACK();
 
     // Clear timeout and remove timeout listeners
     this.setTimeout(0);
@@ -1850,8 +1874,7 @@ class Http2Stream extends Duplex {
     // abort and is already covered by aborted event, also allows more
     // seamless compatibility with http1
     if (err == null && code !== NGHTTP2_NO_ERROR && code !== NGHTTP2_CANCEL)
-      err = new errors.Error('ERR_HTTP2_STREAM_ERROR',
-                             nameForErrorCode[code] || code);
+      err = new ERR_HTTP2_STREAM_ERROR(nameForErrorCode[code] || code);
 
     this[kSession] = undefined;
     this[kHandle] = undefined;
@@ -1900,8 +1923,7 @@ function processHeaders(headers) {
   // This will have an impact on the compatibility layer for anyone using
   // non-standard, non-compliant status codes.
   if (statusCode < 200 || statusCode > 599)
-    throw new errors.RangeError('ERR_HTTP2_STATUS_INVALID',
-                                headers[HTTP2_HEADER_STATUS]);
+    throw new ERR_HTTP2_STATUS_INVALID(headers[HTTP2_HEADER_STATUS]);
 
   return headers;
 }
@@ -1947,7 +1969,7 @@ function doSendFD(session, options, fd, headers, streamOptions, err, stat) {
   // In either case, we do not want to continue because the we are shutting
   // down and should not attempt to send any data.
   if (this.destroyed || this.closed) {
-    this.destroy(new errors.Error('ERR_HTTP2_INVALID_STREAM'));
+    this.destroy(new ERR_HTTP2_INVALID_STREAM());
     return;
   }
 
@@ -1986,7 +2008,7 @@ function doSendFileFD(session, options, fd, headers, streamOptions, err, stat) {
   }
 
   if (!stat.isFile()) {
-    const err = new errors.Error('ERR_HTTP2_SEND_FILE');
+    const err = new ERR_HTTP2_SEND_FILE();
     if (onError)
       onError(err);
     else
@@ -1996,7 +2018,7 @@ function doSendFileFD(session, options, fd, headers, streamOptions, err, stat) {
 
   if (this.destroyed || this.closed) {
     tryClose(fd);
-    this.destroy(new errors.Error('ERR_HTTP2_INVALID_STREAM'));
+    this.destroy(new ERR_HTTP2_INVALID_STREAM());
     return;
   }
 
@@ -2079,7 +2101,7 @@ class ServerHttp2Stream extends Http2Stream {
   // Http2Stream for the push stream.
   pushStream(headers, options, callback) {
     if (!this.pushAllowed)
-      throw new errors.Error('ERR_HTTP2_PUSH_DISABLED');
+      throw new ERR_HTTP2_PUSH_DISABLED();
 
     const session = this[kSession];
 
@@ -2094,7 +2116,7 @@ class ServerHttp2Stream extends Http2Stream {
     }
 
     if (typeof callback !== 'function')
-      throw new errors.TypeError('ERR_INVALID_CALLBACK');
+      throw new ERR_INVALID_CALLBACK();
 
     assertIsObject(options, 'options');
     options = Object.assign({}, options);
@@ -2128,10 +2150,10 @@ class ServerHttp2Stream extends Http2Stream {
     if (typeof ret === 'number') {
       switch (ret) {
         case NGHTTP2_ERR_STREAM_ID_NOT_AVAILABLE:
-          err = new errors.Error('ERR_HTTP2_OUT_OF_STREAMS');
+          err = new ERR_HTTP2_OUT_OF_STREAMS();
           break;
         case NGHTTP2_ERR_STREAM_CLOSED:
-          err = new errors.Error('ERR_HTTP2_INVALID_STREAM');
+          err = new ERR_HTTP2_INVALID_STREAM();
           break;
         default:
           err = new NghttpError(ret);
@@ -2157,9 +2179,9 @@ class ServerHttp2Stream extends Http2Stream {
   // Initiate a response on this Http2Stream
   respond(headers, options) {
     if (this.destroyed || this.closed)
-      throw new errors.Error('ERR_HTTP2_INVALID_STREAM');
+      throw new ERR_HTTP2_INVALID_STREAM();
     if (this.headersSent)
-      throw new errors.Error('ERR_HTTP2_HEADERS_SENT');
+      throw new ERR_HTTP2_HEADERS_SENT();
 
     const state = this[kState];
 
@@ -2179,9 +2201,7 @@ class ServerHttp2Stream extends Http2Stream {
 
     if (options.getTrailers !== undefined) {
       if (typeof options.getTrailers !== 'function') {
-        throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                   'getTrailers',
-                                   options.getTrailers);
+        throw new ERR_INVALID_OPT_VALUE('getTrailers', options.getTrailers);
       }
       streamOptions |= STREAM_OPTION_GET_TRAILERS;
       state.getTrailers = options.getTrailers;
@@ -2224,9 +2244,9 @@ class ServerHttp2Stream extends Http2Stream {
   // reset with an error code.
   respondWithFD(fd, headers, options) {
     if (this.destroyed || this.closed)
-      throw new errors.Error('ERR_HTTP2_INVALID_STREAM');
+      throw new ERR_HTTP2_INVALID_STREAM();
     if (this.headersSent)
-      throw new errors.Error('ERR_HTTP2_HEADERS_SENT');
+      throw new ERR_HTTP2_HEADERS_SENT();
 
     const session = this[kSession];
 
@@ -2234,36 +2254,27 @@ class ServerHttp2Stream extends Http2Stream {
     options = Object.assign({}, options);
 
     if (options.offset !== undefined && typeof options.offset !== 'number')
-      throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                 'offset',
-                                 options.offset);
+      throw new ERR_INVALID_OPT_VALUE('offset', options.offset);
 
     if (options.length !== undefined && typeof options.length !== 'number')
-      throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                 'length',
-                                 options.length);
+      throw new ERR_INVALID_OPT_VALUE('length', options.length);
 
     if (options.statCheck !== undefined &&
         typeof options.statCheck !== 'function') {
-      throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                 'statCheck',
-                                 options.statCheck);
+      throw new ERR_INVALID_OPT_VALUE('statCheck', options.statCheck);
     }
 
     let streamOptions = 0;
     if (options.getTrailers !== undefined) {
       if (typeof options.getTrailers !== 'function') {
-        throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                   'getTrailers',
-                                   options.getTrailers);
+        throw new ERR_INVALID_OPT_VALUE('getTrailers', options.getTrailers);
       }
       streamOptions |= STREAM_OPTION_GET_TRAILERS;
       this[kState].getTrailers = options.getTrailers;
     }
 
     if (typeof fd !== 'number')
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
-                                 'fd', 'number');
+      throw new ERR_INVALID_ARG_TYPE('fd', 'number');
 
     debug(`Http2Stream ${this[kID]} [Http2Session ` +
           `${sessionName(session[kType])}]: initiating response`);
@@ -2275,7 +2286,7 @@ class ServerHttp2Stream extends Http2Stream {
     if (statusCode === HTTP_STATUS_NO_CONTENT ||
         statusCode === HTTP_STATUS_RESET_CONTENT ||
         statusCode === HTTP_STATUS_NOT_MODIFIED) {
-      throw new errors.Error('ERR_HTTP2_PAYLOAD_FORBIDDEN', statusCode);
+      throw new ERR_HTTP2_PAYLOAD_FORBIDDEN(statusCode);
     }
 
     if (options.statCheck !== undefined) {
@@ -2300,36 +2311,28 @@ class ServerHttp2Stream extends Http2Stream {
   // file details are sent.
   respondWithFile(path, headers, options) {
     if (this.destroyed || this.closed)
-      throw new errors.Error('ERR_HTTP2_INVALID_STREAM');
+      throw new ERR_HTTP2_INVALID_STREAM();
     if (this.headersSent)
-      throw new errors.Error('ERR_HTTP2_HEADERS_SENT');
+      throw new ERR_HTTP2_HEADERS_SENT();
 
     assertIsObject(options, 'options');
     options = Object.assign({}, options);
 
     if (options.offset !== undefined && typeof options.offset !== 'number')
-      throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                 'offset',
-                                 options.offset);
+      throw new ERR_INVALID_OPT_VALUE('offset', options.offset);
 
     if (options.length !== undefined && typeof options.length !== 'number')
-      throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                 'length',
-                                 options.length);
+      throw new ERR_INVALID_OPT_VALUE('length', options.length);
 
     if (options.statCheck !== undefined &&
         typeof options.statCheck !== 'function') {
-      throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                 'statCheck',
-                                 options.statCheck);
+      throw new ERR_INVALID_OPT_VALUE('statCheck', options.statCheck);
     }
 
     let streamOptions = 0;
     if (options.getTrailers !== undefined) {
       if (typeof options.getTrailers !== 'function') {
-        throw new errors.TypeError('ERR_INVALID_OPT_VALUE',
-                                   'getTrailers',
-                                   options.getTrailers);
+        throw new ERR_INVALID_OPT_VALUE('getTrailers', options.getTrailers);
       }
       streamOptions |= STREAM_OPTION_GET_TRAILERS;
       this[kState].getTrailers = options.getTrailers;
@@ -2347,7 +2350,7 @@ class ServerHttp2Stream extends Http2Stream {
     if (statusCode === HTTP_STATUS_NO_CONTENT ||
         statusCode === HTTP_STATUS_RESET_CONTENT ||
         statusCode === HTTP_STATUS_NOT_MODIFIED) {
-      throw new errors.Error('ERR_HTTP2_PAYLOAD_FORBIDDEN', statusCode);
+      throw new ERR_HTTP2_PAYLOAD_FORBIDDEN(statusCode);
     }
 
     fs.open(path, 'r',
@@ -2363,9 +2366,9 @@ class ServerHttp2Stream extends Http2Stream {
   // headers are sent, or an error will be thrown.
   additionalHeaders(headers) {
     if (this.destroyed || this.closed)
-      throw new errors.Error('ERR_HTTP2_INVALID_STREAM');
+      throw new ERR_HTTP2_INVALID_STREAM();
     if (this.headersSent)
-      throw new errors.Error('ERR_HTTP2_HEADERS_AFTER_RESPOND');
+      throw new ERR_HTTP2_HEADERS_AFTER_RESPOND();
 
     assertIsObject(headers, 'headers');
     headers = Object.assign(Object.create(null), headers);
@@ -2377,10 +2380,9 @@ class ServerHttp2Stream extends Http2Stream {
     if (headers[HTTP2_HEADER_STATUS] != null) {
       const statusCode = headers[HTTP2_HEADER_STATUS] |= 0;
       if (statusCode === HTTP_STATUS_SWITCHING_PROTOCOLS)
-        throw new errors.Error('ERR_HTTP2_STATUS_101');
+        throw new ERR_HTTP2_STATUS_101();
       if (statusCode < 100 || statusCode >= 200) {
-        throw new errors.RangeError('ERR_HTTP2_INVALID_INFO_STATUS',
-                                    headers[HTTP2_HEADER_STATUS]);
+        throw new ERR_HTTP2_INVALID_INFO_STATUS(headers[HTTP2_HEADER_STATUS]);
       }
     }
 
@@ -2435,7 +2437,7 @@ const setTimeout = {
     if (msecs === 0) {
       if (callback !== undefined) {
         if (typeof callback !== 'function')
-          throw new errors.TypeError('ERR_INVALID_CALLBACK');
+          throw new ERR_INVALID_CALLBACK();
         this.removeListener('timeout', callback);
       }
     } else {
@@ -2444,7 +2446,7 @@ const setTimeout = {
 
       if (callback !== undefined) {
         if (typeof callback !== 'function')
-          throw new errors.TypeError('ERR_INVALID_CALLBACK');
+          throw new ERR_INVALID_CALLBACK();
         this.once('timeout', callback);
       }
     }
@@ -2589,7 +2591,7 @@ class Http2SecureServer extends TLSServer {
     this.timeout = msecs;
     if (callback !== undefined) {
       if (typeof callback !== 'function')
-        throw new errors.TypeError('ERR_INVALID_CALLBACK');
+        throw new ERR_INVALID_CALLBACK();
       this.on('timeout', callback);
     }
     return this;
@@ -2610,7 +2612,7 @@ class Http2Server extends NETServer {
     this.timeout = msecs;
     if (callback !== undefined) {
       if (typeof callback !== 'function')
-        throw new errors.TypeError('ERR_INVALID_CALLBACK');
+        throw new ERR_INVALID_CALLBACK();
       this.on('timeout', callback);
     }
     return this;
@@ -2632,8 +2634,7 @@ function socketOnClose() {
   const session = this[kSession];
   if (session !== undefined) {
     debug(`Http2Session ${sessionName(session[kType])}: socket closed`);
-    const err = session.connecting ?
-      new errors.Error('ERR_SOCKET_CLOSED') : null;
+    const err = session.connecting ? new ERR_SOCKET_CLOSED() : null;
     const state = session[kState];
     state.streams.forEach((stream) => stream.close(NGHTTP2_CANCEL));
     state.pendingStreams.forEach((stream) => stream.close(NGHTTP2_CANCEL));
@@ -2673,7 +2674,7 @@ function connect(authority, options, listener) {
         socket = tls.connect(port, host, initializeTLSOptions(options, host));
         break;
       default:
-        throw new errors.Error('ERR_HTTP2_UNSUPPORTED_PROTOCOL', protocol);
+        throw new ERR_HTTP2_UNSUPPORTED_PROTOCOL(protocol);
     }
   }
 
@@ -2726,11 +2727,10 @@ function getPackedSettings(settings) {
 
 function getUnpackedSettings(buf, options = {}) {
   if (!isArrayBufferView(buf)) {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'buf',
-                               ['Buffer', 'TypedArray', 'DataView']);
+    throw new ERR_INVALID_ARG_TYPE('buf', ['Buffer', 'TypedArray', 'DataView']);
   }
   if (buf.length % 6 !== 0)
-    throw new errors.RangeError('ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH');
+    throw new ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH();
   const settings = {};
   let offset = 0;
   while (offset < buf.length) {
diff --git a/lib/internal/http2/util.js b/lib/internal/http2/util.js
index 1411ab7cf7..b9bd580af2 100644
--- a/lib/internal/http2/util.js
+++ b/lib/internal/http2/util.js
@@ -1,7 +1,13 @@
 'use strict';
 
 const binding = process.binding('http2');
-const errors = require('internal/errors');
+const {
+  ERR_HTTP2_HEADER_SINGLE_VALUE,
+  ERR_HTTP2_INVALID_CONNECTION_HEADERS,
+  ERR_HTTP2_INVALID_PSEUDOHEADER,
+  ERR_HTTP2_INVALID_SETTING_VALUE,
+  ERR_INVALID_ARG_TYPE
+} = require('internal/errors').codes;
 
 const kSocket = Symbol('socket');
 
@@ -382,7 +388,7 @@ function isIllegalConnectionSpecificHeader(name, value) {
 
 function assertValidPseudoHeader(key) {
   if (!kValidPseudoHeaders.has(key)) {
-    const err = new errors.Error('ERR_HTTP2_INVALID_PSEUDOHEADER', key);
+    const err = new ERR_HTTP2_INVALID_PSEUDOHEADER(key);
     Error.captureStackTrace(err, assertValidPseudoHeader);
     return err;
   }
@@ -390,14 +396,14 @@ function assertValidPseudoHeader(key) {
 
 function assertValidPseudoHeaderResponse(key) {
   if (key !== ':status') {
-    const err = new errors.Error('ERR_HTTP2_INVALID_PSEUDOHEADER', key);
+    const err = new ERR_HTTP2_INVALID_PSEUDOHEADER(key);
     Error.captureStackTrace(err, assertValidPseudoHeaderResponse);
     return err;
   }
 }
 
 function assertValidPseudoHeaderTrailer(key) {
-  const err = new errors.Error('ERR_HTTP2_INVALID_PSEUDOHEADER', key);
+  const err = new ERR_HTTP2_INVALID_PSEUDOHEADER(key);
   Error.captureStackTrace(err, assertValidPseudoHeaderTrailer);
   return err;
 }
@@ -426,14 +432,14 @@ function mapToHeaders(map,
           break;
         default:
           if (isSingleValueHeader)
-            return new errors.Error('ERR_HTTP2_HEADER_SINGLE_VALUE', key);
+            return new ERR_HTTP2_HEADER_SINGLE_VALUE(key);
       }
     } else {
       value = String(value);
     }
     if (isSingleValueHeader) {
       if (singles.has(key))
-        return new errors.Error('ERR_HTTP2_HEADER_SINGLE_VALUE', key);
+        return new ERR_HTTP2_HEADER_SINGLE_VALUE(key);
       singles.add(key);
     }
     if (key[0] === ':') {
@@ -444,7 +450,7 @@ function mapToHeaders(map,
       count++;
     } else {
       if (isIllegalConnectionSpecificHeader(key, value)) {
-        return new errors.Error('ERR_HTTP2_INVALID_CONNECTION_HEADERS', key);
+        return new ERR_HTTP2_INVALID_CONNECTION_HEADERS(key);
       }
       if (isArray) {
         for (var k = 0; k < value.length; k++) {
@@ -476,7 +482,7 @@ function assertIsObject(value, name, types = 'Object') {
       (value === null ||
        typeof value !== 'object' ||
        Array.isArray(value))) {
-    const err = new errors.TypeError('ERR_INVALID_ARG_TYPE', name, types);
+    const err = new ERR_INVALID_ARG_TYPE(name, types);
     Error.captureStackTrace(err, assertIsObject);
     throw err;
   }
@@ -485,8 +491,7 @@ function assertIsObject(value, name, types = 'Object') {
 function assertWithinRange(name, value, min = 0, max = Infinity) {
   if (value !== undefined &&
       (typeof value !== 'number' || value < min || value > max)) {
-    const err = new errors.RangeError('ERR_HTTP2_INVALID_SETTING_VALUE',
-                                      name, value);
+    const err = new ERR_HTTP2_INVALID_SETTING_VALUE.RangeError(name, value);
     err.min = min;
     err.max = max;
     err.actual = value;
diff --git a/lib/internal/loader/DefaultResolve.js b/lib/internal/loader/DefaultResolve.js
index e92f528721..c561417bd1 100644
--- a/lib/internal/loader/DefaultResolve.js
+++ b/lib/internal/loader/DefaultResolve.js
@@ -7,7 +7,11 @@ const { NativeModule, internalBinding } = require('internal/bootstrap_loaders');
 const { extname } = require('path');
 const { realpathSync } = require('fs');
 const preserveSymlinks = !!process.binding('config').preserveSymlinks;
-const errors = require('internal/errors');
+const {
+  ERR_MISSING_MODULE,
+  ERR_MODULE_RESOLUTION_LEGACY,
+  ERR_UNKNOWN_FILE_EXTENSION
+} = require('internal/errors').codes;
 const { resolve: moduleWrapResolve } = internalBinding('module_wrap');
 const StringStartsWith = Function.call.bind(String.prototype.startsWith);
 const { getURLFromFilePath, getPathFromURL } = require('internal/url');
@@ -17,7 +21,7 @@ const realpathCache = new Map();
 function search(target, base) {
   if (base === undefined) {
     // We cannot search without a base.
-    throw new errors.Error('ERR_MISSING_MODULE', target);
+    throw new ERR_MISSING_MODULE(target);
   }
   try {
     return moduleWrapResolve(target, base);
@@ -30,8 +34,7 @@ function search(target, base) {
       tmpMod.paths = CJSmodule._nodeModulePaths(
         new URL('./', questionedBase).pathname);
       const found = CJSmodule._resolveFilename(target, tmpMod);
-      error = new errors.Error('ERR_MODULE_RESOLUTION_LEGACY', target,
-                               base, found);
+      error = new ERR_MODULE_RESOLUTION_LEGACY(target, base, found);
     } catch (problemChecking) {
       // ignore
     }
@@ -84,7 +87,7 @@ function resolve(specifier, parentURL) {
     if (isMain)
       format = 'cjs';
     else
-      throw new errors.Error('ERR_UNKNOWN_FILE_EXTENSION', url.pathname);
+      throw new ERR_UNKNOWN_FILE_EXTENSION(url.pathname);
   }
 
   return { url: `${url}`, format };
diff --git a/lib/internal/loader/Loader.js b/lib/internal/loader/Loader.js
index f0edbbf921..e4457cfd81 100644
--- a/lib/internal/loader/Loader.js
+++ b/lib/internal/loader/Loader.js
@@ -1,6 +1,11 @@
 'use strict';
 
-const errors = require('internal/errors');
+const {
+  ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_PROTOCOL,
+  ERR_MISSING_DYNAMIC_INTSTANTIATE_HOOK,
+  ERR_UNKNOWN_MODULE_FORMAT
+} = require('internal/errors').codes;
 const ModuleMap = require('internal/loader/ModuleMap');
 const ModuleJob = require('internal/loader/ModuleJob');
 const defaultResolve = require('internal/loader/DefaultResolve');
@@ -44,22 +49,22 @@ class Loader {
   async resolve(specifier, parentURL) {
     const isMain = parentURL === undefined;
     if (!isMain && typeof parentURL !== 'string')
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'parentURL', 'string');
+      throw new ERR_INVALID_ARG_TYPE('parentURL', 'string');
 
     const { url, format } =
       await this._resolve(specifier, parentURL, defaultResolve);
 
     if (typeof url !== 'string')
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'url', 'string');
+      throw new ERR_INVALID_ARG_TYPE('url', 'string');
 
     if (typeof format !== 'string')
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'format', 'string');
+      throw new ERR_INVALID_ARG_TYPE('format', 'string');
 
     if (format === 'builtin')
       return { url: `node:${url}`, format };
 
     if (format !== 'dynamic' && !url.startsWith('file:'))
-      throw new errors.Error('ERR_INVALID_PROTOCOL', url, 'file:');
+      throw new ERR_INVALID_PROTOCOL(url, 'file:');
 
     return { url, format };
   }
@@ -87,7 +92,7 @@ class Loader {
     let loaderInstance;
     if (format === 'dynamic') {
       if (typeof this._dynamicInstantiate !== 'function')
-        throw new errors.Error('ERR_MISSING_DYNAMIC_INTSTANTIATE_HOOK');
+        throw new ERR_MISSING_DYNAMIC_INTSTANTIATE_HOOK();
 
       loaderInstance = async (url) => {
         debug(`Translating dynamic ${url}`);
@@ -99,7 +104,7 @@ class Loader {
       };
     } else {
       if (!translators.has(format))
-        throw new errors.RangeError('ERR_UNKNOWN_MODULE_FORMAT', format);
+        throw new ERR_UNKNOWN_MODULE_FORMAT(format);
 
       loaderInstance = translators.get(format);
     }
diff --git a/lib/internal/loader/ModuleMap.js b/lib/internal/loader/ModuleMap.js
index aa238afbae..dce8f834ba 100644
--- a/lib/internal/loader/ModuleMap.js
+++ b/lib/internal/loader/ModuleMap.js
@@ -3,29 +3,29 @@
 const ModuleJob = require('internal/loader/ModuleJob');
 const { SafeMap } = require('internal/safe_globals');
 const debug = require('util').debuglog('esm');
-const errors = require('internal/errors');
+const { ERR_INVALID_ARG_TYPE } = require('internal/errors').codes;
 
 // Tracks the state of the loader-level module cache
 class ModuleMap extends SafeMap {
   get(url) {
     if (typeof url !== 'string') {
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'url', 'string');
+      throw new ERR_INVALID_ARG_TYPE('url', 'string');
     }
     return super.get(url);
   }
   set(url, job) {
     if (typeof url !== 'string') {
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'url', 'string');
+      throw new ERR_INVALID_ARG_TYPE('url', 'string');
     }
     if (job instanceof ModuleJob !== true) {
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'job', 'ModuleJob');
+      throw new ERR_INVALID_ARG_TYPE('job', 'ModuleJob');
     }
     debug(`Storing ${url} in ModuleMap`);
     return super.set(url, job);
   }
   has(url) {
     if (typeof url !== 'string') {
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'url', 'string');
+      throw new ERR_INVALID_ARG_TYPE('url', 'string');
     }
     return super.has(url);
   }
diff --git a/lib/internal/module.js b/lib/internal/module.js
index 6e2fb15268..61565cc593 100644
--- a/lib/internal/module.js
+++ b/lib/internal/module.js
@@ -1,6 +1,6 @@
 'use strict';
 
-const errors = require('internal/errors');
+const { ERR_INVALID_ARG_TYPE } = require('internal/errors').codes;
 
 const {
   CHAR_LINE_FEED,
@@ -25,8 +25,7 @@ function makeRequireFunction(mod) {
 
   function resolve(request, options) {
     if (typeof request !== 'string') {
-      throw new errors.Error('ERR_INVALID_ARG_TYPE',
-                             'request', 'string', request);
+      throw new ERR_INVALID_ARG_TYPE('request', 'string', request);
     }
     return Module._resolveFilename(request, mod, false, options);
   }
@@ -35,8 +34,7 @@ function makeRequireFunction(mod) {
 
   function paths(request) {
     if (typeof request !== 'string') {
-      throw new errors.Error('ERR_INVALID_ARG_TYPE',
-                             'request', 'string', request);
+      throw new ERR_INVALID_ARG_TYPE('request', 'string', request);
     }
     return Module._resolveLookupPaths(request, mod, true);
   }
diff --git a/lib/internal/process.js b/lib/internal/process.js
index 3de3ae1603..ba61928adc 100644
--- a/lib/internal/process.js
+++ b/lib/internal/process.js
@@ -1,6 +1,16 @@
 'use strict';
 
-const errors = require('internal/errors');
+const {
+  errnoException,
+  codes: {
+    ERR_ASSERTION,
+    ERR_CPU_USAGE,
+    ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_ARRAY_LENGTH,
+    ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET,
+    ERR_UNKNOWN_SIGNAL
+  }
+} = require('internal/errors');
 const util = require('util');
 const constants = process.binding('constants').os.signals;
 const assert = require('assert').strict;
@@ -8,7 +18,7 @@ const { deprecate } = require('internal/util');
 
 process.assert = deprecate(
   function(x, msg) {
-    if (!x) throw new errors.Error('ERR_ASSERTION', msg || 'assertion error');
+    if (!x) throw new ERR_ASSERTION(msg || 'assertion error');
   },
   'process.assert() is deprecated. Please use the `assert` module instead.',
   'DEP0100');
@@ -31,20 +41,18 @@ function setup_cpuUsage() {
     // If a previous value was passed in, ensure it has the correct shape.
     if (prevValue) {
       if (!previousValueIsValid(prevValue.user)) {
-        throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
-                                   'preValue.user', 'number');
+        throw new ERR_INVALID_ARG_TYPE('preValue.user', 'number');
       }
 
       if (!previousValueIsValid(prevValue.system)) {
-        throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
-                                   'preValue.system', 'number');
+        throw new ERR_INVALID_ARG_TYPE('preValue.system', 'number');
       }
     }
 
     // Call the native function to get the current values.
     const errmsg = _cpuUsage(cpuValues);
     if (errmsg) {
-      throw new errors.Error('ERR_CPU_USAGE', errmsg);
+      throw new ERR_CPU_USAGE(errmsg);
     }
 
     // If a previous value was passed in, return diff of current from previous.
@@ -83,12 +91,10 @@ function setup_hrtime() {
 
     if (time !== undefined) {
       if (!Array.isArray(time)) {
-        throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'time', 'Array',
-                                   time);
+        throw new ERR_INVALID_ARG_TYPE('time', 'Array', time);
       }
       if (time.length !== 2) {
-        throw new errors.TypeError('ERR_INVALID_ARRAY_LENGTH', 'time', 2,
-                                   time.length);
+        throw new ERR_INVALID_ARRAY_LENGTH('time', 2, time.length);
       }
 
       const sec = (hrValues[0] * 0x100000000 + hrValues[1]) - time[0];
@@ -158,7 +164,7 @@ function setupKillAndExit() {
 
     // eslint-disable-next-line eqeqeq
     if (pid != (pid | 0)) {
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'pid', 'number');
+      throw new ERR_INVALID_ARG_TYPE('pid', 'number');
     }
 
     // preserve null signal
@@ -169,12 +175,12 @@ function setupKillAndExit() {
       if (constants[sig]) {
         err = process._kill(pid, constants[sig]);
       } else {
-        throw new errors.TypeError('ERR_UNKNOWN_SIGNAL', sig);
+        throw new ERR_UNKNOWN_SIGNAL(sig);
       }
     }
 
     if (err)
-      throw errors.errnoException(err, 'kill');
+      throw errnoException(err, 'kill');
 
     return true;
   };
@@ -204,7 +210,7 @@ function setupSignalHandlers() {
       const err = wrap.start(signum);
       if (err) {
         wrap.close();
-        throw errors.errnoException(err, 'uv_signal_start');
+        throw errnoException(err, 'uv_signal_start');
       }
 
       signalWraps[type] = wrap;
@@ -256,11 +262,10 @@ function setupUncaughtExceptionCapture(exceptionHandlerState) {
       return;
     }
     if (typeof fn !== 'function') {
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'fn',
-                                 ['Function', 'null']);
+      throw new ERR_INVALID_ARG_TYPE('fn', ['Function', 'null']);
     }
     if (exceptionHandlerState.captureFn !== null) {
-      throw new errors.Error('ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET');
+      throw new ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET();
     }
     exceptionHandlerState.captureFn = fn;
     shouldAbortOnUncaughtToggle[0] = 0;
diff --git a/lib/internal/process/next_tick.js b/lib/internal/process/next_tick.js
index f95d9cc1b8..39e5a6f812 100644
--- a/lib/internal/process/next_tick.js
+++ b/lib/internal/process/next_tick.js
@@ -17,7 +17,7 @@ function setupNextTick() {
     symbols: { async_id_symbol, trigger_async_id_symbol }
   } = require('internal/async_hooks');
   const promises = require('internal/process/promises');
-  const errors = require('internal/errors');
+  const { ERR_INVALID_CALLBACK } = require('internal/errors').codes;
   const { emitPromiseRejectionWarnings } = promises;
 
   // tickInfo is used so that the C++ code in src/node.cc can
@@ -146,7 +146,7 @@ function setupNextTick() {
   // exit since the callback would not have a chance to be executed.
   function nextTick(callback) {
     if (typeof callback !== 'function')
-      throw new errors.TypeError('ERR_INVALID_CALLBACK');
+      throw new ERR_INVALID_CALLBACK();
 
     if (process._exiting)
       return;
@@ -170,7 +170,7 @@ function setupNextTick() {
   // about to exit since the callback would not have a chance to be executed.
   function internalNextTick(triggerAsyncId, callback) {
     if (typeof callback !== 'function')
-      throw new errors.TypeError('ERR_INVALID_CALLBACK');
+      throw new ERR_INVALID_CALLBACK();
     // CHECK(Number.isSafeInteger(triggerAsyncId) || triggerAsyncId === null)
     // CHECK(triggerAsyncId > 0 || triggerAsyncId === null)
 
diff --git a/lib/internal/process/stdio.js b/lib/internal/process/stdio.js
index 45568ae631..29aee7d09b 100644
--- a/lib/internal/process/stdio.js
+++ b/lib/internal/process/stdio.js
@@ -1,6 +1,11 @@
 'use strict';
 
-const errors = require('internal/errors');
+const {
+  ERR_STDERR_CLOSE,
+  ERR_STDOUT_CLOSE,
+  ERR_UNKNOWN_STDIN_TYPE,
+  ERR_UNKNOWN_STREAM_TYPE
+} = require('internal/errors').codes;
 
 exports.setup = setupStdio;
 
@@ -15,7 +20,7 @@ function setupStdio() {
     stdout.destroySoon = stdout.destroy;
     stdout._destroy = function(er, cb) {
       // Avoid errors if we already emitted
-      er = er || new errors.Error('ERR_STDOUT_CLOSE');
+      er = er || new ERR_STDOUT_CLOSE();
       cb(er);
     };
     if (stdout.isTTY) {
@@ -30,7 +35,7 @@ function setupStdio() {
     stderr.destroySoon = stderr.destroy;
     stderr._destroy = function(er, cb) {
       // Avoid errors if we already emitted
-      er = er || new errors.Error('ERR_STDERR_CLOSE');
+      er = er || new ERR_STDERR_CLOSE();
       cb(er);
     };
     if (stderr.isTTY) {
@@ -87,7 +92,7 @@ function setupStdio() {
 
       default:
         // Probably an error on in uv_guess_handle()
-        throw new errors.Error('ERR_UNKNOWN_STDIN_TYPE');
+        throw new ERR_UNKNOWN_STDIN_TYPE();
     }
 
     // For supporting legacy API we put the FD here.
@@ -171,7 +176,7 @@ function createWritableStdioStream(fd) {
 
     default:
       // Probably an error on in uv_guess_handle()
-      throw new errors.Error('ERR_UNKNOWN_STREAM_TYPE');
+      throw new ERR_UNKNOWN_STREAM_TYPE();
   }
 
   // For supporting legacy API we put the FD here.
diff --git a/lib/internal/process/warning.js b/lib/internal/process/warning.js
index 67a3113f23..df2d0c103b 100644
--- a/lib/internal/process/warning.js
+++ b/lib/internal/process/warning.js
@@ -2,7 +2,7 @@
 
 const config = process.binding('config');
 const prefix = `(${process.release.name}:${process.pid}) `;
-const errors = require('internal/errors');
+const { ERR_INVALID_ARG_TYPE } = require('internal/errors').codes;
 
 exports.setup = setupProcessWarnings;
 
@@ -122,9 +122,9 @@ function setupProcessWarnings() {
       code = undefined;
     }
     if (code !== undefined && typeof code !== 'string')
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'code', 'string');
+      throw new ERR_INVALID_ARG_TYPE('code', 'string');
     if (type !== undefined && typeof type !== 'string')
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'type', 'string');
+      throw new ERR_INVALID_ARG_TYPE('type', 'string');
     if (warning === undefined || typeof warning === 'string') {
       warning = new Error(warning);
       warning.name = String(type || 'Warning');
@@ -133,8 +133,7 @@ function setupProcessWarnings() {
       Error.captureStackTrace(warning, ctor || process.emitWarning);
     }
     if (!(warning instanceof Error)) {
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
-                                 'warning', ['Error', 'string']);
+      throw new ERR_INVALID_ARG_TYPE('warning', ['Error', 'string']);
     }
     if (warning.name === 'DeprecationWarning') {
       if (process.noDeprecation)
diff --git a/lib/internal/socket_list.js b/lib/internal/socket_list.js
index dd30e94509..55077af130 100644
--- a/lib/internal/socket_list.js
+++ b/lib/internal/socket_list.js
@@ -1,6 +1,6 @@
 'use strict';
 
-const errors = require('internal/errors');
+const { ERR_CHILD_CLOSED_BEFORE_REPLY } = require('internal/errors').codes;
 
 const EventEmitter = require('events');
 
@@ -21,7 +21,7 @@ class SocketListSend extends EventEmitter {
 
     function onclose() {
       self.child.removeListener('internalMessage', onreply);
-      callback(new errors.Error('ERR_CHILD_CLOSED_BEFORE_REPLY'));
+      callback(new ERR_CHILD_CLOSED_BEFORE_REPLY());
     }
 
     function onreply(msg) {
diff --git a/lib/internal/streams/state.js b/lib/internal/streams/state.js
index cca79c93de..4a1b49d25c 100644
--- a/lib/internal/streams/state.js
+++ b/lib/internal/streams/state.js
@@ -1,18 +1,18 @@
 'use strict';
 
-const errors = require('internal/errors');
+const { ERR_INVALID_OPT_VALUE } = require('internal/errors').codes;
 
 function getHighWaterMark(state, options, duplexKey, isDuplex) {
   let hwm = options.highWaterMark;
   if (hwm != null) {
     if (typeof hwm !== 'number' || !(hwm >= 0))
-      throw new errors.TypeError('ERR_INVALID_OPT_VALUE', 'highWaterMark', hwm);
+      throw new ERR_INVALID_OPT_VALUE('highWaterMark', hwm);
     return Math.floor(hwm);
   } else if (isDuplex) {
     hwm = options[duplexKey];
     if (hwm != null) {
       if (typeof hwm !== 'number' || !(hwm >= 0))
-        throw new errors.TypeError('ERR_INVALID_OPT_VALUE', duplexKey, hwm);
+        throw new ERR_INVALID_OPT_VALUE(duplexKey, hwm);
       return Math.floor(hwm);
     }
   }
diff --git a/lib/internal/timers.js b/lib/internal/timers.js
index 8c1a87a65f..26fc3f941b 100644
--- a/lib/internal/timers.js
+++ b/lib/internal/timers.js
@@ -10,7 +10,11 @@ const {
 const async_id_symbol = Symbol('asyncId');
 const trigger_async_id_symbol = Symbol('triggerId');
 
-const errors = require('internal/errors');
+const {
+  ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_CALLBACK,
+  ERR_OUT_OF_RANGE
+} = require('internal/errors').codes;
 
 // Timeout values > TIMEOUT_MAX are set to 1.
 const TIMEOUT_MAX = 2 ** 31 - 1;
@@ -94,7 +98,7 @@ Timeout.prototype[refreshFnSymbol] = function refresh() {
 function setUnrefTimeout(callback, after, arg1, arg2, arg3) {
   // Type checking identical to setTimeout()
   if (typeof callback !== 'function') {
-    throw new errors.TypeError('ERR_INVALID_CALLBACK');
+    throw new ERR_INVALID_CALLBACK();
   }
 
   let i, args;
@@ -127,13 +131,11 @@ function setUnrefTimeout(callback, after, arg1, arg2, arg3) {
 // Type checking used by timers.enroll() and Socket#setTimeout()
 function validateTimerDuration(msecs) {
   if (typeof msecs !== 'number') {
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'msecs',
-                               'number', msecs);
+    throw new ERR_INVALID_ARG_TYPE('msecs', 'number', msecs);
   }
 
   if (msecs < 0 || !isFinite(msecs)) {
-    throw new errors.RangeError('ERR_OUT_OF_RANGE', 'msecs',
-                                'a non-negative finite number', msecs);
+    throw new ERR_OUT_OF_RANGE('msecs', 'a non-negative finite number', msecs);
   }
 
   // Ensure that msecs fits into signed int32
diff --git a/lib/internal/url.js b/lib/internal/url.js
index 0bdfc4783e..842d26c4aa 100644
--- a/lib/internal/url.js
+++ b/lib/internal/url.js
@@ -7,7 +7,18 @@ const {
 } = require('internal/querystring');
 
 const { getConstructorOf, removeColors } = require('internal/util');
-const errors = require('internal/errors');
+const {
+  ERR_ARG_NOT_ITERABLE,
+  ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_CALLBACK,
+  ERR_INVALID_FILE_URL_HOST,
+  ERR_INVALID_FILE_URL_PATH,
+  ERR_INVALID_THIS,
+  ERR_INVALID_TUPLE,
+  ERR_INVALID_URL,
+  ERR_INVALID_URL_SCHEME,
+  ERR_MISSING_ARGS
+} = require('internal/errors').codes;
 const querystring = require('querystring');
 
 const { platform } = process;
@@ -107,7 +118,7 @@ class URLSearchParams {
         this[searchParams] = childParams.slice();
       } else if (method !== null && method !== undefined) {
         if (typeof method !== 'function') {
-          throw new errors.TypeError('ERR_ARG_NOT_ITERABLE', 'Query pairs');
+          throw new ERR_ARG_NOT_ITERABLE('Query pairs');
         }
 
         // sequence<sequence<USVString>>
@@ -117,8 +128,7 @@ class URLSearchParams {
           if ((typeof pair !== 'object' && typeof pair !== 'function') ||
               pair === null ||
               typeof pair[Symbol.iterator] !== 'function') {
-            throw new errors.TypeError('ERR_INVALID_TUPLE', 'Each query pair',
-                                       '[name, value]');
+            throw new ERR_INVALID_TUPLE('Each query pair', '[name, value]');
           }
           const convertedPair = [];
           for (const element of pair)
@@ -129,8 +139,7 @@ class URLSearchParams {
         this[searchParams] = [];
         for (const pair of pairs) {
           if (pair.length !== 2) {
-            throw new errors.TypeError('ERR_INVALID_TUPLE', 'Each query pair',
-                                       '[name, value]');
+            throw new ERR_INVALID_TUPLE('Each query pair', '[name, value]');
           }
           this[searchParams].push(pair[0], pair[1]);
         }
@@ -162,7 +171,7 @@ class URLSearchParams {
 
   [util.inspect.custom](recurseTimes, ctx) {
     if (!this || !this[searchParams] || this[searchParams][searchParams]) {
-      throw new errors.TypeError('ERR_INVALID_THIS', 'URLSearchParams');
+      throw new ERR_INVALID_THIS('URLSearchParams');
     }
 
     if (typeof recurseTimes === 'number' && recurseTimes < 0)
@@ -214,7 +223,7 @@ function onParseComplete(flags, protocol, username, password,
 }
 
 function onParseError(flags, input) {
-  const error = new errors.TypeError('ERR_INVALID_URL', input);
+  const error = new ERR_INVALID_URL(input);
   error.input = input;
   throw error;
 }
@@ -328,7 +337,7 @@ class URL {
   [util.inspect.custom](depth, opts) {
     if (this == null ||
         Object.getPrototypeOf(this[context]) !== URLContext.prototype) {
-      throw new errors.TypeError('ERR_INVALID_THIS', 'URL');
+      throw new ERR_INVALID_THIS('URL');
     }
 
     if (typeof depth === 'number' && depth < 0)
@@ -370,7 +379,7 @@ Object.defineProperties(URL.prototype, {
     // eslint-disable-next-line func-name-matching
     value: function format(options) {
       if (options && typeof options !== 'object')
-        throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'options', 'Object');
+        throw new ERR_INVALID_ARG_TYPE('options', 'Object');
       options = util._extend({
         fragment: true,
         unicode: false,
@@ -943,10 +952,10 @@ function merge(out, start, mid, end, lBuffer, rBuffer) {
 defineIDLClass(URLSearchParams.prototype, 'URLSearchParams', {
   append(name, value) {
     if (!this || !this[searchParams] || this[searchParams][searchParams]) {
-      throw new errors.TypeError('ERR_INVALID_THIS', 'URLSearchParams');
+      throw new ERR_INVALID_THIS('URLSearchParams');
     }
     if (arguments.length < 2) {
-      throw new errors.TypeError('ERR_MISSING_ARGS', 'name', 'value');
+      throw new ERR_MISSING_ARGS('name', 'value');
     }
 
     name = toUSVString(name);
@@ -957,10 +966,10 @@ defineIDLClass(URLSearchParams.prototype, 'URLSearchParams', {
 
   delete(name) {
     if (!this || !this[searchParams] || this[searchParams][searchParams]) {
-      throw new errors.TypeError('ERR_INVALID_THIS', 'URLSearchParams');
+      throw new ERR_INVALID_THIS('URLSearchParams');
     }
     if (arguments.length < 1) {
-      throw new errors.TypeError('ERR_MISSING_ARGS', 'name');
+      throw new ERR_MISSING_ARGS('name');
     }
 
     const list = this[searchParams];
@@ -978,10 +987,10 @@ defineIDLClass(URLSearchParams.prototype, 'URLSearchParams', {
 
   get(name) {
     if (!this || !this[searchParams] || this[searchParams][searchParams]) {
-      throw new errors.TypeError('ERR_INVALID_THIS', 'URLSearchParams');
+      throw new ERR_INVALID_THIS('URLSearchParams');
     }
     if (arguments.length < 1) {
-      throw new errors.TypeError('ERR_MISSING_ARGS', 'name');
+      throw new ERR_MISSING_ARGS('name');
     }
 
     const list = this[searchParams];
@@ -996,10 +1005,10 @@ defineIDLClass(URLSearchParams.prototype, 'URLSearchParams', {
 
   getAll(name) {
     if (!this || !this[searchParams] || this[searchParams][searchParams]) {
-      throw new errors.TypeError('ERR_INVALID_THIS', 'URLSearchParams');
+      throw new ERR_INVALID_THIS('URLSearchParams');
     }
     if (arguments.length < 1) {
-      throw new errors.TypeError('ERR_MISSING_ARGS', 'name');
+      throw new ERR_MISSING_ARGS('name');
     }
 
     const list = this[searchParams];
@@ -1015,10 +1024,10 @@ defineIDLClass(URLSearchParams.prototype, 'URLSearchParams', {
 
   has(name) {
     if (!this || !this[searchParams] || this[searchParams][searchParams]) {
-      throw new errors.TypeError('ERR_INVALID_THIS', 'URLSearchParams');
+      throw new ERR_INVALID_THIS('URLSearchParams');
     }
     if (arguments.length < 1) {
-      throw new errors.TypeError('ERR_MISSING_ARGS', 'name');
+      throw new ERR_MISSING_ARGS('name');
     }
 
     const list = this[searchParams];
@@ -1033,10 +1042,10 @@ defineIDLClass(URLSearchParams.prototype, 'URLSearchParams', {
 
   set(name, value) {
     if (!this || !this[searchParams] || this[searchParams][searchParams]) {
-      throw new errors.TypeError('ERR_INVALID_THIS', 'URLSearchParams');
+      throw new ERR_INVALID_THIS('URLSearchParams');
     }
     if (arguments.length < 2) {
-      throw new errors.TypeError('ERR_MISSING_ARGS', 'name', 'value');
+      throw new ERR_MISSING_ARGS('name', 'value');
     }
 
     const list = this[searchParams];
@@ -1120,7 +1129,7 @@ defineIDLClass(URLSearchParams.prototype, 'URLSearchParams', {
   // must be set to `entries`.
   entries() {
     if (!this || !this[searchParams] || this[searchParams][searchParams]) {
-      throw new errors.TypeError('ERR_INVALID_THIS', 'URLSearchParams');
+      throw new ERR_INVALID_THIS('URLSearchParams');
     }
 
     return createSearchParamsIterator(this, 'key+value');
@@ -1128,10 +1137,10 @@ defineIDLClass(URLSearchParams.prototype, 'URLSearchParams', {
 
   forEach(callback, thisArg = undefined) {
     if (!this || !this[searchParams] || this[searchParams][searchParams]) {
-      throw new errors.TypeError('ERR_INVALID_THIS', 'URLSearchParams');
+      throw new ERR_INVALID_THIS('URLSearchParams');
     }
     if (typeof callback !== 'function') {
-      throw new errors.TypeError('ERR_INVALID_CALLBACK');
+      throw new ERR_INVALID_CALLBACK();
     }
 
     let list = this[searchParams];
@@ -1150,7 +1159,7 @@ defineIDLClass(URLSearchParams.prototype, 'URLSearchParams', {
   // https://heycam.github.io/webidl/#es-iterable
   keys() {
     if (!this || !this[searchParams] || this[searchParams][searchParams]) {
-      throw new errors.TypeError('ERR_INVALID_THIS', 'URLSearchParams');
+      throw new ERR_INVALID_THIS('URLSearchParams');
     }
 
     return createSearchParamsIterator(this, 'key');
@@ -1158,7 +1167,7 @@ defineIDLClass(URLSearchParams.prototype, 'URLSearchParams', {
 
   values() {
     if (!this || !this[searchParams] || this[searchParams][searchParams]) {
-      throw new errors.TypeError('ERR_INVALID_THIS', 'URLSearchParams');
+      throw new ERR_INVALID_THIS('URLSearchParams');
     }
 
     return createSearchParamsIterator(this, 'value');
@@ -1168,7 +1177,7 @@ defineIDLClass(URLSearchParams.prototype, 'URLSearchParams', {
   // https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior
   toString() {
     if (!this || !this[searchParams] || this[searchParams][searchParams]) {
-      throw new errors.TypeError('ERR_INVALID_THIS', 'URLSearchParams');
+      throw new ERR_INVALID_THIS('URLSearchParams');
     }
 
     return serializeParams(this[searchParams]);
@@ -1200,7 +1209,7 @@ defineIDLClass(URLSearchParamsIteratorPrototype, 'URLSearchParams Iterator', {
   next() {
     if (!this ||
         Object.getPrototypeOf(this) !== URLSearchParamsIteratorPrototype) {
-      throw new errors.TypeError('ERR_INVALID_THIS', 'URLSearchParamsIterator');
+      throw new ERR_INVALID_THIS('URLSearchParamsIterator');
     }
 
     const {
@@ -1237,7 +1246,7 @@ defineIDLClass(URLSearchParamsIteratorPrototype, 'URLSearchParams Iterator', {
   },
   [util.inspect.custom](recurseTimes, ctx) {
     if (this == null || this[context] == null || this[context].target == null)
-      throw new errors.TypeError('ERR_INVALID_THIS', 'URLSearchParamsIterator');
+      throw new ERR_INVALID_THIS('URLSearchParamsIterator');
 
     if (typeof recurseTimes === 'number' && recurseTimes < 0)
       return ctx.stylize('[Object]', 'special');
@@ -1276,7 +1285,7 @@ defineIDLClass(URLSearchParamsIteratorPrototype, 'URLSearchParams Iterator', {
 
 function domainToASCII(domain) {
   if (arguments.length < 1)
-    throw new errors.TypeError('ERR_MISSING_ARGS', 'domain');
+    throw new ERR_MISSING_ARGS('domain');
 
   // toUSVString is not needed.
   return _domainToASCII(`${domain}`);
@@ -1284,7 +1293,7 @@ function domainToASCII(domain) {
 
 function domainToUnicode(domain) {
   if (arguments.length < 1)
-    throw new errors.TypeError('ERR_MISSING_ARGS', 'domain');
+    throw new ERR_MISSING_ARGS('domain');
 
   // toUSVString is not needed.
   return _domainToUnicode(`${domain}`);
@@ -1320,9 +1329,9 @@ function getPathFromURLWin32(url) {
       var third = pathname.codePointAt(n + 2) | 0x20;
       if ((pathname[n + 1] === '2' && third === 102) || // 2f 2F /
           (pathname[n + 1] === '5' && third === 99)) {  // 5c 5C \
-        throw new errors.TypeError(
-          'ERR_INVALID_FILE_URL_PATH',
-          'must not include encoded \\ or / characters');
+        throw new ERR_INVALID_FILE_URL_PATH(
+          'must not include encoded \\ or / characters'
+        );
       }
     }
   }
@@ -1341,8 +1350,7 @@ function getPathFromURLWin32(url) {
     var sep = pathname[2];
     if (letter < 97 || letter > 122 ||   // a..z A..Z
         (sep !== ':')) {
-      throw new errors.TypeError('ERR_INVALID_FILE_URL_PATH',
-                                 'must be absolute');
+      throw new ERR_INVALID_FILE_URL_PATH('must be absolute');
     }
     return pathname.slice(1);
   }
@@ -1350,15 +1358,16 @@ function getPathFromURLWin32(url) {
 
 function getPathFromURLPosix(url) {
   if (url.hostname !== '') {
-    throw new errors.TypeError('ERR_INVALID_FILE_URL_HOST', platform);
+    throw new ERR_INVALID_FILE_URL_HOST(platform);
   }
   var pathname = url.pathname;
   for (var n = 0; n < pathname.length; n++) {
     if (pathname[n] === '%') {
       var third = pathname.codePointAt(n + 2) | 0x20;
       if (pathname[n + 1] === '2' && third === 102) {
-        throw new errors.TypeError('ERR_INVALID_FILE_URL_PATH',
-                                   'must not include encoded / characters');
+        throw new ERR_INVALID_FILE_URL_PATH(
+          'must not include encoded / characters'
+        );
       }
     }
   }
@@ -1371,7 +1380,7 @@ function getPathFromURL(path) {
     return path;
   }
   if (path.protocol !== 'file:')
-    throw new errors.TypeError('ERR_INVALID_URL_SCHEME', 'file');
+    throw new ERR_INVALID_URL_SCHEME('file');
   return isWindows ? getPathFromURLWin32(path) : getPathFromURLPosix(path);
 }
 
diff --git a/lib/internal/util.js b/lib/internal/util.js
index 6a4cf7ee2a..d044f32ca5 100644
--- a/lib/internal/util.js
+++ b/lib/internal/util.js
@@ -1,6 +1,10 @@
 'use strict';
 
-const errors = require('internal/errors');
+const {
+  ERR_INVALID_ARG_TYPE,
+  ERR_NO_CRYPTO,
+  ERR_UNKNOWN_SIGNAL
+} = require('internal/errors').codes;
 const { signals } = process.binding('constants').os;
 
 const {
@@ -45,7 +49,7 @@ function deprecate(fn, msg, code) {
   }
 
   if (code !== undefined && typeof code !== 'string')
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'code', 'string');
+    throw new ERR_INVALID_ARG_TYPE('code', 'string');
 
   let warned = false;
   function deprecated(...args) {
@@ -93,7 +97,7 @@ function decorateErrorStack(err) {
 
 function assertCrypto() {
   if (noCrypto)
-    throw new errors.Error('ERR_NO_CRYPTO');
+    throw new ERR_NO_CRYPTO();
 }
 
 // Return undefined if there is no match.
@@ -225,7 +229,7 @@ function convertToValidSignal(signal) {
     if (signalName) return signalName;
   }
 
-  throw new errors.TypeError('ERR_UNKNOWN_SIGNAL', signal);
+  throw new ERR_UNKNOWN_SIGNAL(signal);
 }
 
 function getConstructorOf(obj) {
@@ -290,15 +294,12 @@ const kCustomPromisifyArgsSymbol = Symbol('customPromisifyArgs');
 
 function promisify(original) {
   if (typeof original !== 'function')
-    throw new errors.TypeError('ERR_INVALID_ARG_TYPE', 'original', 'Function');
+    throw new ERR_INVALID_ARG_TYPE('original', 'Function');
 
   if (original[kCustomPromisifiedSymbol]) {
     const fn = original[kCustomPromisifiedSymbol];
     if (typeof fn !== 'function') {
-      throw new errors.TypeError('ERR_INVALID_ARG_TYPE',
-                                 'util.promisify.custom',
-                                 'Function',
-                                 fn);
+      throw new ERR_INVALID_ARG_TYPE('util.promisify.custom', 'Function', fn);
     }
     Object.defineProperty(fn, kCustomPromisifiedSymbol, {
       value: fn, enumerable: false, writable: false, configurable: true
diff --git a/lib/internal/vm/Module.js b/lib/internal/vm/Module.js
index e954babf1d..6d8f7f76d8 100644
--- a/lib/internal/vm/Module.js
+++ b/lib/internal/vm/Module.js
@@ -4,7 +4,15 @@ const { internalBinding } = require('internal/bootstrap_loaders');
 const { emitExperimentalWarning } = require('internal/util');
 const { URL } = require('internal/url');
 const { kParsingContext, isContext } = process.binding('contextify');
-const errors = require('internal/errors');
+const {
+  ERR_INVALID_ARG_TYPE,
+  ERR_VM_MODULE_ALREADY_LINKED,
+  ERR_VM_MODULE_DIFFERENT_CONTEXT,
+  ERR_VM_MODULE_LINKING_ERRORED,
+  ERR_VM_MODULE_NOT_LINKED,
+  ERR_VM_MODULE_NOT_MODULE,
+  ERR_VM_MODULE_STATUS
+} = require('internal/errors').codes;
 const {
   getConstructorOf,
   customInspectSymbol,
@@ -41,27 +49,23 @@ class Module {
     emitExperimentalWarning('vm.Module');
 
     if (typeof src !== 'string')
-      throw new errors.TypeError(
-        'ERR_INVALID_ARG_TYPE', 'src', 'string', src);
+      throw new ERR_INVALID_ARG_TYPE('src', 'string', src);
     if (typeof options !== 'object' || options === null)
-      throw new errors.TypeError(
-        'ERR_INVALID_ARG_TYPE', 'options', 'object', options);
+      throw new ERR_INVALID_ARG_TYPE('options', 'object', options);
 
     let context;
     if (options.context !== undefined) {
       if (isContext(options.context)) {
         context = options.context;
       } else {
-        throw new errors.TypeError(
-          'ERR_INVALID_ARG_TYPE', 'options.context', 'vm.Context');
+        throw new ERR_INVALID_ARG_TYPE('options.context', 'vm.Context');
       }
     }
 
     let url = options.url;
     if (url !== undefined) {
       if (typeof url !== 'string') {
-        throw new errors.TypeError(
-          'ERR_INVALID_ARG_TYPE', 'options.url', 'string', url);
+        throw new ERR_INVALID_ARG_TYPE('options.url', 'string', url);
       }
       url = new URL(url).href;
     } else if (context === undefined) {
@@ -101,8 +105,9 @@ class Module {
   get namespace() {
     const wrap = wrapMap.get(this);
     if (wrap.getStatus() < kInstantiated)
-      throw new errors.Error('ERR_VM_MODULE_STATUS',
-                             'must not be uninstantiated or instantiating');
+      throw new ERR_VM_MODULE_STATUS(
+        'must not be uninstantiated or instantiating'
+      );
     return wrap.namespace();
   }
 
@@ -120,31 +125,30 @@ class Module {
   get error() {
     const wrap = wrapMap.get(this);
     if (wrap.getStatus() !== kErrored)
-      throw new errors.Error('ERR_VM_MODULE_STATUS', 'must be errored');
+      throw new ERR_VM_MODULE_STATUS('must be errored');
     return wrap.getError();
   }
 
   async link(linker) {
     if (typeof linker !== 'function')
-      throw new errors.TypeError(
-        'ERR_INVALID_ARG_TYPE', 'linker', 'function', linker);
+      throw new ERR_INVALID_ARG_TYPE('linker', 'function', linker);
     if (linkingStatusMap.get(this) !== 'unlinked')
-      throw new errors.Error('ERR_VM_MODULE_ALREADY_LINKED');
+      throw new ERR_VM_MODULE_ALREADY_LINKED();
     const wrap = wrapMap.get(this);
     if (wrap.getStatus() !== kUninstantiated)
-      throw new errors.Error('ERR_VM_MODULE_STATUS', 'must be uninstantiated');
+      throw new ERR_VM_MODULE_STATUS('must be uninstantiated');
 
     linkingStatusMap.set(this, 'linking');
 
     const promises = wrap.link(async (specifier) => {
       const m = await linker(specifier, this);
       if (!m || !wrapMap.has(m))
-        throw new errors.Error('ERR_VM_MODULE_NOT_MODULE');
+        throw new ERR_VM_MODULE_NOT_MODULE();
       if (m.context !== this.context)
-        throw new errors.Error('ERR_VM_MODULE_DIFFERENT_CONTEXT');
+        throw new ERR_VM_MODULE_DIFFERENT_CONTEXT();
       const childLinkingStatus = linkingStatusMap.get(m);
       if (childLinkingStatus === 'errored')
-        throw new errors.Error('ERR_VM_MODULE_LINKING_ERRORED');
+        throw new ERR_VM_MODULE_LINKING_ERRORED();
       if (childLinkingStatus === 'unlinked')
         await m.link(linker);
       return wrapMap.get(m);
@@ -164,10 +168,9 @@ class Module {
     const wrap = wrapMap.get(this);
     const status = wrap.getStatus();
     if (status === kInstantiating || status === kEvaluating)
-      throw new errors.Error(
-        'ERR_VM_MODULE_STATUS', 'must not be instantiating or evaluating');
+      throw new ERR_VM_MODULE_STATUS('must not be instantiating or evaluating');
     if (linkingStatusMap.get(this) !== 'linked')
-      throw new errors.Error('ERR_VM_MODULE_NOT_LINKED');
+      throw new ERR_VM_MODULE_NOT_LINKED();
     wrap.instantiate();
   }
 
@@ -177,9 +180,9 @@ class Module {
     if (status !== kInstantiated &&
         status !== kEvaluated &&
         status !== kErrored) {
-      throw new errors.Error(
-        'ERR_VM_MODULE_STATUS',
-        'must be one of instantiated, evaluated, and errored');
+      throw new ERR_VM_MODULE_STATUS(
+        'must be one of instantiated, evaluated, and errored'
+      );
     }
     const result = wrap.evaluate(options);
     return { result, __proto__: null };
diff --git a/lib/internal/wrap_js_stream.js b/lib/internal/wrap_js_stream.js
index feacab267b..9a7e9cd48a 100644
--- a/lib/internal/wrap_js_stream.js
+++ b/lib/internal/wrap_js_stream.js
@@ -6,7 +6,7 @@ const { Socket } = require('net');
 const { JSStream } = process.binding('js_stream');
 const uv = process.binding('uv');
 const debug = util.debuglog('stream_wrap');
-const errors = require('internal/errors');
+const { ERR_STREAM_WRAP } = require('internal/errors').codes;
 
 const kCurrentWriteRequest = Symbol('kCurrentWriteRequest');
 const kCurrentShutdownRequest = Symbol('kCurrentShutdownRequest');
@@ -53,7 +53,7 @@ class JSStreamWrap extends Socket {
         stream.pause();
         stream.removeListener('data', ondata);
 
-        this.emit('error', new errors.Error('ERR_STREAM_WRAP'));
+        this.emit('error', new ERR_STREAM_WRAP());
         return;
       }