chai 5.1.1 → 5.2.0

package/lib/chai/interface/assert.js

@@ -25,11 +25,7 @@ import {AssertionError} from 'assertion-error';
  */
 export function assert(express, errmsg) {
   var test = new Assertion(null, null, chai.assert, true);
-  test.assert(
-      express
-    , errmsg
-    , '[ negation message unavailable ]'
-  );
+  test.assert(express, errmsg, '[ negation message unavailable ]');
 }
 
 /**
@@ -55,18 +51,22 @@ export function assert(express, errmsg) {
  */
 assert.fail = function (actual, expected, message, operator) {
   if (arguments.length < 2) {
-      // Comply with Node's fail([message]) interface
+    // Comply with Node's fail([message]) interface
 
-      message = actual;
-      actual = undefined;
+    message = actual;
+    actual = undefined;
   }
 
   message = message || 'assert.fail()';
-  throw new AssertionError(message, {
-      actual: actual
-    , expected: expected
-    , operator: operator
-  }, assert.fail);
+  throw new AssertionError(
+    message,
+    {
+      actual: actual,
+      expected: expected,
+      operator: operator
+    },
+    assert.fail
+  );
 };
 
 /**
@@ -125,12 +125,12 @@ assert.equal = function (act, exp, msg) {
   var test = new Assertion(act, msg, assert.equal, true);
 
   test.assert(
-      exp == flag(test, 'object')
-    , 'expected #{this} to equal #{exp}'
-    , 'expected #{this} to not equal #{act}'
-    , exp
-    , act
-    , true
+    exp == flag(test, 'object'),
+    'expected #{this} to equal #{exp}',
+    'expected #{this} to not equal #{act}',
+    exp,
+    act,
+    true
   );
 };
 
@@ -152,12 +152,12 @@ assert.notEqual = function (act, exp, msg) {
   var test = new Assertion(act, msg, assert.notEqual, true);
 
   test.assert(
-      exp != flag(test, 'object')
-    , 'expected #{this} to not equal #{exp}'
-    , 'expected #{this} to equal #{act}'
-    , exp
-    , act
-    , true
+    exp != flag(test, 'object'),
+    'expected #{this} to not equal #{exp}',
+    'expected #{this} to equal #{act}',
+    exp,
+    act,
+    true
   );
 };
 
@@ -540,7 +540,7 @@ assert.isDefined = function (val, msg) {
  */
 assert.isCallable = function (value, message) {
   new Assertion(value, message, assert.isCallable, true).is.callable;
-}
+};
 
 /**
  * ### .isNotCallable(value, [message])
@@ -706,21 +706,60 @@ assert.isNotNumber = function (val, msg) {
   new Assertion(val, msg, assert.isNotNumber, true).to.not.be.a('number');
 };
 
- /**
-  * ### .isFinite(value, [message])
-  *
-  * Asserts that `value` is a finite number. Unlike `.isNumber`, this will fail for `NaN` and `Infinity`.
-  *
-  *     var cups = 2;
-  *     assert.isFinite(cups, 'how many cups');
-  *     assert.isFinite(NaN); // throws
-  *
-  * @name isFinite
-  * @param {number} val
-  * @param {string} msg
-  * @namespace Assert
-  * @public
-  */
+/**
+ * ### .isNumeric(value, [message])
+ *
+ * Asserts that `value` is a number or BigInt.
+ *
+ *     var cups = 2;
+ *     assert.isNumeric(cups, 'how many cups');
+ *
+ *     var cups = 10n;
+ *     assert.isNumeric(cups, 'how many cups');
+ *
+ * @name isNumeric
+ * @param {unknown} val
+ * @param {string} msg
+ * @namespace Assert
+ * @public
+ */
+assert.isNumeric = function (val, msg) {
+  new Assertion(val, msg, assert.isNumeric, true).is.numeric;
+};
+
+/**
+ * ### .isNotNumeric(value, [message])
+ *
+ * Asserts that `value` is _not_ a number or BigInt.
+ *
+ *     var cups = '2 cups please';
+ *     assert.isNotNumeric(cups, 'how many cups');
+ *
+ * @name isNotNumeric
+ * @param {unknown} val
+ * @param {string} msg
+ * @namespace Assert
+ * @public
+ */
+assert.isNotNumeric = function (val, msg) {
+  new Assertion(val, msg, assert.isNotNumeric, true).is.not.numeric;
+};
+
+/**
+ * ### .isFinite(value, [message])
+ *
+ * Asserts that `value` is a finite number. Unlike `.isNumber`, this will fail for `NaN` and `Infinity`.
+ *
+ *     var cups = 2;
+ *     assert.isFinite(cups, 'how many cups');
+ *     assert.isFinite(NaN); // throws
+ *
+ * @name isFinite
+ * @param {number} val
+ * @param {string} msg
+ * @namespace Assert
+ * @public
+ */
 assert.isFinite = function (val, msg) {
   new Assertion(val, msg, assert.isFinite, true).to.be.finite;
 };
