summaryrefslogtreecommitdiff
path: root/src/node_modules/assert/build/internal
diff options
context:
space:
mode:
Diffstat (limited to 'src/node_modules/assert/build/internal')
-rw-r--r--src/node_modules/assert/build/internal/assert/assertion_error.js501
-rw-r--r--src/node_modules/assert/build/internal/errors.js195
-rw-r--r--src/node_modules/assert/build/internal/util/comparisons.js688
3 files changed, 1384 insertions, 0 deletions
diff --git a/src/node_modules/assert/build/internal/assert/assertion_error.js b/src/node_modules/assert/build/internal/assert/assertion_error.js
new file mode 100644
index 0000000..9295f0a
--- /dev/null
+++ b/src/node_modules/assert/build/internal/assert/assertion_error.js
@@ -0,0 +1,501 @@
+// Currently in sync with Node.js lib/internal/assert/assertion_error.js
+// https://github.com/nodejs/node/commit/0817840f775032169ddd70c85ac059f18ffcc81c
+'use strict';
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
+
+function isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+
+function _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }
+
+function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var _require = require('util/'),
+ inspect = _require.inspect;
+
+var _require2 = require('../errors'),
+ ERR_INVALID_ARG_TYPE = _require2.codes.ERR_INVALID_ARG_TYPE; // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
+
+
+function endsWith(str, search, this_len) {
+ if (this_len === undefined || this_len > str.length) {
+ this_len = str.length;
+ }
+
+ return str.substring(this_len - search.length, this_len) === search;
+} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat
+
+
+function repeat(str, count) {
+ count = Math.floor(count);
+ if (str.length == 0 || count == 0) return '';
+ var maxCount = str.length * count;
+ count = Math.floor(Math.log(count) / Math.log(2));
+
+ while (count) {
+ str += str;
+ count--;
+ }
+
+ str += str.substring(0, maxCount - str.length);
+ return str;
+}
+
+var blue = '';
+var green = '';
+var red = '';
+var white = '';
+var kReadableOperator = {
+ deepStrictEqual: 'Expected values to be strictly deep-equal:',
+ strictEqual: 'Expected values to be strictly equal:',
+ strictEqualObject: 'Expected "actual" to be reference-equal to "expected":',
+ deepEqual: 'Expected values to be loosely deep-equal:',
+ equal: 'Expected values to be loosely equal:',
+ notDeepStrictEqual: 'Expected "actual" not to be strictly deep-equal to:',
+ notStrictEqual: 'Expected "actual" to be strictly unequal to:',
+ notStrictEqualObject: 'Expected "actual" not to be reference-equal to "expected":',
+ notDeepEqual: 'Expected "actual" not to be loosely deep-equal to:',
+ notEqual: 'Expected "actual" to be loosely unequal to:',
+ notIdentical: 'Values identical but not reference-equal:'
+}; // Comparing short primitives should just show === / !== instead of using the
+// diff.
+
+var kMaxShortLength = 10;
+
+function copyError(source) {
+ var keys = Object.keys(source);
+ var target = Object.create(Object.getPrototypeOf(source));
+ keys.forEach(function (key) {
+ target[key] = source[key];
+ });
+ Object.defineProperty(target, 'message', {
+ value: source.message
+ });
+ return target;
+}
+
+function inspectValue(val) {
+ // The util.inspect default values could be changed. This makes sure the
+ // error messages contain the necessary information nevertheless.
+ return inspect(val, {
+ compact: false,
+ customInspect: false,
+ depth: 1000,
+ maxArrayLength: Infinity,
+ // Assert compares only enumerable properties (with a few exceptions).
+ showHidden: false,
+ // Having a long line as error is better than wrapping the line for
+ // comparison for now.
+ // TODO(BridgeAR): `breakLength` should be limited as soon as soon as we
+ // have meta information about the inspected properties (i.e., know where
+ // in what line the property starts and ends).
+ breakLength: Infinity,
+ // Assert does not detect proxies currently.
+ showProxy: false,
+ sorted: true,
+ // Inspect getters as we also check them when comparing entries.
+ getters: true
+ });
+}
+
+function createErrDiff(actual, expected, operator) {
+ var other = '';
+ var res = '';
+ var lastPos = 0;
+ var end = '';
+ var skipped = false;
+ var actualInspected = inspectValue(actual);
+ var actualLines = actualInspected.split('\n');
+ var expectedLines = inspectValue(expected).split('\n');
+ var i = 0;
+ var indicator = ''; // In case both values are objects explicitly mark them as not reference equal
+ // for the `strictEqual` operator.
+
+ if (operator === 'strictEqual' && _typeof(actual) === 'object' && _typeof(expected) === 'object' && actual !== null && expected !== null) {
+ operator = 'strictEqualObject';
+ } // If "actual" and "expected" fit on a single line and they are not strictly
+ // equal, check further special handling.
+
+
+ if (actualLines.length === 1 && expectedLines.length === 1 && actualLines[0] !== expectedLines[0]) {
+ var inputLength = actualLines[0].length + expectedLines[0].length; // If the character length of "actual" and "expected" together is less than
+ // kMaxShortLength and if neither is an object and at least one of them is
+ // not `zero`, use the strict equal comparison to visualize the output.
+
+ if (inputLength <= kMaxShortLength) {
+ if ((_typeof(actual) !== 'object' || actual === null) && (_typeof(expected) !== 'object' || expected === null) && (actual !== 0 || expected !== 0)) {
+ // -0 === +0
+ return "".concat(kReadableOperator[operator], "\n\n") + "".concat(actualLines[0], " !== ").concat(expectedLines[0], "\n");
+ }
+ } else if (operator !== 'strictEqualObject') {
+ // If the stderr is a tty and the input length is lower than the current
+ // columns per line, add a mismatch indicator below the output. If it is
+ // not a tty, use a default value of 80 characters.
+ var maxLength = process.stderr && process.stderr.isTTY ? process.stderr.columns : 80;
+
+ if (inputLength < maxLength) {
+ while (actualLines[0][i] === expectedLines[0][i]) {
+ i++;
+ } // Ignore the first characters.
+
+
+ if (i > 2) {
+ // Add position indicator for the first mismatch in case it is a
+ // single line and the input length is less than the column length.
+ indicator = "\n ".concat(repeat(' ', i), "^");
+ i = 0;
+ }
+ }
+ }
+ } // Remove all ending lines that match (this optimizes the output for
+ // readability by reducing the number of total changed lines).
+
+
+ var a = actualLines[actualLines.length - 1];
+ var b = expectedLines[expectedLines.length - 1];
+
+ while (a === b) {
+ if (i++ < 2) {
+ end = "\n ".concat(a).concat(end);
+ } else {
+ other = a;
+ }
+
+ actualLines.pop();
+ expectedLines.pop();
+ if (actualLines.length === 0 || expectedLines.length === 0) break;
+ a = actualLines[actualLines.length - 1];
+ b = expectedLines[expectedLines.length - 1];
+ }
+
+ var maxLines = Math.max(actualLines.length, expectedLines.length); // Strict equal with identical objects that are not identical by reference.
+ // E.g., assert.deepStrictEqual({ a: Symbol() }, { a: Symbol() })
+
+ if (maxLines === 0) {
+ // We have to get the result again. The lines were all removed before.
+ var _actualLines = actualInspected.split('\n'); // Only remove lines in case it makes sense to collapse those.
+ // TODO: Accept env to always show the full error.
+
+
+ if (_actualLines.length > 30) {
+ _actualLines[26] = "".concat(blue, "...").concat(white);
+
+ while (_actualLines.length > 27) {
+ _actualLines.pop();
+ }
+ }
+
+ return "".concat(kReadableOperator.notIdentical, "\n\n").concat(_actualLines.join('\n'), "\n");
+ }
+
+ if (i > 3) {
+ end = "\n".concat(blue, "...").concat(white).concat(end);
+ skipped = true;
+ }
+
+ if (other !== '') {
+ end = "\n ".concat(other).concat(end);
+ other = '';
+ }
+
+ var printedLines = 0;
+ var msg = kReadableOperator[operator] + "\n".concat(green, "+ actual").concat(white, " ").concat(red, "- expected").concat(white);
+ var skippedMsg = " ".concat(blue, "...").concat(white, " Lines skipped");
+
+ for (i = 0; i < maxLines; i++) {
+ // Only extra expected lines exist
+ var cur = i - lastPos;
+
+ if (actualLines.length < i + 1) {
+ // If the last diverging line is more than one line above and the
+ // current line is at least line three, add some of the former lines and
+ // also add dots to indicate skipped entries.
+ if (cur > 1 && i > 2) {
+ if (cur > 4) {
+ res += "\n".concat(blue, "...").concat(white);
+ skipped = true;
+ } else if (cur > 3) {
+ res += "\n ".concat(expectedLines[i - 2]);
+ printedLines++;
+ }
+
+ res += "\n ".concat(expectedLines[i - 1]);
+ printedLines++;
+ } // Mark the current line as the last diverging one.
+
+
+ lastPos = i; // Add the expected line to the cache.
+
+ other += "\n".concat(red, "-").concat(white, " ").concat(expectedLines[i]);
+ printedLines++; // Only extra actual lines exist
+ } else if (expectedLines.length < i + 1) {
+ // If the last diverging line is more than one line above and the
+ // current line is at least line three, add some of the former lines and
+ // also add dots to indicate skipped entries.
+ if (cur > 1 && i > 2) {
+ if (cur > 4) {
+ res += "\n".concat(blue, "...").concat(white);
+ skipped = true;
+ } else if (cur > 3) {
+ res += "\n ".concat(actualLines[i - 2]);
+ printedLines++;
+ }
+
+ res += "\n ".concat(actualLines[i - 1]);
+ printedLines++;
+ } // Mark the current line as the last diverging one.
+
+
+ lastPos = i; // Add the actual line to the result.
+
+ res += "\n".concat(green, "+").concat(white, " ").concat(actualLines[i]);
+ printedLines++; // Lines diverge
+ } else {
+ var expectedLine = expectedLines[i];
+ var actualLine = actualLines[i]; // If the lines diverge, specifically check for lines that only diverge by
+ // a trailing comma. In that case it is actually identical and we should
+ // mark it as such.
+
+ var divergingLines = actualLine !== expectedLine && (!endsWith(actualLine, ',') || actualLine.slice(0, -1) !== expectedLine); // If the expected line has a trailing comma but is otherwise identical,
+ // add a comma at the end of the actual line. Otherwise the output could
+ // look weird as in:
+ //
+ // [
+ // 1 // No comma at the end!
+ // + 2
+ // ]
+ //
+
+ if (divergingLines && endsWith(expectedLine, ',') && expectedLine.slice(0, -1) === actualLine) {
+ divergingLines = false;
+ actualLine += ',';
+ }
+
+ if (divergingLines) {
+ // If the last diverging line is more than one line above and the
+ // current line is at least line three, add some of the former lines and
+ // also add dots to indicate skipped entries.
+ if (cur > 1 && i > 2) {
+ if (cur > 4) {
+ res += "\n".concat(blue, "...").concat(white);
+ skipped = true;
+ } else if (cur > 3) {
+ res += "\n ".concat(actualLines[i - 2]);
+ printedLines++;
+ }
+
+ res += "\n ".concat(actualLines[i - 1]);
+ printedLines++;
+ } // Mark the current line as the last diverging one.
+
+
+ lastPos = i; // Add the actual line to the result and cache the expected diverging
+ // line so consecutive diverging lines show up as +++--- and not +-+-+-.
+
+ res += "\n".concat(green, "+").concat(white, " ").concat(actualLine);
+ other += "\n".concat(red, "-").concat(white, " ").concat(expectedLine);
+ printedLines += 2; // Lines are identical
+ } else {
+ // Add all cached information to the result before adding other things
+ // and reset the cache.
+ res += other;
+ other = ''; // If the last diverging line is exactly one line above or if it is the
+ // very first line, add the line to the result.
+
+ if (cur === 1 || i === 0) {
+ res += "\n ".concat(actualLine);
+ printedLines++;
+ }
+ }
+ } // Inspected object to big (Show ~20 rows max)
+
+
+ if (printedLines > 20 && i < maxLines - 2) {
+ return "".concat(msg).concat(skippedMsg, "\n").concat(res, "\n").concat(blue, "...").concat(white).concat(other, "\n") + "".concat(blue, "...").concat(white);
+ }
+ }
+
+ return "".concat(msg).concat(skipped ? skippedMsg : '', "\n").concat(res).concat(other).concat(end).concat(indicator);
+}
+
+var AssertionError =
+/*#__PURE__*/
+function (_Error) {
+ _inherits(AssertionError, _Error);
+
+ function AssertionError(options) {
+ var _this;
+
+ _classCallCheck(this, AssertionError);
+
+ if (_typeof(options) !== 'object' || options === null) {
+ throw new ERR_INVALID_ARG_TYPE('options', 'Object', options);
+ }
+
+ var message = options.message,
+ operator = options.operator,
+ stackStartFn = options.stackStartFn;
+ var actual = options.actual,
+ expected = options.expected;
+ var limit = Error.stackTraceLimit;
+ Error.stackTraceLimit = 0;
+
+ if (message != null) {
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, String(message)));
+ } else {
+ if (process.stderr && process.stderr.isTTY) {
+ // Reset on each call to make sure we handle dynamically set environment
+ // variables correct.
+ if (process.stderr && process.stderr.getColorDepth && process.stderr.getColorDepth() !== 1) {
+ blue = "\x1B[34m";
+ green = "\x1B[32m";
+ white = "\x1B[39m";
+ red = "\x1B[31m";
+ } else {
+ blue = '';
+ green = '';
+ white = '';
+ red = '';
+ }
+ } // Prevent the error stack from being visible by duplicating the error
+ // in a very close way to the original in case both sides are actually
+ // instances of Error.
+
+
+ if (_typeof(actual) === 'object' && actual !== null && _typeof(expected) === 'object' && expected !== null && 'stack' in actual && actual instanceof Error && 'stack' in expected && expected instanceof Error) {
+ actual = copyError(actual);
+ expected = copyError(expected);
+ }
+
+ if (operator === 'deepStrictEqual' || operator === 'strictEqual') {
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, createErrDiff(actual, expected, operator)));
+ } else if (operator === 'notDeepStrictEqual' || operator === 'notStrictEqual') {
+ // In case the objects are equal but the operator requires unequal, show
+ // the first object and say A equals B
+ var base = kReadableOperator[operator];
+ var res = inspectValue(actual).split('\n'); // In case "actual" is an object, it should not be reference equal.
+
+ if (operator === 'notStrictEqual' && _typeof(actual) === 'object' && actual !== null) {
+ base = kReadableOperator.notStrictEqualObject;
+ } // Only remove lines in case it makes sense to collapse those.
+ // TODO: Accept env to always show the full error.
+
+
+ if (res.length > 30) {
+ res[26] = "".concat(blue, "...").concat(white);
+
+ while (res.length > 27) {
+ res.pop();
+ }
+ } // Only print a single input.
+
+
+ if (res.length === 1) {
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, "".concat(base, " ").concat(res[0])));
+ } else {
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, "".concat(base, "\n\n").concat(res.join('\n'), "\n")));
+ }
+ } else {
+ var _res = inspectValue(actual);
+
+ var other = '';
+ var knownOperators = kReadableOperator[operator];
+
+ if (operator === 'notDeepEqual' || operator === 'notEqual') {
+ _res = "".concat(kReadableOperator[operator], "\n\n").concat(_res);
+
+ if (_res.length > 1024) {
+ _res = "".concat(_res.slice(0, 1021), "...");
+ }
+ } else {
+ other = "".concat(inspectValue(expected));
+
+ if (_res.length > 512) {
+ _res = "".concat(_res.slice(0, 509), "...");
+ }
+
+ if (other.length > 512) {
+ other = "".concat(other.slice(0, 509), "...");
+ }
+
+ if (operator === 'deepEqual' || operator === 'equal') {
+ _res = "".concat(knownOperators, "\n\n").concat(_res, "\n\nshould equal\n\n");
+ } else {
+ other = " ".concat(operator, " ").concat(other);
+ }
+ }
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, "".concat(_res).concat(other)));
+ }
+ }
+
+ Error.stackTraceLimit = limit;
+ _this.generatedMessage = !message;
+ Object.defineProperty(_assertThisInitialized(_this), 'name', {
+ value: 'AssertionError [ERR_ASSERTION]',
+ enumerable: false,
+ writable: true,
+ configurable: true
+ });
+ _this.code = 'ERR_ASSERTION';
+ _this.actual = actual;
+ _this.expected = expected;
+ _this.operator = operator;
+
+ if (Error.captureStackTrace) {
+ // eslint-disable-next-line no-restricted-syntax
+ Error.captureStackTrace(_assertThisInitialized(_this), stackStartFn);
+ } // Create error message including the error code in the name.
+
+
+ _this.stack; // Reset the name.
+
+ _this.name = 'AssertionError';
+ return _possibleConstructorReturn(_this);
+ }
+
+ _createClass(AssertionError, [{
+ key: "toString",
+ value: function toString() {
+ return "".concat(this.name, " [").concat(this.code, "]: ").concat(this.message);
+ }
+ }, {
+ key: inspect.custom,
+ value: function value(recurseTimes, ctx) {
+ // This limits the `actual` and `expected` property default inspection to
+ // the minimum depth. Otherwise those values would be too verbose compared
+ // to the actual error message which contains a combined view of these two
+ // input values.
+ return inspect(this, _objectSpread({}, ctx, {
+ customInspect: false,
+ depth: 0
+ }));
+ }
+ }]);
+
+ return AssertionError;
+}(_wrapNativeSuper(Error));
+
+module.exports = AssertionError; \ No newline at end of file
diff --git a/src/node_modules/assert/build/internal/errors.js b/src/node_modules/assert/build/internal/errors.js
new file mode 100644
index 0000000..3f4350a
--- /dev/null
+++ b/src/node_modules/assert/build/internal/errors.js
@@ -0,0 +1,195 @@
+// Currently in sync with Node.js lib/internal/errors.js
+// https://github.com/nodejs/node/commit/3b044962c48fe313905877a96b5d0894a5404f6f
+
+/* eslint node-core/documented-errors: "error" */
+
+/* eslint node-core/alphabetize-errors: "error" */
+
+/* eslint node-core/prefer-util-format-errors: "error" */
+'use strict'; // The whole point behind this internal module is to allow Node.js to no
+// longer be forced to treat every error message change as a semver-major
+// change. The NodeError classes here all expose a `code` property whose
+// value statically and permanently identifies the error. While the error
+// message may change, the code should not.
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+var codes = {}; // Lazy loaded
+
+var assert;
+var util;
+
+function createErrorType(code, message, Base) {
+ if (!Base) {
+ Base = Error;
+ }
+
+ function getMessage(arg1, arg2, arg3) {
+ if (typeof message === 'string') {
+ return message;
+ } else {
+ return message(arg1, arg2, arg3);
+ }
+ }
+
+ var NodeError =
+ /*#__PURE__*/
+ function (_Base) {
+ _inherits(NodeError, _Base);
+
+ function NodeError(arg1, arg2, arg3) {
+ var _this;
+
+ _classCallCheck(this, NodeError);
+
+ _this = _possibleConstructorReturn(this, _getPrototypeOf(NodeError).call(this, getMessage(arg1, arg2, arg3)));
+ _this.code = code;
+ return _this;
+ }
+
+ return NodeError;
+ }(Base);
+
+ codes[code] = NodeError;
+} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
+
+
+function oneOf(expected, thing) {
+ if (Array.isArray(expected)) {
+ var len = expected.length;
+ expected = expected.map(function (i) {
+ return String(i);
+ });
+
+ if (len > 2) {
+ return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(', '), ", or ") + expected[len - 1];
+ } else if (len === 2) {
+ return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
+ } else {
+ return "of ".concat(thing, " ").concat(expected[0]);
+ }
+ } else {
+ return "of ".concat(thing, " ").concat(String(expected));
+ }
+} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
+
+
+function startsWith(str, search, pos) {
+ return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
+} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
+
+
+function endsWith(str, search, this_len) {
+ if (this_len === undefined || this_len > str.length) {
+ this_len = str.length;
+ }
+
+ return str.substring(this_len - search.length, this_len) === search;
+} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
+
+
+function includes(str, search, start) {
+ if (typeof start !== 'number') {
+ start = 0;
+ }
+
+ if (start + search.length > str.length) {
+ return false;
+ } else {
+ return str.indexOf(search, start) !== -1;
+ }
+}
+
+createErrorType('ERR_AMBIGUOUS_ARGUMENT', 'The "%s" argument is ambiguous. %s', TypeError);
+createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
+ if (assert === undefined) assert = require('../assert');
+ assert(typeof name === 'string', "'name' must be a string"); // determiner: 'must be' or 'must not be'
+
+ var determiner;
+
+ if (typeof expected === 'string' && startsWith(expected, 'not ')) {
+ determiner = 'must not be';
+ expected = expected.replace(/^not /, '');
+ } else {
+ determiner = 'must be';
+ }
+
+ var msg;
+
+ if (endsWith(name, ' argument')) {
+ // For cases like 'first argument'
+ msg = "The ".concat(name, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
+ } else {
+ var type = includes(name, '.') ? 'property' : 'argument';
+ msg = "The \"".concat(name, "\" ").concat(type, " ").concat(determiner, " ").concat(oneOf(expected, 'type'));
+ } // TODO(BridgeAR): Improve the output by showing `null` and similar.
+
+
+ msg += ". Received type ".concat(_typeof(actual));
+ return msg;
+}, TypeError);
+createErrorType('ERR_INVALID_ARG_VALUE', function (name, value) {
+ var reason = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'is invalid';
+ if (util === undefined) util = require('util/');
+ var inspected = util.inspect(value);
+
+ if (inspected.length > 128) {
+ inspected = "".concat(inspected.slice(0, 128), "...");
+ }
+
+ return "The argument '".concat(name, "' ").concat(reason, ". Received ").concat(inspected);
+}, TypeError, RangeError);
+createErrorType('ERR_INVALID_RETURN_VALUE', function (input, name, value) {
+ var type;
+
+ if (value && value.constructor && value.constructor.name) {
+ type = "instance of ".concat(value.constructor.name);
+ } else {
+ type = "type ".concat(_typeof(value));
+ }
+
+ return "Expected ".concat(input, " to be returned from the \"").concat(name, "\"") + " function but got ".concat(type, ".");
+}, TypeError);
+createErrorType('ERR_MISSING_ARGS', function () {
+ for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+ args[_key] = arguments[_key];
+ }
+
+ if (assert === undefined) assert = require('../assert');
+ assert(args.length > 0, 'At least one arg needs to be specified');
+ var msg = 'The ';
+ var len = args.length;
+ args = args.map(function (a) {
+ return "\"".concat(a, "\"");
+ });
+
+ switch (len) {
+ case 1:
+ msg += "".concat(args[0], " argument");
+ break;
+
+ case 2:
+ msg += "".concat(args[0], " and ").concat(args[1], " arguments");
+ break;
+
+ default:
+ msg += args.slice(0, len - 1).join(', ');
+ msg += ", and ".concat(args[len - 1], " arguments");
+ break;
+ }
+
+ return "".concat(msg, " must be specified");
+}, TypeError);
+module.exports.codes = codes; \ No newline at end of file
diff --git a/src/node_modules/assert/build/internal/util/comparisons.js b/src/node_modules/assert/build/internal/util/comparisons.js
new file mode 100644
index 0000000..31d43ff
--- /dev/null
+++ b/src/node_modules/assert/build/internal/util/comparisons.js
@@ -0,0 +1,688 @@
+// Currently in sync with Node.js lib/internal/util/comparisons.js
+// https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9
+'use strict';
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+
+function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+var regexFlagsSupported = /a/g.flags !== undefined;
+
+var arrayFromSet = function arrayFromSet(set) {
+ var array = [];
+ set.forEach(function (value) {
+ return array.push(value);
+ });
+ return array;
+};
+
+var arrayFromMap = function arrayFromMap(map) {
+ var array = [];
+ map.forEach(function (value, key) {
+ return array.push([key, value]);
+ });
+ return array;
+};
+
+var objectIs = Object.is ? Object.is : require('object-is');
+var objectGetOwnPropertySymbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols : function () {
+ return [];
+};
+var numberIsNaN = Number.isNaN ? Number.isNaN : require('is-nan');
+
+function uncurryThis(f) {
+ return f.call.bind(f);
+}
+
+var hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);
+var propertyIsEnumerable = uncurryThis(Object.prototype.propertyIsEnumerable);
+var objectToString = uncurryThis(Object.prototype.toString);
+
+var _require$types = require('util/').types,
+ isAnyArrayBuffer = _require$types.isAnyArrayBuffer,
+ isArrayBufferView = _require$types.isArrayBufferView,
+ isDate = _require$types.isDate,
+ isMap = _require$types.isMap,
+ isRegExp = _require$types.isRegExp,
+ isSet = _require$types.isSet,
+ isNativeError = _require$types.isNativeError,
+ isBoxedPrimitive = _require$types.isBoxedPrimitive,
+ isNumberObject = _require$types.isNumberObject,
+ isStringObject = _require$types.isStringObject,
+ isBooleanObject = _require$types.isBooleanObject,
+ isBigIntObject = _require$types.isBigIntObject,
+ isSymbolObject = _require$types.isSymbolObject,
+ isFloat32Array = _require$types.isFloat32Array,
+ isFloat64Array = _require$types.isFloat64Array;
+
+function isNonIndex(key) {
+ if (key.length === 0 || key.length > 10) return true;
+
+ for (var i = 0; i < key.length; i++) {
+ var code = key.charCodeAt(i);
+ if (code < 48 || code > 57) return true;
+ } // The maximum size for an array is 2 ** 32 -1.
+
+
+ return key.length === 10 && key >= Math.pow(2, 32);
+}
+
+function getOwnNonIndexProperties(value) {
+ return Object.keys(value).filter(isNonIndex).concat(objectGetOwnPropertySymbols(value).filter(Object.prototype.propertyIsEnumerable.bind(value)));
+} // Taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js
+// original notice:
+
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ * @license MIT
+ */
+
+
+function compare(a, b) {
+ if (a === b) {
+ return 0;
+ }
+
+ var x = a.length;
+ var y = b.length;
+
+ for (var i = 0, len = Math.min(x, y); i < len; ++i) {
+ if (a[i] !== b[i]) {
+ x = a[i];
+ y = b[i];
+ break;
+ }
+ }
+
+ if (x < y) {
+ return -1;
+ }
+
+ if (y < x) {
+ return 1;
+ }
+
+ return 0;
+}
+
+var ONLY_ENUMERABLE = undefined;
+var kStrict = true;
+var kLoose = false;
+var kNoIterator = 0;
+var kIsArray = 1;
+var kIsSet = 2;
+var kIsMap = 3; // Check if they have the same source and flags
+
+function areSimilarRegExps(a, b) {
+ return regexFlagsSupported ? a.source === b.source && a.flags === b.flags : RegExp.prototype.toString.call(a) === RegExp.prototype.toString.call(b);
+}
+
+function areSimilarFloatArrays(a, b) {
+ if (a.byteLength !== b.byteLength) {
+ return false;
+ }
+
+ for (var offset = 0; offset < a.byteLength; offset++) {
+ if (a[offset] !== b[offset]) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+function areSimilarTypedArrays(a, b) {
+ if (a.byteLength !== b.byteLength) {
+ return false;
+ }
+
+ return compare(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), new Uint8Array(b.buffer, b.byteOffset, b.byteLength)) === 0;
+}
+
+function areEqualArrayBuffers(buf1, buf2) {
+ return buf1.byteLength === buf2.byteLength && compare(new Uint8Array(buf1), new Uint8Array(buf2)) === 0;
+}
+
+function isEqualBoxedPrimitive(val1, val2) {
+ if (isNumberObject(val1)) {
+ return isNumberObject(val2) && objectIs(Number.prototype.valueOf.call(val1), Number.prototype.valueOf.call(val2));
+ }
+
+ if (isStringObject(val1)) {
+ return isStringObject(val2) && String.prototype.valueOf.call(val1) === String.prototype.valueOf.call(val2);
+ }
+
+ if (isBooleanObject(val1)) {
+ return isBooleanObject(val2) && Boolean.prototype.valueOf.call(val1) === Boolean.prototype.valueOf.call(val2);
+ }
+
+ if (isBigIntObject(val1)) {
+ return isBigIntObject(val2) && BigInt.prototype.valueOf.call(val1) === BigInt.prototype.valueOf.call(val2);
+ }
+
+ return isSymbolObject(val2) && Symbol.prototype.valueOf.call(val1) === Symbol.prototype.valueOf.call(val2);
+} // 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 innerDeepEqual(val1, val2, strict, memos) {
+ // All identical values are equivalent, as determined by ===.
+ if (val1 === val2) {
+ if (val1 !== 0) return true;
+ return strict ? objectIs(val1, val2) : true;
+ } // Check more closely if val1 and val2 are equal.
+
+
+ if (strict) {
+ if (_typeof(val1) !== 'object') {
+ return typeof val1 === 'number' && numberIsNaN(val1) && numberIsNaN(val2);
+ }
+
+ if (_typeof(val2) !== 'object' || val1 === null || val2 === null) {
+ return false;
+ }
+
+ if (Object.getPrototypeOf(val1) !== Object.getPrototypeOf(val2)) {
+ return false;
+ }
+ } else {
+ 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;
+ }
+ }
+
+ var val1Tag = objectToString(val1);
+ var val2Tag = objectToString(val2);
+
+ if (val1Tag !== val2Tag) {
+ return false;
+ }
+
+ if (Array.isArray(val1)) {
+ // Check for sparse arrays and general fast path
+ if (val1.length !== val2.length) {
+ return false;
+ }
+
+ var keys1 = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);
+ var keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);
+
+ if (keys1.length !== keys2.length) {
+ return false;
+ }
+
+ return keyCheck(val1, val2, strict, memos, kIsArray, keys1);
+ } // [browserify] This triggers on certain types in IE (Map/Set) so we don't
+ // wan't to early return out of the rest of the checks. However we can check
+ // if the second value is one of these values and the first isn't.
+
+
+ if (val1Tag === '[object Object]') {
+ // return keyCheck(val1, val2, strict, memos, kNoIterator);
+ if (!isMap(val1) && isMap(val2) || !isSet(val1) && isSet(val2)) {
+ return false;
+ }
+ }
+
+ if (isDate(val1)) {
+ if (!isDate(val2) || Date.prototype.getTime.call(val1) !== Date.prototype.getTime.call(val2)) {
+ return false;
+ }
+ } else if (isRegExp(val1)) {
+ if (!isRegExp(val2) || !areSimilarRegExps(val1, val2)) {
+ return false;
+ }
+ } else if (isNativeError(val1) || val1 instanceof Error) {
+ // Do not compare the stack as it might differ even though the error itself
+ // is otherwise identical.
+ if (val1.message !== val2.message || val1.name !== val2.name) {
+ return false;
+ }
+ } else if (isArrayBufferView(val1)) {
+ if (!strict && (isFloat32Array(val1) || isFloat64Array(val1))) {
+ if (!areSimilarFloatArrays(val1, val2)) {
+ return false;
+ }
+ } else if (!areSimilarTypedArrays(val1, val2)) {
+ 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 than checking
+ // the symbols.
+
+
+ var _keys = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);
+
+ var _keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);
+
+ if (_keys.length !== _keys2.length) {
+ return false;
+ }
+
+ return keyCheck(val1, val2, strict, memos, kNoIterator, _keys);
+ } else if (isSet(val1)) {
+ if (!isSet(val2) || val1.size !== val2.size) {
+ return false;
+ }
+
+ return keyCheck(val1, val2, strict, memos, kIsSet);
+ } else if (isMap(val1)) {
+ if (!isMap(val2) || val1.size !== val2.size) {
+ return false;
+ }
+
+ return keyCheck(val1, val2, strict, memos, kIsMap);
+ } else if (isAnyArrayBuffer(val1)) {
+ if (!areEqualArrayBuffers(val1, val2)) {
+ return false;
+ }
+ } else if (isBoxedPrimitive(val1) && !isEqualBoxedPrimitive(val1, val2)) {
+ return false;
+ }
+
+ return keyCheck(val1, val2, strict, memos, kNoIterator);
+}
+
+function getEnumerables(val, keys) {
+ return keys.filter(function (k) {
+ return propertyIsEnumerable(val, k);
+ });
+}
+
+function keyCheck(val1, val2, strict, memos, iterationType, aKeys) {
+ // 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.
+ if (arguments.length === 5) {
+ aKeys = Object.keys(val1);
+ var bKeys = Object.keys(val2); // The pair must have the same number of owned properties.
+
+ if (aKeys.length !== bKeys.length) {
+ return false;
+ }
+ } // Cheap key test
+
+
+ var i = 0;
+
+ for (; i < aKeys.length; i++) {
+ if (!hasOwnProperty(val2, aKeys[i])) {
+ return false;
+ }
+ }
+
+ if (strict && arguments.length === 5) {
+ var symbolKeysA = objectGetOwnPropertySymbols(val1);
+
+ if (symbolKeysA.length !== 0) {
+ var count = 0;
+
+ for (i = 0; i < symbolKeysA.length; i++) {
+ var key = symbolKeysA[i];
+
+ if (propertyIsEnumerable(val1, key)) {
+ if (!propertyIsEnumerable(val2, key)) {
+ return false;
+ }
+
+ aKeys.push(key);
+ count++;
+ } else if (propertyIsEnumerable(val2, key)) {
+ return false;
+ }
+ }
+
+ var symbolKeysB = objectGetOwnPropertySymbols(val2);
+
+ if (symbolKeysA.length !== symbolKeysB.length && getEnumerables(val2, symbolKeysB).length !== count) {
+ return false;
+ }
+ } else {
+ var _symbolKeysB = objectGetOwnPropertySymbols(val2);
+
+ if (_symbolKeysB.length !== 0 && getEnumerables(val2, _symbolKeysB).length !== 0) {
+ return false;
+ }
+ }
+ }
+
+ if (aKeys.length === 0 && (iterationType === kNoIterator || iterationType === kIsArray && val1.length === 0 || val1.size === 0)) {
+ return true;
+ } // 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.
+ var val2MemoA = memos.val1.get(val1);
+
+ if (val2MemoA !== undefined) {
+ var 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);
+ var areEq = objEquiv(val1, val2, strict, aKeys, memos, iterationType);
+ memos.val1.delete(val1);
+ memos.val2.delete(val2);
+ return areEq;
+}
+
+function setHasEqualElement(set, val1, strict, memo) {
+ // Go looking.
+ var setValues = arrayFromSet(set);
+
+ for (var i = 0; i < setValues.length; i++) {
+ var val2 = setValues[i];
+
+ 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;
+} // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness#Loose_equality_using
+// Sadly it is not possible to detect corresponding values properly in case the
+// type is a string, number, bigint or boolean. The reason is that those values
+// can match lots of different string values (e.g., 1n == '+00001').
+
+
+function findLooseMatchingPrimitives(prim) {
+ switch (_typeof(prim)) {
+ case 'undefined':
+ return null;
+
+ case 'object':
+ // Only pass in null as object!
+ return undefined;
+
+ case 'symbol':
+ return false;
+
+ case 'string':
+ prim = +prim;
+ // Loose equal entries exist only if the string is possible to convert to
+ // a regular number and not NaN.
+ // Fall through
+
+ case 'number':
+ if (numberIsNaN(prim)) {
+ return false;
+ }
+
+ }
+
+ return true;
+}
+
+function setMightHaveLoosePrim(a, b, prim) {
+ var altValue = findLooseMatchingPrimitives(prim);
+ if (altValue != null) return altValue;
+ return b.has(altValue) && !a.has(altValue);
+}
+
+function mapMightHaveLoosePrim(a, b, prim, item, memo) {
+ var altValue = findLooseMatchingPrimitives(prim);
+
+ if (altValue != null) {
+ return altValue;
+ }
+
+ var curB = b.get(altValue);
+
+ if (curB === undefined && !b.has(altValue) || !innerDeepEqual(item, curB, false, memo)) {
+ return false;
+ }
+
+ return !a.has(altValue) && innerDeepEqual(item, curB, false, memo);
+}
+
+function setEquiv(a, b, strict, memo) {
+ // This is a lazily initiated Set of entries which have to be compared
+ // pairwise.
+ var set = null;
+ var aValues = arrayFromSet(a);
+
+ for (var i = 0; i < aValues.length; i++) {
+ var val = aValues[i]; // 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)) {
+ if (strict) return false; // Fast path to detect missing string, symbol, undefined and null values.
+
+ if (!setMightHaveLoosePrim(a, b, val)) {
+ return false;
+ }
+
+ if (set === null) {
+ set = new Set();
+ }
+
+ set.add(val);
+ }
+ }
+
+ if (set !== null) {
+ var bValues = arrayFromSet(b);
+
+ for (var _i = 0; _i < bValues.length; _i++) {
+ var _val = bValues[_i]; // 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 (!strict && !a.has(_val) && !setHasEqualElement(set, _val, strict, memo)) {
+ return false;
+ }
+ }
+
+ return set.size === 0;
+ }
+
+ 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.
+ var setValues = arrayFromSet(set);
+
+ for (var i = 0; i < setValues.length; i++) {
+ var key2 = setValues[i];
+
+ 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) {
+ var set = null;
+ var aEntries = arrayFromMap(a);
+
+ for (var i = 0; i < aEntries.length; i++) {
+ var _aEntries$i = _slicedToArray(aEntries[i], 2),
+ key = _aEntries$i[0],
+ item1 = _aEntries$i[1];
+
+ 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.
+ var item2 = b.get(key);
+
+ if (item2 === undefined && !b.has(key) || !innerDeepEqual(item1, item2, strict, memo)) {
+ if (strict) return false; // Fast path to detect missing string, symbol, undefined and null
+ // keys.
+
+ if (!mapMightHaveLoosePrim(a, b, key, item1, memo)) return false;
+
+ if (set === null) {
+ set = new Set();
+ }
+
+ set.add(key);
+ }
+ }
+ }
+
+ if (set !== null) {
+ var bEntries = arrayFromMap(b);
+
+ for (var _i2 = 0; _i2 < bEntries.length; _i2++) {
+ var _bEntries$_i = _slicedToArray(bEntries[_i2], 2),
+ key = _bEntries$_i[0],
+ item = _bEntries$_i[1];
+
+ if (_typeof(key) === 'object' && key !== null) {
+ if (!mapHasEqualEntry(set, a, key, item, strict, memo)) return false;
+ } else if (!strict && (!a.has(key) || !innerDeepEqual(a.get(key), item, false, memo)) && !mapHasEqualEntry(set, a, key, item, false, memo)) {
+ return false;
+ }
+ }
+
+ return set.size === 0;
+ }
+
+ return true;
+}
+
+function objEquiv(a, b, strict, keys, memos, iterationType) {
+ // Sets and maps don't have their entries accessible via normal object
+ // properties.
+ var i = 0;
+
+ if (iterationType === kIsSet) {
+ if (!setEquiv(a, b, strict, memos)) {
+ return false;
+ }
+ } else if (iterationType === kIsMap) {
+ if (!mapEquiv(a, b, strict, memos)) {
+ return false;
+ }
+ } else if (iterationType === kIsArray) {
+ for (; i < a.length; i++) {
+ if (hasOwnProperty(a, i)) {
+ if (!hasOwnProperty(b, i) || !innerDeepEqual(a[i], b[i], strict, memos)) {
+ return false;
+ }
+ } else if (hasOwnProperty(b, i)) {
+ return false;
+ } else {
+ // Array is sparse.
+ var keysA = Object.keys(a);
+
+ for (; i < keysA.length; i++) {
+ var key = keysA[i];
+
+ if (!hasOwnProperty(b, key) || !innerDeepEqual(a[key], b[key], strict, memos)) {
+ return false;
+ }
+ }
+
+ if (keysA.length !== Object.keys(b).length) {
+ return false;
+ }
+
+ return true;
+ }
+ }
+ } // The pair must have equivalent values for every corresponding key.
+ // Possibly expensive deep test:
+
+
+ for (i = 0; i < keys.length; i++) {
+ var _key = keys[i];
+
+ if (!innerDeepEqual(a[_key], b[_key], strict, memos)) {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+function isDeepEqual(val1, val2) {
+ return innerDeepEqual(val1, val2, kLoose);
+}
+
+function isDeepStrictEqual(val1, val2) {
+ return innerDeepEqual(val1, val2, kStrict);
+}
+
+module.exports = {
+ isDeepEqual: isDeepEqual,
+ isDeepStrictEqual: isDeepStrictEqual
+}; \ No newline at end of file
© Floofi Systems, Some rights reserved. Powered by cgit.