From 39ee3bde15dbaf42a63bf3e4ecd833065bf86b00 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Thu, 5 Oct 2017 21:27:46 -0700
Subject: [PATCH] util,assert: expose util.isDeepStrictEqual()

Provide `util.isDeepStrictEqual()` that works like
`assert.deepStrictEqual()` but returns a boolean rather than throwing an
error.

Several userland modules have needed this functionality and implemented
it independently. This functionality already exists in Node.js core, so
this exposes it for use by modules. Modules that have needed this
functionality include `lodash`, `concordance` (used by `ava`), and
`qunit`.
---
 doc/api/assert.md                            |   2 +-
 doc/api/util.md                              |  16 +
 lib/assert.js                                | 509 +-----------------
 lib/internal/util/comparisons.js             | 516 +++++++++++++++++++
 lib/util.js                                  |   5 +
 node.gyp                                     |   1 +
 test/parallel/test-util-isDeepStrictEqual.js | 483 +++++++++++++++++
 7 files changed, 1028 insertions(+), 504 deletions(-)
 create mode 100644 lib/internal/util/comparisons.js
 create mode 100644 test/parallel/test-util-isDeepStrictEqual.js

diff --git a/doc/api/assert.md b/doc/api/assert.md
index 4a6b06706fa9b9..fa874e916047d3 100644
--- a/doc/api/assert.md
+++ b/doc/api/assert.md
@@ -134,7 +134,7 @@ changes:
 * `expected` {any}
 * `message` {any}
 
-Similar to `assert.deepEqual()` with the following exceptions:
+Identical to [`assert.deepEqual()`][] with the following exceptions:
 
 1. Primitive values besides `NaN` are compared using the [Strict Equality
    Comparison][] ( `===` ). Set and Map values, Map keys and `NaN` are compared