@@ -849,8 +888,9 @@ assert.instanceOf = function (val, type, msg) {
  * @public
  */
 assert.notInstanceOf = function (val, type, msg) {
-  new Assertion(val, msg, assert.notInstanceOf, true)
-    .to.not.be.instanceOf(type);
+  new Assertion(val, msg, assert.notInstanceOf, true).to.not.be.instanceOf(
+    type
+  );
 };
 
 /**
@@ -1015,8 +1055,9 @@ assert.nestedInclude = function (exp, inc, msg) {
  * @public
  */
 assert.notNestedInclude = function (exp, inc, msg) {
-  new Assertion(exp, msg, assert.notNestedInclude, true)
-    .not.nested.include(inc);
+  new Assertion(exp, msg, assert.notNestedInclude, true).not.nested.include(
+    inc
+  );
 };
 
 /**
@@ -1039,9 +1080,10 @@ assert.notNestedInclude = function (exp, inc, msg) {
  * @namespace Assert
  * @public
  */
-assert.deepNestedInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.deepNestedInclude, true)
-    .deep.nested.include(inc);
+assert.deepNestedInclude = function (exp, inc, msg) {
+  new Assertion(exp, msg, assert.deepNestedInclude, true).deep.nested.include(
+    inc
+  );
 };
 
 /**
@@ -1064,9 +1106,13 @@ assert.deepNestedInclude = function(exp, inc, msg) {
  * @namespace Assert
  * @public
  */
-assert.notDeepNestedInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.notDeepNestedInclude, true)
-    .not.deep.nested.include(inc);
+assert.notDeepNestedInclude = function (exp, inc, msg) {
+  new Assertion(
+    exp,
+    msg,
+    assert.notDeepNestedInclude,
+    true
+  ).not.deep.nested.include(inc);
 };
 
 /**
@@ -1085,7 +1131,7 @@ assert.notDeepNestedInclude = function(exp, inc, msg) {
  * @namespace Assert
  * @public
  */
-assert.ownInclude = function(exp, inc, msg) {
+assert.ownInclude = function (exp, inc, msg) {
   new Assertion(exp, msg, assert.ownInclude, true).own.include(inc);
 };
 
@@ -1106,7 +1152,7 @@ assert.ownInclude = function(exp, inc, msg) {
  * @namespace Assert
  * @public
  */
-assert.notOwnInclude = function(exp, inc, msg) {
+assert.notOwnInclude = function (exp, inc, msg) {
   new Assertion(exp, msg, assert.notOwnInclude, true).not.own.include(inc);
 };
 
@@ -1126,9 +1172,8 @@ assert.notOwnInclude = function(exp, inc, msg) {
  * @namespace Assert
  * @public
  */
-assert.deepOwnInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.deepOwnInclude, true)
-    .deep.own.include(inc);
+assert.deepOwnInclude = function (exp, inc, msg) {
+  new Assertion(exp, msg, assert.deepOwnInclude, true).deep.own.include(inc);
 };
 
 /**
@@ -1147,9 +1192,10 @@ assert.deepOwnInclude = function(exp, inc, msg) {
  * @namespace Assert
  * @public
  */
-assert.notDeepOwnInclude = function(exp, inc, msg) {
-  new Assertion(exp, msg, assert.notDeepOwnInclude, true)
-    .not.deep.own.include(inc);
+assert.notDeepOwnInclude = function (exp, inc, msg) {
+  new Assertion(exp, msg, assert.notDeepOwnInclude, true).not.deep.own.include(
+    inc
+  );
 };
 
 /**
@@ -1224,8 +1270,7 @@ assert.property = function (obj, prop, msg) {
  * @public
  */
 assert.notProperty = function (obj, prop, msg) {
-  new Assertion(obj, msg, assert.notProperty, true)
-    .to.not.have.property(prop);
+  new Assertion(obj, msg, assert.notProperty, true).to.not.have.property(prop);
 };
 
 /**
@@ -1246,8 +1291,7 @@ assert.notProperty = function (obj, prop, msg) {
  * @public
  */
 assert.propertyVal = function (obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.propertyVal, true)
-    .to.have.property(prop, val);
+  new Assertion(obj, msg, assert.propertyVal, true).to.have.property(prop, val);
 };
 
 /**
@@ -1269,8 +1313,10 @@ assert.propertyVal = function (obj, prop, val, msg) {
  * @public
  */
 assert.notPropertyVal = function (obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.notPropertyVal, true)
-    .to.not.have.property(prop, val);
+  new Assertion(obj, msg, assert.notPropertyVal, true).to.not.have.property(
+    prop,
+    val
+  );
 };
 
 /**
@@ -1290,8 +1336,10 @@ assert.notPropertyVal = function (obj, prop, val, msg) {
  * @public
  */
 assert.deepPropertyVal = function (obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.deepPropertyVal, true)
-    .to.have.deep.property(prop, val);
+  new Assertion(obj, msg, assert.deepPropertyVal, true).to.have.deep.property(
+    prop,
+    val
+  );
 };
 
 /**
@@ -1313,8 +1361,12 @@ assert.deepPropertyVal = function (obj, prop, val, msg) {
  * @public
  */
 assert.notDeepPropertyVal = function (obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.notDeepPropertyVal, true)
-    .to.not.have.deep.property(prop, val);
+  new Assertion(
+    obj,
+    msg,
+    assert.notDeepPropertyVal,
+    true
+  ).to.not.have.deep.property(prop, val);
 };
 
 /**
@@ -1332,8 +1384,7 @@ assert.notDeepPropertyVal = function (obj, prop, val, msg) {
  * @public
  */
 assert.ownProperty = function (obj, prop, msg) {
-  new Assertion(obj, msg, assert.ownProperty, true)
-    .to.have.own.property(prop);
+  new Assertion(obj, msg, assert.ownProperty, true).to.have.own.property(prop);
 };
 
 /**
@@ -1352,8 +1403,9 @@ assert.ownProperty = function (obj, prop, msg) {
  * @public
  */
 assert.notOwnProperty = function (obj, prop, msg) {
-  new Assertion(obj, msg, assert.notOwnProperty, true)
-    .to.not.have.own.property(prop);
+  new Assertion(obj, msg, assert.notOwnProperty, true).to.not.have.own.property(
+    prop
+  );
 };
 
 /**
@@ -1373,8 +1425,10 @@ assert.notOwnProperty = function (obj, prop, msg) {
  * @public
  */
 assert.ownPropertyVal = function (obj, prop, value, msg) {
-  new Assertion(obj, msg, assert.ownPropertyVal, true)
-    .to.have.own.property(prop, value);
+  new Assertion(obj, msg, assert.ownPropertyVal, true).to.have.own.property(
+    prop,
+    value
+  );
 };
 
 /**
@@ -1395,8 +1449,12 @@ assert.ownPropertyVal = function (obj, prop, value, msg) {
  * @public
  */
 assert.notOwnPropertyVal = function (obj, prop, value, msg) {
-  new Assertion(obj, msg, assert.notOwnPropertyVal, true)
-    .to.not.have.own.property(prop, value);
+  new Assertion(
+    obj,
+    msg,
+    assert.notOwnPropertyVal,
+    true
+  ).to.not.have.own.property(prop, value);
 };
 
 /**
@@ -1416,8 +1474,12 @@ assert.notOwnPropertyVal = function (obj, prop, value, msg) {
  * @public
  */
 assert.deepOwnPropertyVal = function (obj, prop, value, msg) {
-  new Assertion(obj, msg, assert.deepOwnPropertyVal, true)
-    .to.have.deep.own.property(prop, value);
+  new Assertion(
+    obj,
+    msg,
+    assert.deepOwnPropertyVal,
+    true
+  ).to.have.deep.own.property(prop, value);
 };
 
 /**
@@ -1440,8 +1502,12 @@ assert.deepOwnPropertyVal = function (obj, prop, value, msg) {
  * @public
  */
 assert.notDeepOwnPropertyVal = function (obj, prop, value, msg) {
-  new Assertion(obj, msg, assert.notDeepOwnPropertyVal, true)
-    .to.not.have.deep.own.property(prop, value);
+  new Assertion(
+    obj,
+    msg,
+    assert.notDeepOwnPropertyVal,
+    true
+  ).to.not.have.deep.own.property(prop, value);
 };
 
 /**
@@ -1461,8 +1527,9 @@ assert.notDeepOwnPropertyVal = function (obj, prop, value, msg) {
  * @public
  */
 assert.nestedProperty = function (obj, prop, msg) {
-  new Assertion(obj, msg, assert.nestedProperty, true)
-    .to.have.nested.property(prop);
+  new Assertion(obj, msg, assert.nestedProperty, true).to.have.nested.property(
+    prop
+  );
 };
 
 /**
@@ -1482,8 +1549,12 @@ assert.nestedProperty = function (obj, prop, msg) {
  * @public
  */
 assert.notNestedProperty = function (obj, prop, msg) {
-  new Assertion(obj, msg, assert.notNestedProperty, true)
-    .to.not.have.nested.property(prop);
+  new Assertion(
+    obj,
+    msg,
+    assert.notNestedProperty,
+    true
+  ).to.not.have.nested.property(prop);
 };
 
 /**
@@ -1504,8 +1575,12 @@ assert.notNestedProperty = function (obj, prop, msg) {
  * @public
  */
 assert.nestedPropertyVal = function (obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.nestedPropertyVal, true)
