chai 5.0.3 → 5.1.1

package/README.md

@@ -98,9 +98,9 @@ import { expect, use } from 'chai';  // Creates local variables `expect` and `us
 ### Usage with Mocha
 
 ```bash
-mocha spec.js -r chai/register-assert  # Using Assert style
-mocha spec.js -r chai/register-expect  # Using Expect style
-mocha spec.js -r chai/register-should  # Using Should style
+mocha spec.js --require chai/register-assert.js  # Using Assert style
+mocha spec.js --require chai/register-expect.js  # Using Expect style
+mocha spec.js --require chai/register-should.js  # Using Should style
 ```
 
 [Read more about these styles in our docs](http://chaijs.com/guide/styles/).

package/chai.js

@@ -38,6 +38,7 @@ __export(utils_exports, {
   inspect: () => inspect2,
   isNaN: () => isNaN2,
   isProxyEnabled: () => isProxyEnabled,
+  isRegExp: () => isRegExp2,
   objDisplay: () => objDisplay,
   overwriteChainableMethod: () => overwriteChainableMethod,
   overwriteMethod: () => overwriteMethod,
@@ -57,14 +58,22 @@ __export(check_error_exports, {
   getConstructorName: () => getConstructorName,
   getMessage: () => getMessage
 });
+function isErrorInstance(obj) {
+  return obj instanceof Error || Object.prototype.toString.call(obj) === "[object Error]";
+}
+__name(isErrorInstance, "isErrorInstance");
+function isRegExp(obj) {
+  return Object.prototype.toString.call(obj) === "[object RegExp]";
+}
+__name(isRegExp, "isRegExp");
 function compatibleInstance(thrown, errorLike) {
-  return errorLike instanceof Error && thrown === errorLike;
+  return isErrorInstance(errorLike) && thrown === errorLike;
 }
 __name(compatibleInstance, "compatibleInstance");
 function compatibleConstructor(thrown, errorLike) {
-  if (errorLike instanceof Error) {
+  if (isErrorInstance(errorLike)) {
     return thrown.constructor === errorLike.constructor || thrown instanceof errorLike.constructor;
-  } else if (errorLike.prototype instanceof Error || errorLike === Error) {
+  } else if ((typeof errorLike === "object" || typeof errorLike === "function") && errorLike.prototype) {
     return thrown.constructor === errorLike || thrown instanceof errorLike;
   }
   return false;
@@ -72,7 +81,7 @@ function compatibleConstructor(thrown, errorLike) {
 __name(compatibleConstructor, "compatibleConstructor");
 function compatibleMessage(thrown, errMatcher) {
   const comparisonString = typeof thrown === "string" ? thrown : thrown.message;
-  if (errMatcher instanceof RegExp) {
+  if (isRegExp(errMatcher)) {
     return errMatcher.test(comparisonString);
   } else if (typeof errMatcher === "string") {
     return comparisonString.indexOf(errMatcher) !== -1;
@@ -82,7 +91,7 @@ function compatibleMessage(thrown, errMatcher) {
 __name(compatibleMessage, "compatibleMessage");
 function getConstructorName(errorLike) {
   let constructorName = errorLike;
-  if (errorLike instanceof Error) {
+  if (isErrorInstance(errorLike)) {
     constructorName = errorLike.constructor.name;
   } else if (typeof errorLike === "function") {
     constructorName = errorLike.name;
@@ -805,8 +814,8 @@ var config = {
    *
    *     chai.config.includeStack = true;  // enable stack on error
    *
-   * @param {Boolean}
-   * @api public
+   * @param {boolean}
+   * @public
    */
   includeStack: false,
   /**
@@ -818,8 +827,8 @@ var config = {
    * will be true when the assertion has requested a diff
    * be shown.
    *
-   * @param {Boolean}
-   * @api public
+   * @param {boolean}
+   * @public
    */
   showDiff: true,
   /**
@@ -838,8 +847,8 @@ var config = {
    *
    *     chai.config.truncateThreshold = 0;  // disable truncating
    *
-   * @param {Number}
-   * @api public
+   * @param {number}
+   * @public
    */
   truncateThreshold: 40,
   /**
@@ -856,8 +865,8 @@ var config = {
    * This feature is automatically disabled regardless of this config value
    * in environments that don't support proxies.
    *
-   * @param {Boolean}
-   * @api public
+   * @param {boolean}
+   * @public
    */
   useProxy: true,
   /**
@@ -875,7 +884,7 @@ var config = {
    *     chai.config.proxyExcludedKeys = ['then', 'inspect'];
    *
    * @param {Array}
-   * @api public
+   * @public
    */
   proxyExcludedKeys: ["then", "catch", "inspect", "toJSON"],
   /**
@@ -887,18 +896,18 @@ var config = {
    *
    *     // use a custom comparator
    *     chai.config.deepEqual = (expected, actual) => {
-   *        return chai.util.eql(expected, actual, {
-   *           comparator: (expected, actual) => {
-   *              // for non number comparison, use the default behavior
-   *              if(typeof expected !== 'number') return null;
-   *              // allow a difference of 10 between compared numbers
-   *              return typeof actual === 'number' && Math.abs(actual - expected) < 10
-   *           }
-   *        })
+   *         return chai.util.eql(expected, actual, {
+   *             comparator: (expected, actual) => {
+   *                 // for non number comparison, use the default behavior
+   *                 if(typeof expected !== 'number') return null;
+   *                 // allow a difference of 10 between compared numbers
+   *                 return typeof actual === 'number' && Math.abs(actual - expected) < 10
+   *             }
+   *         })
    *     };
    *
    * @param {Function}
-   * @api public
+   * @public
    */
   deepEqual: null
 };
@@ -1809,6 +1818,10 @@ function getName(fn) {
   return fn.name;
 }
 __name(getName, "getName");
+function isRegExp2(obj) {
+  return Object.prototype.toString.call(obj) === "[object RegExp]";
+}
+__name(isRegExp2, "isRegExp");
 
 // lib/chai/core/assertions.js
 var { flag: flag2 } = utils_exports;
@@ -2659,14 +2672,16 @@ function assertThrows(errorLike, errMsgMatcher, msg) {
     flag2(this, "message", msg);
   var obj = flag2(this, "object"), ssfi = flag2(this, "ssfi"), flagMsg = flag2(this, "message"), negate = flag2(this, "negate") || false;
   new Assertion(obj, flagMsg, ssfi, true).is.a("function");
-  if (errorLike instanceof RegExp || typeof errorLike === "string") {
+  if (isRegExp2(errorLike) || typeof errorLike === "string") {
     errMsgMatcher = errorLike;
     errorLike = null;
   }
-  var caughtErr;
+  let caughtErr;
+  let errorWasThrown = false;
   try {
     obj();
   } catch (err) {
+    errorWasThrown = true;
     caughtErr = err;
   }
   var everyArgIsUndefined = errorLike === void 0 && errMsgMatcher === void 0;
@@ -2680,12 +2695,23 @@ function assertThrows(errorLike, errMsgMatcher, msg) {
     } else if (errorLike) {
       errorLikeString = check_error_exports.getConstructorName(errorLike);
     }
+    let actual = caughtErr;
+    if (caughtErr instanceof Error) {
+      actual = caughtErr.toString();
+    } else if (typeof caughtErr === "string") {
+      actual = caughtErr;
+    } else if (caughtErr && (typeof caughtErr === "object" || typeof caughtErr === "function")) {
+      try {
+        actual = check_error_exports.getConstructorName(caughtErr);
+      } catch (_err) {
+      }
+    }
     this.assert(
-      caughtErr,
+      errorWasThrown,
       "expected #{this} to throw " + errorLikeString,
       "expected #{this} to not throw an error but #{act} was thrown",
       errorLike && errorLike.toString(),
-      caughtErr instanceof Error ? caughtErr.toString() : typeof caughtErr === "string" ? caughtErr : caughtErr && check_error_exports.getConstructorName(caughtErr)
+      actual
     );
   }
   if (errorLike && caughtErr) {
@@ -2722,7 +2748,7 @@ function assertThrows(errorLike, errMsgMatcher, msg) {
   }
   if (caughtErr && errMsgMatcher !== void 0 && errMsgMatcher !== null) {
     var placeholder = "including";
-    if (errMsgMatcher instanceof RegExp) {
+    if (isRegExp2(errMsgMatcher)) {
       placeholder = "matching";
     }
     var isCompatibleMessage = check_error_exports.compatibleMessage(caughtErr, errMsgMatcher);
@@ -2810,7 +2836,9 @@ function closeTo(expected, delta, msg) {
 __name(closeTo, "closeTo");
 Assertion.addMethod("closeTo", closeTo);
 Assertion.addMethod("approximately", closeTo);
-function isSubsetOf(subset, superset, cmp, contains, ordered) {
+function isSubsetOf(_subset, _superset, cmp, contains, ordered) {
+  let superset = Array.from(_superset);
+  let subset = Array.from(_subset);
   if (!contains) {
     if (subset.length !== superset.length)
       return false;
@@ -2841,8 +2869,8 @@ Assertion.addMethod("members", function(subset, msg) {
   if (msg)
     flag2(this, "message", msg);
   var obj = flag2(this, "object"), flagMsg = flag2(this, "message"), ssfi = flag2(this, "ssfi");
-  new Assertion(obj, flagMsg, ssfi, true).to.be.an("array");
-  new Assertion(subset, flagMsg, ssfi, true).to.be.an("array");
+  new Assertion(obj, flagMsg, ssfi, true).to.be.iterable;
+  new Assertion(subset, flagMsg, ssfi, true).to.be.iterable;
   var contains = flag2(this, "contains");
   var ordered = flag2(this, "ordered");
   var subject, failMsg, failNegateMsg;
@@ -2865,6 +2893,17 @@ Assertion.addMethod("members", function(subset, msg) {
     true
   );
 });
+Assertion.addProperty("iterable", function(msg) {
+  if (msg)
+    flag2(this, "message", msg);
+  var obj = flag2(this, "object");
+  this.assert(
+    obj != void 0 && obj[Symbol.iterator],
+    "expected #{this} to be an iterable",
+    "expected #{this} to not be an iterable",
+    obj
+  );
+});
 function oneOf(list, msg) {
   if (msg)
     flag2(this, "message", msg);
@@ -3113,8 +3152,8 @@ function loadShould() {
       operator
     }, should2.fail);
   };
-  should2.equal = function(val1, val2, msg) {
-    new Assertion(val1, msg).to.equal(val2);
+  should2.equal = function(actual, expected, message) {
+    new Assertion(actual, message).to.equal(expected);
   };
   should2.Throw = function(fn, errt, errs, msg) {
     new Assertion(fn, msg).to.Throw(errt, errs);
@@ -3123,8 +3162,8 @@ function loadShould() {
     new Assertion(val, msg).to.exist;
   };
   should2.not = {};
-  should2.not.equal = function(val1, val2, msg) {
-    new Assertion(val1, msg).to.not.equal(val2);
+  should2.not.equal = function(actual, expected, msg) {
+    new Assertion(actual, msg).to.not.equal(expected);
   };
   should2.not.Throw = function(fn, errt, errs, msg) {
     new Assertion(fn, msg).to.not.Throw(errt, errs);
@@ -3235,8 +3274,8 @@ assert.isNotNull = function(val, msg) {
 assert.isNaN = function(val, msg) {
   new Assertion(val, msg, assert.isNaN, true).to.be.NaN;
 };
-assert.isNotNaN = function(val, msg) {
-  new Assertion(val, msg, assert.isNotNaN, true).not.to.be.NaN;
+assert.isNotNaN = function(value, message) {
+  new Assertion(value, message, assert.isNotNaN, true).not.to.be.NaN;
 };
 assert.exists = function(val, msg) {
   new Assertion(val, msg, assert.exists, true).to.exist;
@@ -3250,11 +3289,11 @@ assert.isUndefined = function(val, msg) {
 assert.isDefined = function(val, msg) {
   new Assertion(val, msg, assert.isDefined, true).to.not.equal(void 0);
 };
-assert.isCallable = function(val, msg) {
-  new Assertion(val, msg, assert.isCallable, true).is.callable;
+assert.isCallable = function(value, message) {
+  new Assertion(value, message, assert.isCallable, true).is.callable;
 };
-assert.isNotCallable = function(val, msg) {
-  new Assertion(val, msg, assert.isNotCallable, true).is.not.callable;
+assert.isNotCallable = function(value, message) {
+  new Assertion(value, message, assert.isNotCallable, true).is.not.callable;
 };
 assert.isObject = function(val, msg) {
   new Assertion(val, msg, assert.isObject, true).to.be.a("object");
@@ -3292,8 +3331,8 @@ assert.isNotBoolean = function(val, msg) {
 assert.typeOf = function(val, type3, msg) {
   new Assertion(val, msg, assert.typeOf, true).to.be.a(type3);
 };
-assert.notTypeOf = function(val, type3, msg) {
-  new Assertion(val, msg, assert.notTypeOf, true).to.not.be.a(type3);
+assert.notTypeOf = function(value, type3, message) {
+  new Assertion(value, message, assert.notTypeOf, true).to.not.be.a(type3);
 };
 assert.instanceOf = function(val, type3, msg) {
   new Assertion(val, msg, assert.instanceOf, true).to.be.instanceOf(type3);
@@ -3438,12 +3477,12 @@ assert.throws = function(fn, errorLike, errMsgMatcher, msg) {
   var assertErr = new Assertion(fn, msg, assert.throws, true).to.throw(errorLike, errMsgMatcher);
   return flag(assertErr, "object");
 };
-assert.doesNotThrow = function(fn, errorLike, errMsgMatcher, msg) {
+assert.doesNotThrow = function(fn, errorLike, errMsgMatcher, message) {
   if ("string" === typeof errorLike || errorLike instanceof RegExp) {
     errMsgMatcher = errorLike;
     errorLike = null;
   }
-  new Assertion(fn, msg, assert.doesNotThrow, true).to.not.throw(errorLike, errMsgMatcher);
+  new Assertion(fn, message, assert.doesNotThrow, true).to.not.throw(errorLike, errMsgMatcher);
 };
 assert.operator = function(val, operator, val2, msg) {
   var ok;
@@ -3544,6 +3583,16 @@ assert.notIncludeDeepOrderedMembers = function(superset, subset, msg) {
 assert.oneOf = function(inList, list, msg) {
   new Assertion(inList, msg, assert.oneOf, true).to.be.oneOf(list);
 };
+assert.isIterable = function(obj, msg) {
+  if (obj == void 0 || !obj[Symbol.iterator]) {
+    msg = msg ? `${msg} expected ${inspect2(obj)} to be an iterable` : `expected ${inspect2(obj)} to be an iterable`;
+    throw new AssertionError(
+      msg,
+      void 0,
+      assert.isIterable
+    );
+  }
+};
 assert.changes = function(fn, obj, prop, msg) {
   if (arguments.length === 3 && typeof obj === "function") {
     msg = prop;
@@ -3737,9 +3786,6 @@ export {
  * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
-/*!
- * Module dependencies
- */
 /*!
  * Chai - expectTypes utility
  * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
@@ -3766,52 +3812,6 @@ export {
  * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
-/*!
- * Assertion Constructor
- *
- * Creates object for chaining.
- *
- * `Assertion` objects contain metadata in the form of flags. Three flags can
- * be assigned during instantiation by passing arguments to this constructor:
- *
- * - `object`: This flag contains the target of the assertion. For example, in
- *   the assertion `expect(numKittens).to.equal(7);`, the `object` flag will
- *   contain `numKittens` so that the `equal` assertion can reference it when
- *   needed.
- *
- * - `message`: This flag contains an optional custom error message to be
- *   prepended to the error message that's generated by the assertion when it
- *   fails.
- *
- * - `ssfi`: This flag stands for "start stack function indicator". It
- *   contains a function reference that serves as the starting point for
- *   removing frames from the stack trace of the error that's created by the
- *   assertion when it fails. The goal is to provide a cleaner stack trace to
- *   end users by removing Chai's internal functions. Note that it only works
- *   in environments that support `Error.captureStackTrace`, and only when
- *   `Chai.config.includeStack` hasn't been set to `false`.
- *
- * - `lockSsfi`: This flag controls whether or not the given `ssfi` flag
- *   should retain its current value, even as assertions are chained off of
- *   this object. This is usually set to `true` when creating a new assertion
- *   from within another assertion. It's also temporarily set to `true` before
- *   an overwritten assertion gets called by the overwriting assertion.
- *
- * - `eql`: This flag contains the deepEqual function to be used by the assertion.
- *
- * @param {Mixed} obj target of the assertion
- * @param {String} msg (optional) custom error message
- * @param {Function} ssfi (optional) starting point for removing stack frames
- * @param {Boolean} lockSsfi (optional) whether or not the ssfi flag is locked
- * @api private
- */
-/*!
- * ### ._obj
- *
- * Quick reference to stored `actual` value for plugin developers.
- *
- * @api private
- */
 /*!
  * Chai - isProxyEnabled helper
  * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
@@ -3857,9 +3857,6 @@ export {
  * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
-/*!
- * Module variables
- */
 /*!
  * Chai - overwriteChainableMethod utility
  * Copyright(c) 2012-2014 Jake Luer <jake@alogicalparadox.com>
@@ -3890,134 +3887,11 @@ export {
  * Copyright(c) 2011 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
-/*!
- * Dependencies that are used for multiple exports are required here only once
- */
-/*!
- * test utility
- */
-/*!
- * type utility
- */
-/*!
- * expectTypes utility
- */
-/*!
- * message utility
- */
-/*!
- * actual utility
- */
-/*!
- * Inspect util
- */
-/*!
- * Object Display util
- */
-/*!
- * Flag utility
- */
-/*!
- * Flag transferring utility
- */
-/*!
- * Deep equal utility
- */
-/*!
- * Deep path info
- */
-/*!
- * Function name
- */
-/*!
- * add Property
- */
-/*!
- * add Method
- */
-/*!
- * overwrite Property
- */
-/*!
- * overwrite Method
- */
-/*!
- * Add a chainable method
- */
-/*!
- * Overwrite chainable method
- */
-/*!
- * Compare by inspect method
- */
-/*!
- * Get own enumerable property symbols method
- */
-/*!
- * Get own enumerable properties method
- */
-/*!
- * Checks error against a given set of criteria
- */
-/*!
- * Proxify util
- */
-/*!
- * addLengthGuard util
- */
-/*!
- * isProxyEnabled helper
- */
-/*!
- * isNaN method
- */
-/*!
- * getOperator method
- */
 /*!
  * chai
  * Copyright(c) 2011-2014 Jake Luer <jake@alogicalparadox.com>
  * MIT Licensed
  */
-/*!
- * ### .ifError(object)
- *
- * Asserts if value is not a false value, and throws if it is a true value.
- * This is added to allow for chai to be a drop-in replacement for Node's
- * assert class.
- *
- *     var err = new Error('I am a custom error');
- *     assert.ifError(err); // Rethrows err!
- *
- * @name ifError
- * @param {Object} object
- * @namespace Assert
- * @api public
- */
-/*!
- * Aliases.
- */
-/*!
- * Assertion Error
- */
-/*!
- * Utility Functions
- */
-/*!
- * Configuration
- */
-/*!
- * Primary `Assertion` prototype
- */
-/*!
- * Expect interface
- */
-/*!
- * Should interface
- */
-/*!
- * Assert interface
- */
 /*! Bundled license information:
 
 deep-eql/index.js:

package/eslint.config.js

@@ -0,0 +1,12 @@
+import jsdoc from "eslint-plugin-jsdoc";
+
+export default [
+  jsdoc.configs["flat/recommended"],
+  {
+    rules: {
+      "jsdoc/require-param-description": "off",
+      "jsdoc/require-returns-description": "off",
+      "jsdoc/tag-lines": ["error", "any", { startLines: 1 }],
+    },
+  },
+];

package/lib/chai/assertion.js

@@ -9,7 +9,7 @@ import {config} from './config.js';
 import {AssertionError} from 'assertion-error';
 import * as util from './utils/index.js';
 
-/*!
+/**
  * Assertion Constructor
  *
  * Creates object for chaining.
@@ -18,37 +18,37 @@ import * as util from './utils/index.js';
  * be assigned during instantiation by passing arguments to this constructor:
  *
  * - `object`: This flag contains the target of the assertion. For example, in
- *   the assertion `expect(numKittens).to.equal(7);`, the `object` flag will
- *   contain `numKittens` so that the `equal` assertion can reference it when
- *   needed.
+ * the assertion `expect(numKittens).to.equal(7);`, the `object` flag will
+ * contain `numKittens` so that the `equal` assertion can reference it when
+ * needed.
  *
  * - `message`: This flag contains an optional custom error message to be
- *   prepended to the error message that's generated by the assertion when it
- *   fails.
+ * prepended to the error message that's generated by the assertion when it
+ * fails.
  *
  * - `ssfi`: This flag stands for "start stack function indicator". It
- *   contains a function reference that serves as the starting point for
- *   removing frames from the stack trace of the error that's created by the
- *   assertion when it fails. The goal is to provide a cleaner stack trace to
- *   end users by removing Chai's internal functions. Note that it only works
- *   in environments that support `Error.captureStackTrace`, and only when
- *   `Chai.config.includeStack` hasn't been set to `false`.
+ * contains a function reference that serves as the starting point for
+ * removing frames from the stack trace of the error that's created by the
+ * assertion when it fails. The goal is to provide a cleaner stack trace to
+ * end users by removing Chai's internal functions. Note that it only works
+ * in environments that support `Error.captureStackTrace`, and only when
+ * `Chai.config.includeStack` hasn't been set to `false`.
  *
  * - `lockSsfi`: This flag controls whether or not the given `ssfi` flag
- *   should retain its current value, even as assertions are chained off of
- *   this object. This is usually set to `true` when creating a new assertion
- *   from within another assertion. It's also temporarily set to `true` before
- *   an overwritten assertion gets called by the overwriting assertion.
+ * should retain its current value, even as assertions are chained off of
+ * this object. This is usually set to `true` when creating a new assertion
+ * from within another assertion. It's also temporarily set to `true` before
+ * an overwritten assertion gets called by the overwriting assertion.
  *
  * - `eql`: This flag contains the deepEqual function to be used by the assertion.
  *
- * @param {Mixed} obj target of the assertion
- * @param {String} msg (optional) custom error message
+ * @param {unknown} obj target of the assertion
+ * @param {string} msg (optional) custom error message
  * @param {Function} ssfi (optional) starting point for removing stack frames
- * @param {Boolean} lockSsfi (optional) whether or not the ssfi flag is locked
- * @api private
+ * @param {boolean} lockSsfi (optional) whether or not the ssfi flag is locked
+ * @returns {unknown}
+ * @private
  */
-
 export function Assertion (obj, msg, ssfi, lockSsfi) {
   util.flag(this, 'ssfi', ssfi || Assertion);
   util.flag(this, 'lockSsfi', lockSsfi);
@@ -111,13 +111,13 @@ Assertion.overwriteChainableMethod = function (name, fn, chainingBehavior) {
  * Executes an expression and check expectations. Throws AssertionError for reporting if test doesn't pass.
  *
  * @name assert
- * @param {Philosophical} expression to be tested
- * @param {String|Function} message or function that returns message to display if expression fails
- * @param {String|Function} negatedMessage or function that returns negatedMessage to display if negated expression fails
- * @param {Mixed} expected value (remember to check for negation)
- * @param {Mixed} actual (optional) will default to `this.obj`
- * @param {Boolean} showDiff (optional) when set to `true`, assert will display a diff in addition to the message if expression fails
- * @api private
+ * @param {unknown} expression to be tested
+ * @param {string | Function} message or function that returns message to display if expression fails
+ * @param {string | Function} negatedMessage or function that returns negatedMessage to display if negated expression fails
+ * @param {unknown} expected value (remember to check for negation)
+ * @param {unknown} actual (optional) will default to `this.obj`
+ * @param {boolean} showDiff (optional) when set to `true`, assert will display a diff in addition to the message if expression fails
+ * @private
  */
 
 Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual, showDiff) {
@@ -147,14 +147,13 @@ Assertion.prototype.assert = function (expr, msg, negateMsg, expected, _actual,
   }
 };
 
-/*!
+/**
  * ### ._obj
  *
  * Quick reference to stored `actual` value for plugin developers.
  *
- * @api private
+ * @private
  */
-
 Object.defineProperty(Assertion.prototype, '_obj',
   { get: function () {
       return util.flag(this, 'object');