diff --git a/doc/api/util.md b/doc/api/util.md
index 2653c01af1d4c9..5b296decf071ca 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -455,6 +455,21 @@ util.inspect.defaultOptions.maxArrayLength = null;
 console.log(arr); // logs the full array
 ```
 
+## util.isDeepStrictEqual(val1, val2)
+<!-- YAML
+added: REPLACEME
+-->
+
+* `val1` {any}
+* `val2` {any}
+* Returns: {string}
+
+Returns `true` if there is deep strict equality between `val` and `val2`.
+Otherwise, returns `false`.
+
+See [`assert.deepStrictEqual()`][] for more information about deep strict
+equality.
+
 ## util.promisify(original)
 <!-- YAML
 added: v8.0.0
@@ -1180,6 +1195,7 @@ Deprecated predecessor of `console.log`.
 [`Buffer.isBuffer()`]: buffer.html#buffer_class_method_buffer_isbuffer_obj
 [`Error`]: errors.html#errors_class_error
 [`Object.assign()`]: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
+[`assert.deepStrictEqual()`]: assert.html#assert_assert_deepstrictequal_actual_expected_message
 [`console.error()`]: console.html#console_console_error_data_args
 [`console.log()`]: console.html#console_console_log_data_args
 [`util.inspect()`]: #util_util_inspect_object_options
diff --git a/lib/assert.js b/lib/assert.js
index a29408f47e1cf9..9c7260a1a89575 100644
--- a/lib/assert.js
+++ b/lib/assert.js
@@ -20,12 +20,9 @@
 
 'use strict';
 
-const { compare } = process.binding('buffer');
-const { isSet, isMap, isDate, isRegExp } = process.binding('util');
-const { objectToString } = require('internal/util');
-const { isArrayBufferView } = require('internal/util/types');
+const { isDeepEqual, isDeepStrictEqual } =
+  require('internal/util/comparisons');
 const errors = require('internal/errors');
-const { propertyIsEnumerable } = Object.prototype;
 
 // The assert module provides functions that throw
 // AssertionError's when particular conditions are not met. The
@@ -100,522 +97,28 @@ assert.notEqual = function notEqual(actual, expected, message) {
 
 // The equivalence assertion tests a deep equality relation.
 assert.deepEqual = function deepEqual(actual, expected, message) {
-  if (!innerDeepEqual(actual, expected, false)) {
+  if (!isDeepEqual(actual, expected)) {
     innerFail(actual, expected, message, 'deepEqual', deepEqual);
   }
 };
 /* eslint-enable */
 
 assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
-  if (!innerDeepEqual(actual, expected, true)) {
+  if (!isDeepStrictEqual(actual, expected)) {
     innerFail(actual, expected, message, 'deepStrictEqual', deepStrictEqual);
   }
 };
 
-// Check if they have the same source and flags
-function areSimilarRegExps(a, b) {
-  return a.source === b.source && a.flags === b.flags;
-}
-
-// For small buffers it's faster to compare the buffer in a loop. The c++
-// barrier including the Uint8Array operation takes the advantage of the faster
-// binary compare otherwise. The break even point was at about 300 characters.
-function areSimilarTypedArrays(a, b, max) {
-  const len = a.byteLength;
-  if (len !== b.byteLength) {
-    return false;
-  }
-  if (len < max) {
-    for (var offset = 0; offset < len; offset++) {
-      if (a[offset] !== b[offset]) {
-        return false;
-      }
-    }
-    return true;
-  }
-  return compare(new Uint8Array(a.buffer, a.byteOffset, len),
-                 new Uint8Array(b.buffer, b.byteOffset, b.byteLength)) === 0;
-}
-
-function isFloatTypedArrayTag(tag) {
-  return tag === '[object Float32Array]' || tag === '[object Float64Array]';
-}
-
-function isArguments(tag) {
-  return tag === '[object Arguments]';
-}
-
-function isObjectOrArrayTag(tag) {
-  return tag === '[object Array]' || tag === '[object Object]';
-}
-
-// Notes: Type tags are historical [[Class]] properties that can be set by
-// FunctionTemplate::SetClassName() in C++ or Symbol.toStringTag in JS
-// and retrieved using Object.prototype.toString.call(obj) in JS
-// See https://tc39.github.io/ecma262/#sec-object.prototype.tostring
-// for a list of tags pre-defined in the spec.
-// There are some unspecified tags in the wild too (e.g. typed array tags).
-// Since tags can be altered, they only serve fast failures
-//
-// Typed arrays and buffers are checked by comparing the content in their
-// underlying ArrayBuffer. This optimization requires that it's
-// reasonable to interpret their underlying memory in the same way,
-// which is checked by comparing their type tags.
-// (e.g. a Uint8Array and a Uint16Array with the same memory content
-// could still be different because they will be interpreted differently).
-//
-// For strict comparison, objects should have
-// a) The same built-in type tags
-// b) The same prototypes.
-function strictDeepEqual(actual, expected, memos) {
-  if (typeof actual !== 'object') {
-    return typeof actual === 'number' && Number.isNaN(actual) &&
-      Number.isNaN(expected);
-  }
-  if (typeof expected !== 'object' || actual === null || expected === null) {
-    return false;
-  }
-  const actualTag = objectToString(actual);
-  const expectedTag = objectToString(expected);
-
-  if (actualTag !== expectedTag) {
-    return false;
-  }
-  if (Object.getPrototypeOf(actual) !== Object.getPrototypeOf(expected)) {
-    return false;
-  }
-  if (actualTag === '[object Array]') {
-    // Check for sparse arrays and general fast path
-    if (actual.length !== expected.length)
-      return false;
-    // Skip testing the part below and continue with the keyCheck.
-    return keyCheck(actual, expected, true, memos);
-  }
-  if (actualTag === '[object Object]') {
-    // Skip testing the part below and continue with the keyCheck.
-    return keyCheck(actual, expected, true, memos);
-  }
-  if (isDate(actual)) {
-    if (actual.getTime() !== expected.getTime()) {
-      return false;
-    }
-  } else if (isRegExp(actual)) {
-    if (!areSimilarRegExps(actual, expected)) {
-      return false;
-    }
-  } else if (actualTag === '[object Error]') {
-    // Do not compare the stack as it might differ even though the error itself
-    // is otherwise identical. The non-enumerable name should be identical as
-    // the prototype is also identical. Otherwise this is caught later on.
-    if (actual.message !== expected.message) {
-      return false;
-    }
-  } else if (isArrayBufferView(actual)) {
-    if (!areSimilarTypedArrays(actual, expected,
-                               isFloatTypedArrayTag(actualTag) ? 0 : 300)) {
-      return false;
-    }
-    // Buffer.compare returns true, so actual.length === expected.length
-    // if they both only contain numeric keys, we don't need to exam further
-    return keyCheck(actual, expected, true, memos, actual.length,
-                    expected.length);
-  } else if (typeof actual.valueOf === 'function') {
-    const actualValue = actual.valueOf();
-    // Note: Boxed string keys are going to be compared again by Object.keys
-    if (actualValue !== actual) {
-      if (!innerDeepEqual(actualValue, expected.valueOf(), true))
-        return false;
-      // Fast path for boxed primitives
-      var lengthActual = 0;
-      var lengthExpected = 0;
-      if (typeof actualValue === 'string') {
-        lengthActual = actual.length;
-        lengthExpected = expected.length;
-      }
-      return keyCheck(actual, expected, true, memos, lengthActual,
-                      lengthExpected);
-    }
-  }
-  return keyCheck(actual, expected, true, memos);
-}
-
-function looseDeepEqual(actual, expected, memos) {
-  if (actual === null || typeof actual !== 'object') {
-    if (expected === null || typeof expected !== 'object') {
-      // eslint-disable-next-line eqeqeq
-      return actual == expected;
-    }
-    return false;
-  }
-  if (expected === null || typeof expected !== 'object') {
-    return false;
-  }
-  if (isDate(actual) && isDate(expected)) {
-    return actual.getTime() === expected.getTime();
-  }
-  if (isRegExp(actual) && isRegExp(expected)) {
-    return areSimilarRegExps(actual, expected);
-  }
-  if (actual instanceof Error && expected instanceof Error) {
-    if (actual.message !== expected.message || actual.name !== expected.name)
-      return false;
-  }
-  const actualTag = objectToString(actual);
-  const expectedTag = objectToString(expected);
-  if (actualTag === expectedTag) {
-    if (!isObjectOrArrayTag(actualTag) && isArrayBufferView(actual)) {
-      return areSimilarTypedArrays(actual, expected,
-                                   isFloatTypedArrayTag(actualTag) ?
-                                     Infinity : 300);
-    }
-  // Ensure reflexivity of deepEqual with `arguments` objects.
-  // See https://github.com/nodejs/node-v0.x-archive/pull/7178
-  } else if (isArguments(actualTag) || isArguments(expectedTag)) {
-    return false;
-  }
-  return keyCheck(actual, expected, false, memos);
-}
-
-function keyCheck(actual, expected, strict, memos, lengthA, lengthB) {
-  // For all remaining Object pairs, including Array, objects and Maps,
-  // equivalence is determined by having:
-  // a) The same number of owned enumerable properties
-  // b) The same set of keys/indexes (although not necessarily the same order)
-  // c) Equivalent values for every corresponding key/index
-  // d) For Sets and Maps, equal contents
-  // Note: this accounts for both named and indexed properties on Arrays.
-  var aKeys = Object.keys(actual);
-  var bKeys = Object.keys(expected);
-  var i;
-
-  // The pair must have the same number of owned properties.
-  if (aKeys.length !== bKeys.length)
-    return false;
-
-  if (strict) {
-    var symbolKeysA = Object.getOwnPropertySymbols(actual);
-    var symbolKeysB = Object.getOwnPropertySymbols(expected);
-    if (symbolKeysA.length !== 0) {
-      symbolKeysA = symbolKeysA.filter((k) =>
-        propertyIsEnumerable.call(actual, k));
-      symbolKeysB = symbolKeysB.filter((k) =>
-        propertyIsEnumerable.call(expected, k));
-      if (symbolKeysA.length !== symbolKeysB.length)
-        return false;
-    } else if (symbolKeysB.length !== 0 && symbolKeysB.filter((k) =>
-      propertyIsEnumerable.call(expected, k)).length !== 0) {
-      return false;
-    }
-    if (lengthA !== undefined) {
-      if (aKeys.length !== lengthA || bKeys.length !== lengthB)
-        return false;
-      if (symbolKeysA.length === 0)
-        return true;
-      aKeys = [];
-      bKeys = [];
-    }
-    if (symbolKeysA.length !== 0) {
-      aKeys.push(...symbolKeysA);
-      bKeys.push(...symbolKeysB);
-    }
-  }
-
-  // Cheap key test:
-  const keys = {};
-  for (i = 0; i < aKeys.length; i++) {
-    keys[aKeys[i]] = true;
-  }
-  for (i = 0; i < aKeys.length; i++) {
-    if (keys[bKeys[i]] === undefined)
-      return false;
-  }
-
-  // Use memos to handle cycles.
-  if (memos === undefined) {
-    memos = {
-      actual: new Map(),
-      expected: new Map(),
-      position: 0
-    };
-  } else {
-    // We prevent up to two map.has(x) calls by directly retrieving the value
-    // and checking for undefined. The map can only contain numbers, so it is
-    // safe to check for undefined only.
-    const expectedMemoA = memos.actual.get(actual);
-    if (expectedMemoA !== undefined) {
-      const expectedMemoB = memos.expected.get(expected);
-      if (expectedMemoB !== undefined) {
-        return expectedMemoA === expectedMemoB;
-      }
-    }
-    memos.position++;
-  }
-
-  memos.actual.set(actual, memos.position);
-  memos.expected.set(expected, memos.position);
-
-  const areEq = objEquiv(actual, expected, strict, aKeys, memos);
-
-  memos.actual.delete(actual);
-  memos.expected.delete(expected);
-
-  return areEq;
-}
-
-function innerDeepEqual(actual, expected, strict, memos) {
-  // All identical values are equivalent, as determined by ===.
-  if (actual === expected) {
-    if (actual !== 0)
-      return true;
-    return strict ? Object.is(actual, expected) : true;
-  }
-
-  // Check more closely if actual and expected are equal.
-  if (strict === true)
-    return strictDeepEqual(actual, expected, memos);
-
-  return looseDeepEqual(actual, expected, memos);
-}
-
-function setHasEqualElement(set, val1, strict, memo) {
-  // Go looking.
-  for (const val2 of set) {
-    if (innerDeepEqual(val1, val2, strict, memo)) {
-      // Remove the matching element to make sure we do not check that again.
-      set.delete(val2);
-      return true;
-    }
-  }
-
-  return false;
-}
-
-// Note: we actually run this multiple times for each loose key!
-// This is done to prevent slowing down the average case.
-function setHasLoosePrim(a, b, val) {
-  const altValues = findLooseMatchingPrimitives(val);
-  if (altValues === undefined)
-    return false;
-
-  var matches = 1;
-  for (var i = 0; i < altValues.length; i++) {
-    if (b.has(altValues[i])) {
-      matches--;
-    }
-    if (a.has(altValues[i])) {
-      matches++;
-    }
-  }
-  return matches === 0;
-}
-
-function setEquiv(a, b, strict, memo) {
-  // This code currently returns false for this pair of sets:
-  //   assert.deepEqual(new Set(['1', 1]), new Set([1]))
-  //
-  // In theory, all the items in the first set have a corresponding == value in
-  // the second set, but the sets have different sizes. Its a silly case,
-  // and more evidence that deepStrictEqual should always be preferred over
-  // deepEqual.
-  if (a.size !== b.size)
-    return false;
-
-  // This is a lazily initiated Set of entries which have to be compared
-  // pairwise.
-  var set = null;
-  for (const val of a) {
-    // Note: Checking for the objects first improves the performance for object
-    // heavy sets but it is a minor slow down for primitives. As they are fast
-    // to check this improves the worst case scenario instead.
-    if (typeof val === 'object' && val !== null) {
-      if (set === null) {
-        set = new Set();
-      }
-      // If the specified value doesn't exist in the second set its an not null
-      // object (or non strict only: a not matching primitive) we'll need to go
-      // hunting for something thats deep-(strict-)equal to it. To make this
-      // O(n log n) complexity we have to copy these values in a new set first.
-      set.add(val);
-    } else if (!b.has(val) && (strict || !setHasLoosePrim(a, b, val))) {
-      return false;
-    }
-  }
-
-  if (set !== null) {
-    for (const val of b) {
-      // We have to check if a primitive value is already
-      // matching and only if it's not, go hunting for it.
-      if (typeof val === 'object' && val !== null) {
-        if (!setHasEqualElement(set, val, strict, memo))
-          return false;
-      } else if (!a.has(val) && (strict || !setHasLoosePrim(b, a, val))) {
-        return false;
-      }
-    }
-  }
-
-  return true;
-}
-
-function findLooseMatchingPrimitives(prim) {
-  var values, number;
-  switch (typeof prim) {
-    case 'number':
-      values = ['' + prim];
-      if (prim === 1 || prim === 0)
-        values.push(Boolean(prim));
-      return values;
-    case 'string':
-      number = +prim;
-      if ('' + number === prim) {
-        values = [number];
-        if (number === 1 || number === 0)
-          values.push(Boolean(number));
-      }
-      return values;
-    case 'undefined':
-      return [null];
-    case 'object': // Only pass in null as object!
-      return [undefined];
-    case 'boolean':
-      number = +prim;
-      return [number, '' + number];
-  }
-}
-
-// This is a ugly but relatively fast way to determine if a loose equal entry
-// actually has a correspondent matching entry. Otherwise checking for such
-// values would be way more expensive (O(n^2)).
-// Note: we actually run this multiple times for each loose key!
-// This is done to prevent slowing down the average case.
-function mapHasLoosePrim(a, b, key1, memo, item1, item2) {
-  const altKeys = findLooseMatchingPrimitives(key1);
-  if (altKeys === undefined)
-    return false;
-
-  const setA = new Set();
-  const setB = new Set();
-
-  var keyCount = 1;
-
-  setA.add(item1);
-  if (b.has(key1)) {
-    keyCount--;
-    setB.add(item2);
-  }
-
-  for (var i = 0; i < altKeys.length; i++) {
-    const key2 = altKeys[i];
-    if (a.has(key2)) {
-      keyCount++;
-      setA.add(a.get(key2));
-    }
-    if (b.has(key2)) {
-      keyCount--;
-      setB.add(b.get(key2));
-    }
-  }
-  if (keyCount !== 0 || setA.size !== setB.size)
-    return false;
-
-  for (const val of setA) {
-    if (typeof val === 'object' && val !== null) {
-      if (!setHasEqualElement(setB, val, false, memo))
-        return false;
-    } else if (!setB.has(val) && !setHasLoosePrim(setA, setB, val)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function mapHasEqualEntry(set, map, key1, item1, strict, memo) {
-  // To be able to handle cases like:
-  //   Map([[{}, 'a'], [{}, 'b']]) vs Map([[{}, 'b'], [{}, 'a']])
-  // ... we need to consider *all* matching keys, not just the first we find.
-  for (const key2 of set) {
-    if (innerDeepEqual(key1, key2, strict, memo) &&
-      innerDeepEqual(item1, map.get(key2), strict, memo)) {
-      set.delete(key2);
-      return true;
-    }
-  }
-
-  return false;
-}
-
-function mapEquiv(a, b, strict, memo) {
-  if (a.size !== b.size)
-    return false;
-
-  var set = null;
-
-  for (const [key, item1] of a) {
-    if (typeof key === 'object' && key !== null) {
-      if (set === null) {
-        set = new Set();
-      }
-      set.add(key);
-    } else {
-      // By directly retrieving the value we prevent another b.has(key) check in
-      // almost all possible cases.
-      const item2 = b.get(key);
-      if ((item2 === undefined && !b.has(key) ||
-        !innerDeepEqual(item1, item2, strict, memo)) &&
-        (strict || !mapHasLoosePrim(a, b, key, memo, item1, item2))) {
-        return false;
-      }
-    }
-  }
-
-  if (set !== null) {
-    for (const [key, item] of b) {
-      if (typeof key === 'object' && key !== null) {
-        if (!mapHasEqualEntry(set, a, key, item, strict, memo))
-          return false;
-      } else if (!a.has(key) &&
-        (strict || !mapHasLoosePrim(b, a, key, memo, item))) {
-        return false;
-      }
-    }
-  }
-
-  return true;
-}
-
-function objEquiv(a, b, strict, keys, memos) {
-  // Sets and maps don't have their entries accessible via normal object
-  // properties.
-  if (isSet(a)) {
-    if (!isSet(b) || !setEquiv(a, b, strict, memos))
-      return false;
-  } else if (isMap(a)) {
-    if (!isMap(b) || !mapEquiv(a, b, strict, memos))
-      return false;
-  } else if (isSet(b) || isMap(b)) {
-    return false;
-  }
-
-  // The pair must have equivalent values for every corresponding key.
-  // Possibly expensive deep test:
-  for (var i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    if (!innerDeepEqual(a[key], b[key], strict, memos))
-      return false;
-  }
-  return true;
-}
-
 // The non-equivalence assertion tests for any deep inequality.
 assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
-  if (innerDeepEqual(actual, expected, false)) {
+  if (isDeepEqual(actual, expected)) {
     innerFail(actual, expected, message, 'notDeepEqual', notDeepEqual);
   }
 };
 
 assert.notDeepStrictEqual = notDeepStrictEqual;
 function notDeepStrictEqual(actual, expected, message) {
-  if (innerDeepEqual(actual, expected, true)) {
+  if (isDeepStrictEqual(actual, expected)) {
     innerFail(actual, expected, message, 'notDeepStrictEqual',
               notDeepStrictEqual);
   }
diff --git a/lib/internal/util/comparisons.js b/lib/internal/util/comparisons.js
new file mode 100644
index 00000000000000..1145bc7d9971ba
--- /dev/null
+++ b/lib/internal/util/comparisons.js
@@ -0,0 +1,516 @@
+'use strict';
+
+const { compare } = process.binding('buffer');
+const { isArrayBufferView } = require('internal/util/types');
+const { isDate, isMap, isRegExp, isSet } = process.binding('util');
+
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
+
+// Check if they have the same source and flags
+function areSimilarRegExps(a, b) {
+  return a.source === b.source && a.flags === b.flags;
+}
+
+// For small buffers it's faster to compare the buffer in a loop. The c++
+// barrier including the Uint8Array operation takes the advantage of the faster
+// binary compare otherwise. The break even point was at about 300 characters.
+function areSimilarTypedArrays(a, b, max) {
+  const len = a.byteLength;
+  if (len !== b.byteLength) {
+    return false;
+  }
+  if (len < max) {
+    for (var offset = 0; offset < len; offset++) {
+      if (a[offset] !== b[offset]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return compare(new Uint8Array(a.buffer, a.byteOffset, len),
+                 new Uint8Array(b.buffer, b.byteOffset, b.byteLength)) === 0;
+}
+
+function isFloatTypedArrayTag(tag) {
+  return tag === '[object Float32Array]' || tag === '[object Float64Array]';
+}
+
+function isArguments(tag) {
+  return tag === '[object Arguments]';
+}
+
+function isObjectOrArrayTag(tag) {
+  return tag === '[object Array]' || tag === '[object Object]';
+}
+
+// Notes: Type tags are historical [[Class]] properties that can be set by
+// FunctionTemplate::SetClassName() in C++ or Symbol.toStringTag in JS
+// and retrieved using Object.prototype.toString.call(obj) in JS
+// See https://tc39.github.io/ecma262/#sec-object.prototype.tostring
+// for a list of tags pre-defined in the spec.
+// There are some unspecified tags in the wild too (e.g. typed array tags).
+// Since tags can be altered, they only serve fast failures
+//
+// Typed arrays and buffers are checked by comparing the content in their
+// underlying ArrayBuffer. This optimization requires that it's
+// reasonable to interpret their underlying memory in the same way,
+// which is checked by comparing their type tags.
+// (e.g. a Uint8Array and a Uint16Array with the same memory content
+// could still be different because they will be interpreted differently).
+//
+// For strict comparison, objects should have
+// a) The same built-in type tags
+// b) The same prototypes.
+function strictDeepEqual(val1, val2, memos) {
+  if (typeof val1 !== 'object') {
+    return typeof val1 === 'number' && Number.isNaN(val1) &&
+      Number.isNaN(val2);
+  }
+  if (typeof val2 !== 'object' || val1 === null || val2 === null) {
+    return false;
+  }
+  const val1Tag = objectToString(val1);
+  const val2Tag = objectToString(val2);
+
+  if (val1Tag !== val2Tag) {
+    return false;
+  }
+  if (Object.getPrototypeOf(val1) !== Object.getPrototypeOf(val2)) {
+    return false;
+  }
+  if (val1Tag === '[object Array]') {
+    // Check for sparse arrays and general fast path
+    if (val1.length !== val2.length)
+      return false;
+    // Skip testing the part below and continue with the keyCheck.
+    return keyCheck(val1, val2, true, memos);
+  }
+  if (val1Tag === '[object Object]') {
+    // Skip testing the part below and continue with the keyCheck.
+    return keyCheck(val1, val2, true, memos);
+  }
+  if (isDate(val1)) {
+    if (val1.getTime() !== val2.getTime()) {
+      return false;
+    }
+  } else if (isRegExp(val1)) {
+    if (!areSimilarRegExps(val1, val2)) {
+      return false;
+    }
+  } else if (val1Tag === '[object Error]') {
+    // Do not compare the stack as it might differ even though the error itself
+    // is otherwise identical. The non-enumerable name should be identical as
+    // the prototype is also identical. Otherwise this is caught later on.
+    if (val1.message !== val2.message) {
+      return false;
+    }
+  } else if (isArrayBufferView(val1)) {
+    if (!areSimilarTypedArrays(val1, val2,
+                               isFloatTypedArrayTag(val1Tag) ? 0 : 300)) {
+      return false;
+    }
+    // Buffer.compare returns true, so val1.length === val2.length
+    // if they both only contain numeric keys, we don't need to exam further
+    return keyCheck(val1, val2, true, memos, val1.length,
+                    val2.length);
+  } else if (typeof val1.valueOf === 'function') {
+    const val1Value = val1.valueOf();
+    // Note: Boxed string keys are going to be compared again by Object.keys
+    if (val1Value !== val1) {
+      if (!innerDeepEqual(val1Value, val2.valueOf(), true))
+        return false;
+      // Fast path for boxed primitives
+      var lengthval1 = 0;
+      var lengthval2 = 0;
+      if (typeof val1Value === 'string') {
+        lengthval1 = val1.length;
+        lengthval2 = val2.length;
+      }
+      return keyCheck(val1, val2, true, memos, lengthval1,
+                      lengthval2);
+    }
+  }
+  return keyCheck(val1, val2, true, memos);
+}
+
+function looseDeepEqual(val1, val2, memos) {
+  if (val1 === null || typeof val1 !== 'object') {
+    if (val2 === null || typeof val2 !== 'object') {
+      // eslint-disable-next-line eqeqeq
+      return val1 == val2;
+    }
+    return false;
+  }
+  if (val2 === null || typeof val2 !== 'object') {
+    return false;
+  }
+  if (isDate(val1) && isDate(val2)) {
+    return val1.getTime() === val2.getTime();
+  }
+  if (isRegExp(val1) && isRegExp(val2)) {
+    return areSimilarRegExps(val1, val2);
+  }
+  if (val1 instanceof Error && val2 instanceof Error) {
+    if (val1.message !== val2.message || val1.name !== val2.name)
+      return false;
+  }
+  const val1Tag = objectToString(val1);
+  const val2Tag = objectToString(val2);
+  if (val1Tag === val2Tag) {
+    if (!isObjectOrArrayTag(val1Tag) && isArrayBufferView(val1)) {
+      return areSimilarTypedArrays(val1, val2,
+                                   isFloatTypedArrayTag(val1Tag) ?
+                                     Infinity : 300);
+    }
+  // Ensure reflexivity of deepEqual with `arguments` objects.
+  // See https://github.com/nodejs/node-v0.x-archive/pull/7178
+  } else if (isArguments(val1Tag) || isArguments(val2Tag)) {
+    return false;
+  }
+  return keyCheck(val1, val2, false, memos);
+}
+
+function keyCheck(val1, val2, strict, memos, lengthA, lengthB) {
+  // For all remaining Object pairs, including Array, objects and Maps,
+  // equivalence is determined by having:
+  // a) The same number of owned enumerable properties
+  // b) The same set of keys/indexes (although not necessarily the same order)
+  // c) Equivalent values for every corresponding key/index
+  // d) For Sets and Maps, equal contents
+  // Note: this accounts for both named and indexed properties on Arrays.
+  var aKeys = Object.keys(val1);
+  var bKeys = Object.keys(val2);
+  var i;
+
+  // The pair must have the same number of owned properties.
+  if (aKeys.length !== bKeys.length)
+    return false;
+
+  if (strict) {
+    var symbolKeysA = Object.getOwnPropertySymbols(val1);
+    var symbolKeysB = Object.getOwnPropertySymbols(val2);
+    if (symbolKeysA.length !== 0) {
+      symbolKeysA = symbolKeysA.filter((k) =>
+        propertyIsEnumerable.call(val1, k));
+      symbolKeysB = symbolKeysB.filter((k) =>
+        propertyIsEnumerable.call(val2, k));
+      if (symbolKeysA.length !== symbolKeysB.length)
+        return false;
+    } else if (symbolKeysB.length !== 0 && symbolKeysB.filter((k) =>
+      propertyIsEnumerable.call(val2, k)).length !== 0) {
+      return false;
+    }
+    if (lengthA !== undefined) {
+      if (aKeys.length !== lengthA || bKeys.length !== lengthB)
+        return false;
+      if (symbolKeysA.length === 0)
+        return true;
+      aKeys = [];
+      bKeys = [];
+    }
+    if (symbolKeysA.length !== 0) {
+      aKeys.push(...symbolKeysA);
+      bKeys.push(...symbolKeysB);
+    }
+  }
+
+  // Cheap key test:
+  const keys = {};
+  for (i = 0; i < aKeys.length; i++) {
+    keys[aKeys[i]] = true;
+  }
+  for (i = 0; i < aKeys.length; i++) {
+    if (keys[bKeys[i]] === undefined)
+      return false;
+  }
+
+  // Use memos to handle cycles.
+  if (memos === undefined) {
+    memos = {
+      val1: new Map(),
+      val2: new Map(),
+      position: 0
+    };
+  } else {
+    // We prevent up to two map.has(x) calls by directly retrieving the value
+    // and checking for undefined. The map can only contain numbers, so it is
+    // safe to check for undefined only.
+    const val2MemoA = memos.val1.get(val1);
+    if (val2MemoA !== undefined) {
+      const val2MemoB = memos.val2.get(val2);
+      if (val2MemoB !== undefined) {
+        return val2MemoA === val2MemoB;
+      }
+    }
+    memos.position++;
+  }
+
+  memos.val1.set(val1, memos.position);
+  memos.val2.set(val2, memos.position);
+
+  const areEq = objEquiv(val1, val2, strict, aKeys, memos);
+
+  memos.val1.delete(val1);
+  memos.val2.delete(val2);
+
+  return areEq;
+}
+
+function innerDeepEqual(val1, val2, strict, memos) {
+  // All identical values are equivalent, as determined by ===.
+  if (val1 === val2) {
+    if (val1 !== 0)
+      return true;
+    return strict ? Object.is(val1, val2) : true;
+  }
+
+  // Check more closely if val1 and val2 are equal.
+  if (strict === true)
+    return strictDeepEqual(val1, val2, memos);
+
+  return looseDeepEqual(val1, val2, memos);
+}
+
+function setHasEqualElement(set, val1, strict, memo) {
+  // Go looking.
+  for (const val2 of set) {
+    if (innerDeepEqual(val1, val2, strict, memo)) {
+      // Remove the matching element to make sure we do not check that again.
+      set.delete(val2);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// Note: we val1ly run this multiple times for each loose key!
+// This is done to prevent slowing down the average case.
+function setHasLoosePrim(a, b, val) {
+  const altValues = findLooseMatchingPrimitives(val);
+  if (altValues === undefined)
+    return false;
+
+  var matches = 1;
+  for (var i = 0; i < altValues.length; i++) {
+    if (b.has(altValues[i])) {
+      matches--;
+    }
+    if (a.has(altValues[i])) {
+      matches++;
+    }
+  }
+  return matches === 0;
+}
+
+function setEquiv(a, b, strict, memo) {
+  // This code currently returns false for this pair of sets:
+  //   assert.deepEqual(new Set(['1', 1]), new Set([1]))
+  //
+  // In theory, all the items in the first set have a corresponding == value in
+  // the second set, but the sets have different sizes. Its a silly case,
+  // and more evidence that deepStrictEqual should always be preferred over
+  // deepEqual.
+  if (a.size !== b.size)
+    return false;
+
+  // This is a lazily initiated Set of entries which have to be compared
+  // pairwise.
+  var set = null;
+  for (const val of a) {
+    // Note: Checking for the objects first improves the performance for object
+    // heavy sets but it is a minor slow down for primitives. As they are fast
+    // to check this improves the worst case scenario instead.
+    if (typeof val === 'object' && val !== null) {
+      if (set === null) {
+        set = new Set();
+      }
+      // If the specified value doesn't exist in the second set its an not null
+      // object (or non strict only: a not matching primitive) we'll need to go
+      // hunting for something thats deep-(strict-)equal to it. To make this
+      // O(n log n) complexity we have to copy these values in a new set first.
+      set.add(val);
+    } else if (!b.has(val) && (strict || !setHasLoosePrim(a, b, val))) {
+      return false;
+    }
+  }
+
+  if (set !== null) {
+    for (const val of b) {
+      // We have to check if a primitive value is already
+      // matching and only if it's not, go hunting for it.
+      if (typeof val === 'object' && val !== null) {
+        if (!setHasEqualElement(set, val, strict, memo))
+          return false;
+      } else if (!a.has(val) && (strict || !setHasLoosePrim(b, a, val))) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+function findLooseMatchingPrimitives(prim) {
+  var values, number;
+  switch (typeof prim) {
+    case 'number':
+      values = ['' + prim];
+      if (prim === 1 || prim === 0)
+        values.push(Boolean(prim));
+      return values;
+    case 'string':
+      number = +prim;
+      if ('' + number === prim) {
+        values = [number];
+        if (number === 1 || number === 0)
+          values.push(Boolean(number));
+      }
+      return values;
+    case 'undefined':
+      return [null];
+    case 'object': // Only pass in null as object!
+      return [undefined];
+    case 'boolean':
+      number = +prim;
+      return [number, '' + number];
+  }
+}
+
+// This is a ugly but relatively fast way to determine if a loose equal entry
+// val1ly has a correspondent matching entry. Otherwise checking for such
+// values would be way more expensive (O(n^2)).
+// Note: we val1ly run this multiple times for each loose key!
+// This is done to prevent slowing down the average case.
+function mapHasLoosePrim(a, b, key1, memo, item1, item2) {
+  const altKeys = findLooseMatchingPrimitives(key1);
+  if (altKeys === undefined)
+    return false;
+
+  const setA = new Set();
+  const setB = new Set();
+
+  var keyCount = 1;
+
+  setA.add(item1);
+  if (b.has(key1)) {
+    keyCount--;
+    setB.add(item2);
+  }
+
+  for (var i = 0; i < altKeys.length; i++) {
+    const key2 = altKeys[i];
+    if (a.has(key2)) {
+      keyCount++;
+      setA.add(a.get(key2));
+    }
+    if (b.has(key2)) {
+      keyCount--;
+      setB.add(b.get(key2));
+    }
+  }
+  if (keyCount !== 0 || setA.size !== setB.size)
+    return false;
+
+  for (const val of setA) {
+    if (typeof val === 'object' && val !== null) {
+      if (!setHasEqualElement(setB, val, false, memo))
+        return false;
+    } else if (!setB.has(val) && !setHasLoosePrim(setA, setB, val)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function mapHasEqualEntry(set, map, key1, item1, strict, memo) {
+  // To be able to handle cases like:
+  //   Map([[{}, 'a'], [{}, 'b']]) vs Map([[{}, 'b'], [{}, 'a']])
+  // ... we need to consider *all* matching keys, not just the first we find.
+  for (const key2 of set) {
+    if (innerDeepEqual(key1, key2, strict, memo) &&
+      innerDeepEqual(item1, map.get(key2), strict, memo)) {
+      set.delete(key2);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function mapEquiv(a, b, strict, memo) {
+  if (a.size !== b.size)
+    return false;
+
+  var set = null;
+
+  for (const [key, item1] of a) {
+    if (typeof key === 'object' && key !== null) {
+      if (set === null) {
+        set = new Set();
+      }
+      set.add(key);
+    } else {
+      // By directly retrieving the value we prevent another b.has(key) check in
+      // almost all possible cases.
+      const item2 = b.get(key);
+      if ((item2 === undefined && !b.has(key) ||
+        !innerDeepEqual(item1, item2, strict, memo)) &&
+        (strict || !mapHasLoosePrim(a, b, key, memo, item1, item2))) {
+        return false;
+      }
+    }
+  }
+
+  if (set !== null) {
+    for (const [key, item] of b) {
+      if (typeof key === 'object' && key !== null) {
+        if (!mapHasEqualEntry(set, a, key, item, strict, memo))
+          return false;
+      } else if (!a.has(key) &&
+        (strict || !mapHasLoosePrim(b, a, key, memo, item))) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}
+
+function objEquiv(a, b, strict, keys, memos) {
+  // Sets and maps don't have their entries accessible via normal object
+  // properties.
+  if (isSet(a)) {
+    if (!isSet(b) || !setEquiv(a, b, strict, memos))
+      return false;
+  } else if (isMap(a)) {
+    if (!isMap(b) || !mapEquiv(a, b, strict, memos))
+      return false;
+  } else if (isSet(b) || isMap(b)) {
+    return false;
+  }
+
+  // The pair must have equivalent values for every corresponding key.
+  // Possibly expensive deep test:
+  for (var i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (!innerDeepEqual(a[key], b[key], strict, memos))
+      return false;
+  }
+  return true;
+}
+
+function isDeepEqual(val1, val2) {
+  return innerDeepEqual(val1, val2, false);
+}
+
+function isDeepStrictEqual(val1, val2) {
+  return innerDeepEqual(val1, val2, true);
+}
+
+module.exports = {
+  isDeepEqual,
+  isDeepStrictEqual
+};
diff --git a/lib/util.js b/lib/util.js
index 2574c2dd6692e4..4a75397c567b78 100644
--- a/lib/util.js
+++ b/lib/util.js
@@ -48,6 +48,10 @@ const {
   isTypedArray
 } = require('internal/util/types');
 
+const {
+  isDeepStrictEqual
+} = require('internal/util/comparisons');
+
 const {
   customInspectSymbol,
   deprecate,
@@ -1114,6 +1118,7 @@ module.exports = exports = {
   isArray: Array.isArray,
   isBoolean,
   isBuffer,
+  isDeepStrictEqual,
   isNull,
   isNullOrUndefined,
   isNumber,
diff --git a/node.gyp b/node.gyp
index 66949aa3b8bb5a..80f31b858b7846 100644
--- a/node.gyp
+++ b/node.gyp
@@ -123,6 +123,7 @@
       'lib/internal/tls.js',
       'lib/internal/url.js',
       'lib/internal/util.js',
+      'lib/internal/util/comparisons.js',
       'lib/internal/util/types.js',
       'lib/internal/http2/core.js',
       'lib/internal/http2/compat.js',
diff --git a/test/parallel/test-util-isDeepStrictEqual.js b/test/parallel/test-util-isDeepStrictEqual.js
new file mode 100644
index 00000000000000..356a9a71324971
--- /dev/null
+++ b/test/parallel/test-util-isDeepStrictEqual.js
@@ -0,0 +1,483 @@
+'use strict';
+
+// Confirm functionality of `util.isDeepStrictEqual()`.
+
+require('../common');
+
+const assert = require('assert');
+const util = require('util');
+
+class MyDate extends Date {
+  constructor(...args) {
+    super(...args);
+    this[0] = '1';
+  }
+}
+
+class MyRegExp extends RegExp {
+  constructor(...args) {
+    super(...args);
+    this[0] = '1';
+  }
+}
+
+{
+  const arr = new Uint8Array([120, 121, 122, 10]);
+  const buf = Buffer.from(arr);
+  // They have different [[Prototype]]
+  assert.strictEqual(util.isDeepStrictEqual(arr, buf), false);
+
+  const buf2 = Buffer.from(arr);
+  buf2.prop = 1;
+
+  assert.strictEqual(util.isDeepStrictEqual(buf2, buf), false);
+
+  const arr2 = new Uint8Array([120, 121, 122, 10]);
+  arr2.prop = 5;
+  assert.strictEqual(util.isDeepStrictEqual(arr, arr2), false);
+}
+
+{
+  const date = new Date('2016');
+
+  const date2 = new MyDate('2016');
+
+  // deepStrictEqual checks own properties
+  assert.strictEqual(util.isDeepStrictEqual(date, date2), false);
+  assert.strictEqual(util.isDeepStrictEqual(date2, date), false);
+}
+
+{
+  const re1 = new RegExp('test');
+  const re2 = new MyRegExp('test');
+
+  // deepStrictEqual checks all properties
+  assert.strictEqual(util.isDeepStrictEqual(re1, re2), false);
+}
+
+{
+  // For these cases, deepStrictEqual should throw.
+  const similar = new Set([
+    { 0: '1' },  // Object
+    { 0: 1 },  // Object
+    new String('1'),  // Object
+    ['1'],  // Array
+    [1],  // Array
+    new MyDate('2016'), // Date with this[0] = '1'
+    new MyRegExp('test'),  // RegExp with this[0] = '1'
+    new Int8Array([1]), // Int8Array
+    new Uint8Array([1]), // Uint8Array
+    new Int16Array([1]), // Int16Array
+    new Uint16Array([1]), // Uint16Array
+    new Int32Array([1]), // Int32Array
+    new Uint32Array([1]), // Uint32Array
+    Buffer.from([1]), // Buffer
+  ]);
+
+  for (const a of similar) {
+    for (const b of similar) {
+      if (a !== b) {
+        assert.strictEqual(util.isDeepStrictEqual(a, b), false);
+      }
+    }
+  }
+}
+
+function utilIsDeepStrict(a, b) {
+  assert.strictEqual(util.isDeepStrictEqual(a, b), true);
+  assert.strictEqual(util.isDeepStrictEqual(b, a), true);
+}
+
+function notUtilIsDeepStrict(a, b) {
+  assert.strictEqual(util.isDeepStrictEqual(a, b), false);
+  assert.strictEqual(util.isDeepStrictEqual(b, a), false);
+}
+
+// es6 Maps and Sets
+utilIsDeepStrict(new Set(), new Set());
+utilIsDeepStrict(new Map(), new Map());
+
+utilIsDeepStrict(new Set([1, 2, 3]), new Set([1, 2, 3]));
+notUtilIsDeepStrict(new Set([1, 2, 3]), new Set([1, 2, 3, 4]));
+notUtilIsDeepStrict(new Set([1, 2, 3, 4]), new Set([1, 2, 3]));
+utilIsDeepStrict(new Set(['1', '2', '3']), new Set(['1', '2', '3']));
+utilIsDeepStrict(new Set([[1, 2], [3, 4]]), new Set([[3, 4], [1, 2]]));
+
+{
+  const a = [ 1, 2 ];
+  const b = [ 3, 4 ];
+  const c = [ 1, 2 ];
+  const d = [ 3, 4 ];
+
+  utilIsDeepStrict(
+    { a: a, b: b, s: new Set([a, b]) },
+    { a: c, b: d, s: new Set([d, c]) }
+  );
+}
+
+utilIsDeepStrict(new Map([[1, 1], [2, 2]]), new Map([[1, 1], [2, 2]]));
+utilIsDeepStrict(new Map([[1, 1], [2, 2]]), new Map([[2, 2], [1, 1]]));
+notUtilIsDeepStrict(new Map([[1, 1], [2, 2]]), new Map([[1, 2], [2, 1]]));
+notUtilIsDeepStrict(
+  new Map([[[1], 1], [{}, 2]]),
+  new Map([[[1], 2], [{}, 1]])
+);
+
+notUtilIsDeepStrict(new Set([1]), [1]);
+notUtilIsDeepStrict(new Set(), []);
+notUtilIsDeepStrict(new Set(), {});
+
+notUtilIsDeepStrict(new Map([['a', 1]]), { a: 1 });
+notUtilIsDeepStrict(new Map(), []);
+notUtilIsDeepStrict(new Map(), {});
+
+notUtilIsDeepStrict(new Set(['1']), new Set([1]));
+
+notUtilIsDeepStrict(new Map([['1', 'a']]), new Map([[1, 'a']]));
+notUtilIsDeepStrict(new Map([['a', '1']]), new Map([['a', 1]]));
+notUtilIsDeepStrict(new Map([['a', '1']]), new Map([['a', 2]]));
+
+utilIsDeepStrict(new Set([{}]), new Set([{}]));
+
+// Ref: https://github.com/nodejs/node/issues/13347
+notUtilIsDeepStrict(
+  new Set([{ a: 1 }, { a: 1 }]),
+  new Set([{ a: 1 }, { a: 2 }])
+);
+notUtilIsDeepStrict(
+  new Set([{ a: 1 }, { a: 1 }, { a: 2 }]),
+  new Set([{ a: 1 }, { a: 2 }, { a: 2 }])
+);
+notUtilIsDeepStrict(
+  new Map([[{ x: 1 }, 5], [{ x: 1 }, 5]]),
+  new Map([[{ x: 1 }, 5], [{ x: 2 }, 5]])
+);
+
+notUtilIsDeepStrict(new Set([3, '3']), new Set([3, 4]));
+notUtilIsDeepStrict(new Map([[3, 0], ['3', 0]]), new Map([[3, 0], [4, 0]]));
+
+notUtilIsDeepStrict(
+  new Set([{ a: 1 }, { a: 1 }, { a: 2 }]),
+  new Set([{ a: 1 }, { a: 2 }, { a: 2 }])
+);
+
+// Mixed primitive and object keys
+utilIsDeepStrict(
+  new Map([[1, 'a'], [{}, 'a']]),
+  new Map([[1, 'a'], [{}, 'a']])
+);
+utilIsDeepStrict(
+  new Set([1, 'a', [{}, 'a']]),
+  new Set([1, 'a', [{}, 'a']])
+);
+
+// This is an awful case, where a map contains multiple equivalent keys:
+notUtilIsDeepStrict(
+  new Map([[1, 'a'], ['1', 'b']]),
+  new Map([['1', 'a'], [true, 'b']])
+);
+notUtilIsDeepStrict(
+  new Set(['a']),
+  new Set(['b'])
+);
+utilIsDeepStrict(
+  new Map([[{}, 'a'], [{}, 'b']]),
+  new Map([[{}, 'b'], [{}, 'a']])
+);
+notUtilIsDeepStrict(
+  new Map([[true, 'a'], ['1', 'b'], [1, 'a']]),
+  new Map([['1', 'a'], [1, 'b'], [true, 'a']])
+);
+notUtilIsDeepStrict(
+  new Map([[true, 'a'], ['1', 'b'], [1, 'c']]),
+  new Map([['1', 'a'], [1, 'b'], [true, 'a']])
+);
+
+// Similar object keys
+notUtilIsDeepStrict(
+  new Set([{}, {}]),
+  new Set([{}, 1])
+);
+notUtilIsDeepStrict(
+  new Set([[{}, 1], [{}, 1]]),
+  new Set([[{}, 1], [1, 1]])
+);
+notUtilIsDeepStrict(
+  new Map([[{}, 1], [{}, 1]]),
+  new Map([[{}, 1], [1, 1]])
+);
+notUtilIsDeepStrict(
+  new Map([[{}, 1], [true, 1]]),
+  new Map([[{}, 1], [1, 1]])
+);
+
+// Similar primitive key / values
+notUtilIsDeepStrict(
+  new Set([1, true, false]),
+  new Set(['1', 0, '0'])
+);
+notUtilIsDeepStrict(
+  new Map([[1, 5], [true, 5], [false, 5]]),
+  new Map([['1', 5], [0, 5], ['0', 5]])
+);
+
+// undefined value in Map
+utilIsDeepStrict(
+  new Map([[1, undefined]]),
+  new Map([[1, undefined]])
+);
+notUtilIsDeepStrict(
+  new Map([[1, null]]),
+  new Map([['1', undefined]])
+);
+notUtilIsDeepStrict(
+  new Map([[1, undefined]]),
+  new Map([[2, undefined]])
+);
+
+// null as key
+utilIsDeepStrict(
+  new Map([[null, 3]]),
+  new Map([[null, 3]])
+);
+notUtilIsDeepStrict(
+  new Map([[null, undefined]]),
+  new Map([[undefined, null]])
+);
+notUtilIsDeepStrict(
+  new Set([null]),
+  new Set([undefined])
+);
+
+// GH-6416. Make sure circular refs don't throw.
+{
+  const b = {};
+  b.b = b;
+  const c = {};
+  c.b = c;
+
+  utilIsDeepStrict(b, c);
+
+  const d = {};
+  d.a = 1;
+  d.b = d;
+  const e = {};
+  e.a = 1;
+  e.b = {};
+
+  notUtilIsDeepStrict(d, e);
+}
+
+// GH-14441. Circular structures should be consistent
+{
+  const a = {};
+  const b = {};
+  a.a = a;
+  b.a = {};
+  b.a.a = a;
+  utilIsDeepStrict(a, b);
+}
+
+{
+  const a = new Set();
+  const b = new Set();
+  const c = new Set();
+  a.add(a);
+  b.add(b);
+  c.add(a);
+  utilIsDeepStrict(b, c);
+}
+
+// GH-7178. Ensure reflexivity of deepEqual with `arguments` objects.
+{
+  const args = (function() { return arguments; })();
+  notUtilIsDeepStrict([], args);
+}
+
+// More checking that arguments objects are handled correctly
+{
+  // eslint-disable-next-line func-style
+  const returnArguments = function() { return arguments; };
+
+  const someArgs = returnArguments('a');
+  const sameArgs = returnArguments('a');
+  const diffArgs = returnArguments('b');
+
+  notUtilIsDeepStrict(someArgs, ['a']);
+  notUtilIsDeepStrict(someArgs, { '0': 'a' });
+  notUtilIsDeepStrict(someArgs, diffArgs);
+  utilIsDeepStrict(someArgs, sameArgs);
+}
+
+{
+  const values = [
+    123,
+    Infinity,
+    0,
+    null,
+    undefined,
+    false,
+    true,
+    {},
+    [],
+    () => {},
+  ];
+  utilIsDeepStrict(new Set(values), new Set(values));
+  utilIsDeepStrict(new Set(values), new Set(values.reverse()));
+
+  const mapValues = values.map((v) => [v, { a: 5 }]);
+  utilIsDeepStrict(new Map(mapValues), new Map(mapValues));
+  utilIsDeepStrict(new Map(mapValues), new Map(mapValues.reverse()));
+}
+
+{
+  const s1 = new Set();
+  const s2 = new Set();
+  s1.add(1);
+  s1.add(2);
+  s2.add(2);
+  s2.add(1);
+  utilIsDeepStrict(s1, s2);
+}
+
+{
+  const m1 = new Map();
+  const m2 = new Map();
+  const obj = { a: 5, b: 6 };
+  m1.set(1, obj);
+  m1.set(2, 'hi');
+  m1.set(3, [1, 2, 3]);
+
+  m2.set(2, 'hi'); // different order
+  m2.set(1, obj);
+  m2.set(3, [1, 2, 3]); // deep equal, but not reference equal.
+
+  utilIsDeepStrict(m1, m2);
+}
+
+{
+  const m1 = new Map();
+  const m2 = new Map();
+
+  // m1 contains itself.
+  m1.set(1, m1);
+  m2.set(1, new Map());
+
+  notUtilIsDeepStrict(m1, m2);
+}
+
+{
+  const map1 = new Map([[1, 1]]);
+  const map2 = new Map([[1, '1']]);
+  assert.strictEqual(util.isDeepStrictEqual(map1, map2), false);
+}
+
+{
+  // Two equivalent sets / maps with different key/values applied shouldn't be
+  // the same. This is a terrible idea to do in practice, but deepEqual should
+  // still check for it.
+  const s1 = new Set();
+  const s2 = new Set();
+  s1.x = 5;
+  notUtilIsDeepStrict(s1, s2);
+
+  const m1 = new Map();
+  const m2 = new Map();
+  m1.x = 5;
+  notUtilIsDeepStrict(m1, m2);
+}
+
+{
+  // Circular references.
+  const s1 = new Set();
+  s1.add(s1);
+  const s2 = new Set();
+  s2.add(s2);
+  utilIsDeepStrict(s1, s2);
+
+  const m1 = new Map();
+  m1.set(2, m1);
+  const m2 = new Map();
+  m2.set(2, m2);
+  utilIsDeepStrict(m1, m2);
+
+  const m3 = new Map();
+  m3.set(m3, 2);
+  const m4 = new Map();
+  m4.set(m4, 2);
+  utilIsDeepStrict(m3, m4);
+}
+
+// Handle sparse arrays
+utilIsDeepStrict([1, , , 3], [1, , , 3]);
+notUtilIsDeepStrict([1, , , 3], [1, , , 3, , , ]);
+
+// Handle different error messages
+{
+  const err1 = new Error('foo1');
+  const err2 = new Error('foo2');
+  const err3 = new TypeError('foo1');
+  notUtilIsDeepStrict(err1, err2, assert.AssertionError);
+  notUtilIsDeepStrict(err1, err3, assert.AssertionError);
+  // TODO: evaluate if this should throw or not. The same applies for RegExp
+  // Date and any object that has the same keys but not the same prototype.
+  notUtilIsDeepStrict(err1, {}, assert.AssertionError);
+}
+
+// Handle NaN
+assert.strictEqual(util.isDeepStrictEqual(NaN, NaN), true);
+assert.strictEqual(util.isDeepStrictEqual({ a: NaN }, { a: NaN }), true);
+assert.strictEqual(
+  util.isDeepStrictEqual([ 1, 2, NaN, 4 ], [ 1, 2, NaN, 4 ]),
+  true
+);
+
+// Handle boxed primitives
+{
+  const boxedString = new String('test');
+  const boxedSymbol = Object(Symbol());
+  notUtilIsDeepStrict(new Boolean(true), Object(false));
+  notUtilIsDeepStrict(Object(true), new Number(1));
+  notUtilIsDeepStrict(new Number(2), new Number(1));
+  notUtilIsDeepStrict(boxedSymbol, Object(Symbol()));
+  notUtilIsDeepStrict(boxedSymbol, {});
+  utilIsDeepStrict(boxedSymbol, boxedSymbol);
+  utilIsDeepStrict(Object(true), Object(true));
+  utilIsDeepStrict(Object(2), Object(2));
+  utilIsDeepStrict(boxedString, Object('test'));
+  boxedString.slow = true;
+  notUtilIsDeepStrict(boxedString, Object('test'));
+  boxedSymbol.slow = true;
+  notUtilIsDeepStrict(boxedSymbol, {});
+}
+
+// Minus zero
+notUtilIsDeepStrict(0, -0);
+utilIsDeepStrict(-0, -0);
+
+// Handle symbols (enumerable only)
+{
+  const symbol1 = Symbol();
+  const obj1 = { [symbol1]: 1 };
+  const obj2 = { [symbol1]: 1 };
+  const obj3 = { [Symbol()]: 1 };
+  // Add a non enumerable symbol as well. It is going to be ignored!
+  Object.defineProperty(obj2, Symbol(), { value: 1 });
+  notUtilIsDeepStrict(obj1, obj3);
+  utilIsDeepStrict(obj1, obj2);
+  // TypedArrays have a fast path. Test for this as well.
+  const a = new Uint8Array(4);
+  const b = new Uint8Array(4);
+  a[symbol1] = true;
+  b[symbol1] = false;
+  notUtilIsDeepStrict(a, b);
+  b[symbol1] = true;
+  utilIsDeepStrict(a, b);
+  // The same as TypedArrays is valid for boxed primitives
+  const boxedStringA = new String('test');
+  const boxedStringB = new String('test');
+  boxedStringA[symbol1] = true;
+  notUtilIsDeepStrict(boxedStringA, boxedStringB);
+  boxedStringA[symbol1] = true;
+  utilIsDeepStrict(a, b);
+}