-    .to.have.nested.property(prop, val);
+  new Assertion(
+    obj,
+    msg,
+    assert.nestedPropertyVal,
+    true
+  ).to.have.nested.property(prop, val);
 };
 
 /**
@@ -1527,8 +1602,12 @@ assert.nestedPropertyVal = function (obj, prop, val, msg) {
  * @public
  */
 assert.notNestedPropertyVal = function (obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.notNestedPropertyVal, true)
-    .to.not.have.nested.property(prop, val);
+  new Assertion(
+    obj,
+    msg,
+    assert.notNestedPropertyVal,
+    true
+  ).to.not.have.nested.property(prop, val);
 };
 
 /**
@@ -1549,8 +1628,12 @@ assert.notNestedPropertyVal = function (obj, prop, val, msg) {
  * @public
  */
 assert.deepNestedPropertyVal = function (obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.deepNestedPropertyVal, true)
-    .to.have.deep.nested.property(prop, val);
+  new Assertion(
+    obj,
+    msg,
+    assert.deepNestedPropertyVal,
+    true
+  ).to.have.deep.nested.property(prop, val);
 };
 
 /**
@@ -1573,9 +1656,13 @@ assert.deepNestedPropertyVal = function (obj, prop, val, msg) {
  * @public
  */
 assert.notDeepNestedPropertyVal = function (obj, prop, val, msg) {
-  new Assertion(obj, msg, assert.notDeepNestedPropertyVal, true)
-    .to.not.have.deep.nested.property(prop, val);
-}
+  new Assertion(
+    obj,
+    msg,
+    assert.notDeepNestedPropertyVal,
+    true
+  ).to.not.have.deep.nested.property(prop, val);
+};
 
 /**
  * ### .lengthOf(object, length, [message])
@@ -1619,7 +1706,7 @@ assert.lengthOf = function (exp, len, msg) {
  */
 assert.hasAnyKeys = function (obj, keys, msg) {
   new Assertion(obj, msg, assert.hasAnyKeys, true).to.have.any.keys(keys);
-}
+};
 
 /**
  * ### .hasAllKeys(object, [keys], [message])
@@ -1642,7 +1729,7 @@ assert.hasAnyKeys = function (obj, keys, msg) {
  */
 assert.hasAllKeys = function (obj, keys, msg) {
   new Assertion(obj, msg, assert.hasAllKeys, true).to.have.all.keys(keys);
-}
+};
 
 /**
  * ### .containsAllKeys(object, [keys], [message])
@@ -1668,9 +1755,10 @@ assert.hasAllKeys = function (obj, keys, msg) {
  * @public
  */
 assert.containsAllKeys = function (obj, keys, msg) {
-  new Assertion(obj, msg, assert.containsAllKeys, true)
-    .to.contain.all.keys(keys);
-}
+  new Assertion(obj, msg, assert.containsAllKeys, true).to.contain.all.keys(
+    keys
+  );
+};
 
 /**
  * ### .doesNotHaveAnyKeys(object, [keys], [message])
@@ -1692,9 +1780,10 @@ assert.containsAllKeys = function (obj, keys, msg) {
  * @public
  */
 assert.doesNotHaveAnyKeys = function (obj, keys, msg) {
-  new Assertion(obj, msg, assert.doesNotHaveAnyKeys, true)
-    .to.not.have.any.keys(keys);
-}
+  new Assertion(obj, msg, assert.doesNotHaveAnyKeys, true).to.not.have.any.keys(
+    keys
+  );
+};
 
 /**
  * ### .doesNotHaveAllKeys(object, [keys], [message])
@@ -1716,9 +1805,10 @@ assert.doesNotHaveAnyKeys = function (obj, keys, msg) {
  * @public
  */
 assert.doesNotHaveAllKeys = function (obj, keys, msg) {
-  new Assertion(obj, msg, assert.doesNotHaveAllKeys, true)
-    .to.not.have.all.keys(keys);
-}
+  new Assertion(obj, msg, assert.doesNotHaveAllKeys, true).to.not.have.all.keys(
+    keys
+  );
+};
 
 /**
  * ### .hasAnyDeepKeys(object, [keys], [message])
@@ -1744,9 +1834,10 @@ assert.doesNotHaveAllKeys = function (obj, keys, msg) {
  * @public
  */
 assert.hasAnyDeepKeys = function (obj, keys, msg) {
-  new Assertion(obj, msg, assert.hasAnyDeepKeys, true)
-    .to.have.any.deep.keys(keys);
-}
+  new Assertion(obj, msg, assert.hasAnyDeepKeys, true).to.have.any.deep.keys(
+    keys
+  );
+};
 
 /**
  * ### .hasAllDeepKeys(object, [keys], [message])
@@ -1770,9 +1861,10 @@ assert.hasAnyDeepKeys = function (obj, keys, msg) {
  * @public
  */
 assert.hasAllDeepKeys = function (obj, keys, msg) {
-  new Assertion(obj, msg, assert.hasAllDeepKeys, true)
-    .to.have.all.deep.keys(keys);
-}
+  new Assertion(obj, msg, assert.hasAllDeepKeys, true).to.have.all.deep.keys(
+    keys
+  );
+};
 
 /**
  * ### .containsAllDeepKeys(object, [keys], [message])
@@ -1796,9 +1888,13 @@ assert.hasAllDeepKeys = function (obj, keys, msg) {
  * @public
  */
 assert.containsAllDeepKeys = function (obj, keys, msg) {
-  new Assertion(obj, msg, assert.containsAllDeepKeys, true)
-    .to.contain.all.deep.keys(keys);
-}
+  new Assertion(
+    obj,
+    msg,
+    assert.containsAllDeepKeys,
+    true
+  ).to.contain.all.deep.keys(keys);
+};
 
 /**
  * ### .doesNotHaveAnyDeepKeys(object, [keys], [message])
@@ -1822,9 +1918,13 @@ assert.containsAllDeepKeys = function (obj, keys, msg) {
  * @public
  */
 assert.doesNotHaveAnyDeepKeys = function (obj, keys, msg) {
-  new Assertion(obj, msg, assert.doesNotHaveAnyDeepKeys, true)
-    .to.not.have.any.deep.keys(keys);
-}
+  new Assertion(
+    obj,
+    msg,
+    assert.doesNotHaveAnyDeepKeys,
+    true
+  ).to.not.have.any.deep.keys(keys);
+};
 
 /**
  * ### .doesNotHaveAllDeepKeys(object, [keys], [message])
@@ -1848,9 +1948,13 @@ assert.doesNotHaveAnyDeepKeys = function (obj, keys, msg) {
  * @public
  */
 assert.doesNotHaveAllDeepKeys = function (obj, keys, msg) {
-  new Assertion(obj, msg, assert.doesNotHaveAllDeepKeys, true)
-    .to.not.have.all.deep.keys(keys);
-}
+  new Assertion(
+    obj,
+    msg,
+    assert.doesNotHaveAllDeepKeys,
+    true
+  ).to.not.have.all.deep.keys(keys);
+};
 
 /**
  * ### .throws(fn, [errorLike/string/regexp], [string/regexp], [message])
@@ -1889,8 +1993,10 @@ assert.throws = function (fn, errorLike, errMsgMatcher, msg) {
     errorLike = null;
   }
 
-  var assertErr = new Assertion(fn, msg, assert.throws, true)
-    .to.throw(errorLike, errMsgMatcher);
+  var assertErr = new Assertion(fn, msg, assert.throws, true).to.throw(
+    errorLike,
+    errMsgMatcher
+  );
   return flag(assertErr, 'object');
 };
 
@@ -1928,8 +2034,10 @@ assert.doesNotThrow = function (fn, errorLike, errMsgMatcher, message) {
     errorLike = null;
   }
 
-  new Assertion(fn, message, assert.doesNotThrow, true)
-    .to.not.throw(errorLike, errMsgMatcher);
+  new Assertion(fn, message, assert.doesNotThrow, true).to.not.throw(
+    errorLike,
+    errMsgMatcher
+  );
 };
 
 /**
@@ -1950,7 +2058,7 @@ assert.doesNotThrow = function (fn, errorLike, errMsgMatcher, message) {
  */
 assert.operator = function (val, operator, val2, msg) {
   var ok;
-  switch(operator) {
+  switch (operator) {
     case '==':
       ok = val == val2;
       break;
@@ -1985,9 +2093,10 @@ assert.operator = function (val, operator, val2, msg) {
   }
   var test = new Assertion(ok, msg, assert.operator, true);
   test.assert(
-      true === flag(test, 'object')
-    , 'expected ' + inspect(val) + ' to be ' + operator + ' ' + inspect(val2)
-    , 'expected ' + inspect(val) + ' to not be ' + operator + ' ' + inspect(val2) );
+    true === flag(test, 'object'),
+    'expected ' + inspect(val) + ' to be ' + operator + ' ' + inspect(val2),
+    'expected ' + inspect(val) + ' to not be ' + operator + ' ' + inspect(val2)
+  );
 };
 
 /**
@@ -2025,8 +2134,10 @@ assert.closeTo = function (act, exp, delta, msg) {
  * @public
  */
 assert.approximately = function (act, exp, delta, msg) {
-  new Assertion(act, msg, assert.approximately, true)
-    .to.be.approximately(exp, delta);
+  new Assertion(act, msg, assert.approximately, true).to.be.approximately(
+    exp,
+    delta
+  );
 };
 
 /**
@@ -2045,9 +2156,8 @@ assert.approximately = function (act, exp, delta, msg) {
  * @public
  */
 assert.sameMembers = function (set1, set2, msg) {
-  new Assertion(set1, msg, assert.sameMembers, true)
-    .to.have.same.members(set2);
-}
+  new Assertion(set1, msg, assert.sameMembers, true).to.have.same.members(set2);
+};
 
 /**
  * ### .notSameMembers(set1, set2, [message])
@@ -2065,9 +2175,13 @@ assert.sameMembers = function (set1, set2, msg) {
  * @public
  */
 assert.notSameMembers = function (set1, set2, msg) {
-  new Assertion(set1, msg, assert.notSameMembers, true)
-    .to.not.have.same.members(set2);
-}
+  new Assertion(
+    set1,
+    msg,
+    assert.notSameMembers,
+    true
+  ).to.not.have.same.members(set2);
+};
 
 /**
  * ### .sameDeepMembers(set1, set2, [message])
@@ -2085,9 +2199,13 @@ assert.notSameMembers = function (set1, set2, msg) {
  * @public
  */
 assert.sameDeepMembers = function (set1, set2, msg) {
-  new Assertion(set1, msg, assert.sameDeepMembers, true)
-    .to.have.same.deep.members(set2);
-}
+  new Assertion(
+    set1,
+    msg,
+    assert.sameDeepMembers,
+    true
+  ).to.have.same.deep.members(set2);
+};
 
 /**
  * ### .notSameDeepMembers(set1, set2, [message])
@@ -2105,9 +2223,13 @@ assert.sameDeepMembers = function (set1, set2, msg) {
  * @public
  */
 assert.notSameDeepMembers = function (set1, set2, msg) {
-  new Assertion(set1, msg, assert.notSameDeepMembers, true)
-    .to.not.have.same.deep.members(set2);
-}
+  new Assertion(
+    set1,
+    msg,
+    assert.notSameDeepMembers,
+    true
+  ).to.not.have.same.deep.members(set2);
+};
 
 /**
  * ### .sameOrderedMembers(set1, set2, [message])
@@ -2125,9 +2247,13 @@ assert.notSameDeepMembers = function (set1, set2, msg) {
  * @public
  */
 assert.sameOrderedMembers = function (set1, set2, msg) {
-  new Assertion(set1, msg, assert.sameOrderedMembers, true)
-    .to.have.same.ordered.members(set2);
-}
+  new Assertion(
+    set1,
+    msg,
+    assert.sameOrderedMembers,
+    true
+  ).to.have.same.ordered.members(set2);
+};
 
 /**
  * ### .notSameOrderedMembers(set1, set2, [message])
@@ -2145,9 +2271,13 @@ assert.sameOrderedMembers = function (set1, set2, msg) {
  * @public
  */
 assert.notSameOrderedMembers = function (set1, set2, msg) {
-  new Assertion(set1, msg, assert.notSameOrderedMembers, true)
-    .to.not.have.same.ordered.members(set2);
-}
+  new Assertion(
+    set1,
+    msg,
+    assert.notSameOrderedMembers,
+    true
+  ).to.not.have.same.ordered.members(set2);
+};
 
 /**
  * ### .sameDeepOrderedMembers(set1, set2, [message])
@@ -2165,9 +2295,13 @@ assert.notSameOrderedMembers = function (set1, set2, msg) {
  * @public
  */
 assert.sameDeepOrderedMembers = function (set1, set2, msg) {
-  new Assertion(set1, msg, assert.sameDeepOrderedMembers, true)
-    .to.have.same.deep.ordered.members(set2);
-}
+  new Assertion(
+    set1,
+    msg,
+    assert.sameDeepOrderedMembers,
+    true
+  ).to.have.same.deep.ordered.members(set2);
+};
 
 /**
  * ### .notSameDeepOrderedMembers(set1, set2, [message])
@@ -2186,9 +2320,13 @@ assert.sameDeepOrderedMembers = function (set1, set2, msg) {
  * @public
  */
 assert.notSameDeepOrderedMembers = function (set1, set2, msg) {
-  new Assertion(set1, msg, assert.notSameDeepOrderedMembers, true)
-    .to.not.have.same.deep.ordered.members(set2);
-}
+  new Assertion(
+    set1,
+    msg,
+    assert.notSameDeepOrderedMembers,
+    true
+  ).to.not.have.same.deep.ordered.members(set2);
+};
 
 /**
  * ### .includeMembers(superset, subset, [message])
@@ -2206,9 +2344,10 @@ assert.notSameDeepOrderedMembers = function (set1, set2, msg) {
  * @public
  */
 assert.includeMembers = function (superset, subset, msg) {
-  new Assertion(superset, msg, assert.includeMembers, true)
-    .to.include.members(subset);
-}
+  new Assertion(superset, msg, assert.includeMembers, true).to.include.members(
+    subset
+  );
+};
 
 /**
  * ### .notIncludeMembers(superset, subset, [message])
@@ -2226,9 +2365,13 @@ assert.includeMembers = function (superset, subset, msg) {
  * @public
  */
 assert.notIncludeMembers = function (superset, subset, msg) {
-  new Assertion(superset, msg, assert.notIncludeMembers, true)
-    .to.not.include.members(subset);
-}
+  new Assertion(
+    superset,
+    msg,
+    assert.notIncludeMembers,
+    true
+  ).to.not.include.members(subset);
+};
 
 /**
  * ### .includeDeepMembers(superset, subset, [message])
@@ -2246,9 +2389,13 @@ assert.notIncludeMembers = function (superset, subset, msg) {
  * @public
  */
 assert.includeDeepMembers = function (superset, subset, msg) {
-  new Assertion(superset, msg, assert.includeDeepMembers, true)
-    .to.include.deep.members(subset);
-}
+  new Assertion(
+    superset,
+    msg,
+    assert.includeDeepMembers,
+    true
+  ).to.include.deep.members(subset);
+};
 
 /**
  * ### .notIncludeDeepMembers(superset, subset, [message])
@@ -2266,9 +2413,13 @@ assert.includeDeepMembers = function (superset, subset, msg) {
  * @public
  */
 assert.notIncludeDeepMembers = function (superset, subset, msg) {
-  new Assertion(superset, msg, assert.notIncludeDeepMembers, true)
-    .to.not.include.deep.members(subset);
-}
+  new Assertion(
+    superset,
+    msg,
+    assert.notIncludeDeepMembers,
+    true
+  ).to.not.include.deep.members(subset);
+};
 
 /**
  * ### .includeOrderedMembers(superset, subset, [message])
@@ -2287,9 +2438,13 @@ assert.notIncludeDeepMembers = function (superset, subset, msg) {
  * @public
  */
 assert.includeOrderedMembers = function (superset, subset, msg) {
-  new Assertion(superset, msg, assert.includeOrderedMembers, true)
-    .to.include.ordered.members(subset);
-}
+  new Assertion(
+    superset,
+    msg,
+    assert.includeOrderedMembers,
+    true
+  ).to.include.ordered.members(subset);
+};
 
 /**
  * ### .notIncludeOrderedMembers(superset, subset, [message])
@@ -2309,9 +2464,13 @@ assert.includeOrderedMembers = function (superset, subset, msg) {
  * @public
  */
 assert.notIncludeOrderedMembers = function (superset, subset, msg) {
-  new Assertion(superset, msg, assert.notIncludeOrderedMembers, true)
-    .to.not.include.ordered.members(subset);
-}
+  new Assertion(
+    superset,
+    msg,
+    assert.notIncludeOrderedMembers,
+    true
+  ).to.not.include.ordered.members(subset);
+};
 
 /**
  * ### .includeDeepOrderedMembers(superset, subset, [message])
@@ -2330,9 +2489,13 @@ assert.notIncludeOrderedMembers = function (superset, subset, msg) {
  * @public
  */
 assert.includeDeepOrderedMembers = function (superset, subset, msg) {
-  new Assertion(superset, msg, assert.includeDeepOrderedMembers, true)
-    .to.include.deep.ordered.members(subset);
-}
+  new Assertion(
+    superset,
+    msg,
+    assert.includeDeepOrderedMembers,
+    true
+  ).to.include.deep.ordered.members(subset);
+};
 
 /**
  * ### .notIncludeDeepOrderedMembers(superset, subset, [message])
@@ -2353,9 +2516,13 @@ assert.includeDeepOrderedMembers = function (superset, subset, msg) {
  * @public
  */
 assert.notIncludeDeepOrderedMembers = function (superset, subset, msg) {
-  new Assertion(superset, msg, assert.notIncludeDeepOrderedMembers, true)
-    .to.not.include.deep.ordered.members(subset);
-}
+  new Assertion(
+    superset,
+    msg,
+    assert.notIncludeDeepOrderedMembers,
+    true
+  ).to.not.include.deep.ordered.members(subset);
+};
 
 /**
  * ### .oneOf(inList, list, [message])
@@ -2373,7 +2540,7 @@ assert.notIncludeDeepOrderedMembers = function (superset, subset, msg) {
  */
 assert.oneOf = function (inList, list, msg) {
   new Assertion(inList, msg, assert.oneOf, true).to.be.oneOf(list);
-}
+};
 
 /**
  * ### isIterable(obj, [message])
@@ -2388,19 +2555,15 @@ assert.oneOf = function (inList, list, msg) {
  * @namespace Assert
  * @public
  */
-assert.isIterable = function(obj, msg) {
+assert.isIterable = function (obj, msg) {
   if (obj == undefined || !obj[Symbol.iterator]) {
-    msg = msg ?
-      `${msg} expected ${inspect(obj)} to be an iterable` :
-      `expected ${inspect(obj)} to be an iterable`;
-
-    throw new AssertionError(
-      msg,
-      undefined,
-      assert.isIterable
-    );
+    msg = msg
+      ? `${msg} expected ${inspect(obj)} to be an iterable`
+      : `expected ${inspect(obj)} to be an iterable`;
+
+    throw new AssertionError(msg, undefined, assert.isIterable);
   }
-}
+};
 
 /**
  * ### .changes(function, object, property, [message])
@@ -2426,7 +2589,7 @@ assert.changes = function (fn, obj, prop, msg) {
   }
 
   new Assertion(fn, msg, assert.changes, true).to.change(obj, prop);
-}
+};
 
 /**
  * ### .changesBy(function, object, property, delta, [message])
@@ -2456,9 +2619,8 @@ assert.changesBy = function (fn, obj, prop, delta, msg) {
     prop = null;
   }
 
-  new Assertion(fn, msg, assert.changesBy, true)
-    .to.change(obj, prop).by(delta);
-}
+  new Assertion(fn, msg, assert.changesBy, true).to.change(obj, prop).by(delta);
+};
 
 /**
  * ### .doesNotChange(function, object, property, [message])
@@ -2484,9 +2646,11 @@ assert.doesNotChange = function (fn, obj, prop, msg) {
     prop = null;
   }
 
-  return new Assertion(fn, msg, assert.doesNotChange, true)
-    .to.not.change(obj, prop);
-}
+  return new Assertion(fn, msg, assert.doesNotChange, true).to.not.change(
+    obj,
+    prop
+  );
+};
 
 /**
  * ### .changesButNotBy(function, object, property, delta, [message])
@@ -2516,9 +2680,10 @@ assert.changesButNotBy = function (fn, obj, prop, delta, msg) {
     prop = null;
   }
 
-  new Assertion(fn, msg, assert.changesButNotBy, true)
-    .to.change(obj, prop).but.not.by(delta);
-}
+  new Assertion(fn, msg, assert.changesButNotBy, true).to
+    .change(obj, prop)
+    .but.not.by(delta);
+};
 
 /**
  * ### .increases(function, object, property, [message])
@@ -2544,9 +2709,8 @@ assert.increases = function (fn, obj, prop, msg) {
     prop = null;
   }
 
-  return new Assertion(fn, msg, assert.increases, true)
-    .to.increase(obj, prop);
-}
+  return new Assertion(fn, msg, assert.increases, true).to.increase(obj, prop);
+};
 
 /**
  * ### .increasesBy(function, object, property, delta, [message])
@@ -2576,9 +2740,10 @@ assert.increasesBy = function (fn, obj, prop, delta, msg) {
     prop = null;
   }
 
-  new Assertion(fn, msg, assert.increasesBy, true)
-    .to.increase(obj, prop).by(delta);
-}
+  new Assertion(fn, msg, assert.increasesBy, true).to
+    .increase(obj, prop)
+    .by(delta);
+};
 
 /**
  * ### .doesNotIncrease(function, object, property, [message])
@@ -2604,9 +2769,11 @@ assert.doesNotIncrease = function (fn, obj, prop, msg) {
     prop = null;
   }
 
-  return new Assertion(fn, msg, assert.doesNotIncrease, true)
-    .to.not.increase(obj, prop);
-}
+  return new Assertion(fn, msg, assert.doesNotIncrease, true).to.not.increase(
+    obj,
+    prop
+  );
+};
 
 /**
  * ### .increasesButNotBy(function, object, property, delta, [message])
@@ -2636,9 +2803,10 @@ assert.increasesButNotBy = function (fn, obj, prop, delta, msg) {
     prop = null;
   }
 
-  new Assertion(fn, msg, assert.increasesButNotBy, true)
-    .to.increase(obj, prop).but.not.by(delta);
-}
+  new Assertion(fn, msg, assert.increasesButNotBy, true).to
+    .increase(obj, prop)
+    .but.not.by(delta);
+};
 
 /**
  * ### .decreases(function, object, property, [message])
@@ -2664,9 +2832,8 @@ assert.decreases = function (fn, obj, prop, msg) {
     prop = null;
   }
 
-  return new Assertion(fn, msg, assert.decreases, true)
-    .to.decrease(obj, prop);
-}
+  return new Assertion(fn, msg, assert.decreases, true).to.decrease(obj, prop);
+};
 
 /**
  * ### .decreasesBy(function, object, property, delta, [message])
@@ -2696,9 +2863,10 @@ assert.decreasesBy = function (fn, obj, prop, delta, msg) {
     prop = null;
   }
 
-  new Assertion(fn, msg, assert.decreasesBy, true)
-    .to.decrease(obj, prop).by(delta);
-}
+  new Assertion(fn, msg, assert.decreasesBy, true).to
+    .decrease(obj, prop)
+    .by(delta);
+};
 
 /**
  * ### .doesNotDecrease(function, object, property, [message])
@@ -2724,9 +2892,11 @@ assert.doesNotDecrease = function (fn, obj, prop, msg) {
     prop = null;
   }
 
-  return new Assertion(fn, msg, assert.doesNotDecrease, true)
-    .to.not.decrease(obj, prop);
-}
+  return new Assertion(fn, msg, assert.doesNotDecrease, true).to.not.decrease(
+    obj,
+    prop
+  );
+};
 
 /**
  * ### .doesNotDecreaseBy(function, object, property, delta, [message])
@@ -2757,9 +2927,10 @@ assert.doesNotDecreaseBy = function (fn, obj, prop, delta, msg) {
     prop = null;
   }
 
-  return new Assertion(fn, msg, assert.doesNotDecreaseBy, true)
-    .to.not.decrease(obj, prop).by(delta);
-}
+  return new Assertion(fn, msg, assert.doesNotDecreaseBy, true).to.not
+    .decrease(obj, prop)
+    .by(delta);
+};
 
 /**
  * ### .decreasesButNotBy(function, object, property, delta, [message])
@@ -2789,9 +2960,10 @@ assert.decreasesButNotBy = function (fn, obj, prop, delta, msg) {
     prop = null;
   }
 
-  new Assertion(fn, msg, assert.decreasesButNotBy, true)
-    .to.decrease(obj, prop).but.not.by(delta);
-}
+  new Assertion(fn, msg, assert.decreasesButNotBy, true).to
+    .decrease(obj, prop)
+    .but.not.by(delta);
+};
 
 /**
  * ### .ifError(object)
@@ -2810,7 +2982,7 @@ assert.decreasesButNotBy = function (fn, obj, prop, delta, msg) {
  */
 assert.ifError = function (val) {
   if (val) {
-    throw(val);
+    throw val;
   }
 };
 
@@ -2956,7 +3128,7 @@ assert.isNotFrozen = function (obj, msg) {
  * @namespace Assert
  * @public
  */
-assert.isEmpty = function(val, msg) {
+assert.isEmpty = function (val, msg) {
   new Assertion(val, msg, assert.isEmpty, true).to.be.empty;
 };
 
@@ -2981,10 +3153,52 @@ assert.isEmpty = function(val, msg) {
  * @namespace Assert
  * @public
  */
-assert.isNotEmpty = function(val, msg) {
+assert.isNotEmpty = function (val, msg) {
   new Assertion(val, msg, assert.isNotEmpty, true).to.not.be.empty;
 };
 
+/**
+ * ### .containsSubset(target, subset)
+ *
+ * Asserts that the target primitive/object/array structure deeply contains all provided fields
+ * at the same key/depth as the provided structure.
+ *
+ * When comparing arrays, the target must contain the subset of at least one of each object/value in the subset array.
+ * Order does not matter.
+ *
+ *     assert.containsSubset(
+ *         [{name: {first: "John", last: "Smith"}}, {name: {first: "Jane", last: "Doe"}}],
+ *         [{name: {first: "Jane"}}]
+ *     );
+ *
+ * @name containsSubset
+ * @alias containSubset
+ * @param {unknown} val
+ * @param {unknown} exp
+ * @param {string} msg _optional_
+ * @namespace Assert
+ * @public
+ */
+assert.containsSubset = function (val, exp, msg) {
+  new Assertion(val, msg).to.containSubset(exp);
+};
+
+/**
+ * ### .doesNotContainSubset(target, subset)
+ *
+ * The negation of assert.containsSubset.
+ *
+ * @name doesNotContainSubset
+ * @param {unknown} val
+ * @param {unknown} exp
+ * @param {string} msg _optional_
+ * @namespace Assert
+ * @public
+ */
+assert.doesNotContainSubset = function (val, exp, msg) {
+  new Assertion(val, msg).to.not.containSubset(exp);
+};
+
 /**
  * Aliases.
  *
@@ -2992,21 +3206,23 @@ assert.isNotEmpty = function(val, msg) {
  * @param {unknown} as
  * @returns {unknown}
  */
-(function alias(name, as){
+const aliases = [
+  ['isOk', 'ok'],
+  ['isNotOk', 'notOk'],
+  ['throws', 'throw'],
+  ['throws', 'Throw'],
+  ['isExtensible', 'extensible'],
+  ['isNotExtensible', 'notExtensible'],
+  ['isSealed', 'sealed'],
+  ['isNotSealed', 'notSealed'],
+  ['isFrozen', 'frozen'],
+  ['isNotFrozen', 'notFrozen'],
+  ['isEmpty', 'empty'],
+  ['isNotEmpty', 'notEmpty'],
+  ['isCallable', 'isFunction'],
+  ['isNotCallable', 'isNotFunction'],
+  ['containsSubset', 'containSubset']
+];
+for (const [name, as] of aliases) {
   assert[as] = assert[name];
-  return alias;
-})
-('isOk', 'ok')
-('isNotOk', 'notOk')
-('throws', 'throw')
-('throws', 'Throw')
-('isExtensible', 'extensible')
-('isNotExtensible', 'notExtensible')
-('isSealed', 'sealed')
-('isNotSealed', 'notSealed')
-('isFrozen', 'frozen')
-('isNotFrozen', 'notFrozen')
-('isEmpty', 'empty')
-('isNotEmpty', 'notEmpty')
-('isCallable', 'isFunction')
-('isNotCallable', 'isNotFunction')
+}