@jointhedots/gear 1.0.21 → 1.1.5

package/node_modules/@jspm/core/nodelibs/browser/assert.js

@@ -0,0 +1,2574 @@
+import exports$j from './util.js';
+import { p as process } from './chunk-DEMDiNwt.js';
+import { d as dew$i, a as dew$j, b as dew$k, c as dew$l, e as dew$m } from './chunk-DtcTpLWz.js';
+import './chunk-CkFCi-G1.js';
+
+var exports$i = {},
+  _dewExec$h = false;
+function dew$h() {
+  if (_dewExec$h) return exports$i;
+  _dewExec$h = true;
+  // 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(o) {
+    "@babel/helpers - typeof";
+
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+      return typeof o;
+    } : function (o) {
+      return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+    }, _typeof(o);
+  }
+  function _createClass(Constructor, protoProps, staticProps) {
+    Object.defineProperty(Constructor, "prototype", {
+      writable: false
+    });
+    return Constructor;
+  }
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+  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
+      }
+    });
+    Object.defineProperty(subClass, "prototype", {
+      writable: false
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+  }
+  function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+      o.__proto__ = p;
+      return o;
+    };
+    return _setPrototypeOf(o, p);
+  }
+  function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+      var Super = _getPrototypeOf(Derived),
+        result;
+      if (hasNativeReflectConstruct) {
+        var NewTarget = _getPrototypeOf(this).constructor;
+        result = Reflect.construct(Super, arguments, NewTarget);
+      } else {
+        result = Super.apply(this, arguments);
+      }
+      return _possibleConstructorReturn(this, result);
+    };
+  }
+  function _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+      return call;
+    } else if (call !== void 0) {
+      throw new TypeError("Derived constructors may only return object or undefined");
+    }
+    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 _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+      return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+  }
+  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);
+      var _super = _createSuper(NodeError);
+      function NodeError(arg1, arg2, arg3) {
+        var _this;
+        _classCallCheck(this, NodeError);
+        _this = _super.call(this, getMessage(arg1, arg2, arg3));
+        _this.code = code;
+        return _this;
+      }
+      return _createClass(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(0 , 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 = dew();
+    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 = exports$j;
+    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);
+  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 = dew();
+    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);
+  exports$i.codes = codes;
+  return exports$i;
+}
+
+var exports$h = {},
+  _dewExec$g = false;
+function dew$g() {
+  if (_dewExec$g) return exports$h;
+  _dewExec$g = true;
+  var process$1 = process;
+  function ownKeys(e, r) {
+    var t = Object.keys(e);
+    if (Object.getOwnPropertySymbols) {
+      var o = Object.getOwnPropertySymbols(e);
+      r && (o = o.filter(function (r) {
+        return Object.getOwnPropertyDescriptor(e, r).enumerable;
+      })), t.push.apply(t, o);
+    }
+    return t;
+  }
+  function _objectSpread(e) {
+    for (var r = 1; r < arguments.length; r++) {
+      var t = null != arguments[r] ? arguments[r] : {};
+      r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {
+        _defineProperty(e, r, t[r]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+        Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+      });
+    }
+    return e;
+  }
+  function _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
+    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, _toPropertyKey(descriptor.key), descriptor);
+    }
+  }
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    Object.defineProperty(Constructor, "prototype", {
+      writable: false
+    });
+    return Constructor;
+  }
+  function _toPropertyKey(arg) {
+    var key = _toPrimitive(arg, "string");
+    return _typeof(key) === "symbol" ? key : String(key);
+  }
+  function _toPrimitive(input, hint) {
+    if (_typeof(input) !== "object" || input === null) return input;
+    var prim = input[Symbol.toPrimitive];
+    if (prim !== undefined) {
+      var res = prim.call(input, hint || "default");
+      if (_typeof(res) !== "object") return res;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (hint === "string" ? String : Number)(input);
+  }
+  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
+      }
+    });
+    Object.defineProperty(subClass, "prototype", {
+      writable: false
+    });
+    if (superClass) _setPrototypeOf(subClass, superClass);
+  }
+  function _createSuper(Derived) {
+    var hasNativeReflectConstruct = _isNativeReflectConstruct();
+    return function _createSuperInternal() {
+      var Super = _getPrototypeOf(Derived),
+        result;
+      if (hasNativeReflectConstruct) {
+        var NewTarget = _getPrototypeOf(this).constructor;
+        result = Reflect.construct(Super, arguments, NewTarget);
+      } else {
+        result = Super.apply(this, arguments);
+      }
+      return _possibleConstructorReturn(this, result);
+    };
+  }
+  function _possibleConstructorReturn(self, call) {
+    if (call && (_typeof(call) === "object" || typeof call === "function")) {
+      return call;
+    } else if (call !== void 0) {
+      throw new TypeError("Derived constructors may only return object or undefined");
+    }
+    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 _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 _construct(Parent, args, Class) {
+    if (_isNativeReflectConstruct()) {
+      _construct = Reflect.construct.bind();
+    } 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 _isNativeReflectConstruct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+      Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+      return true;
+    } catch (e) {
+      return false;
+    }
+  }
+  function _isNativeFunction(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+  }
+  function _setPrototypeOf(o, p) {
+    _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+      o.__proto__ = p;
+      return o;
+    };
+    return _setPrototypeOf(o, p);
+  }
+  function _getPrototypeOf(o) {
+    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+      return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _getPrototypeOf(o);
+  }
+  function _typeof(o) {
+    "@babel/helpers - typeof";
+
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+      return typeof o;
+    } : function (o) {
+      return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+    }, _typeof(o);
+  }
+  var _require = exports$j,
+    inspect = _require.inspect;
+  var _require2 = dew$h(),
+    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$1.stderr && process$1.stderr.isTTY ? process$1.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, _inspect$custom) {
+    _inherits(AssertionError, _Error);
+    var _super = _createSuper(AssertionError);
+    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 = _super.call(this, String(message));
+      } else {
+        if (process$1.stderr && process$1.stderr.isTTY) {
+          // Reset on each call to make sure we handle dynamically set environment
+          // variables correct.
+          if (process$1.stderr && process$1.stderr.getColorDepth && process$1.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 = _super.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 = _super.call(this, "".concat(base, " ").concat(res[0]));
+          } else {
+            _this = _super.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 = _super.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(_objectSpread({}, ctx), {}, {
+          customInspect: false,
+          depth: 0
+        }));
+      }
+    }]);
+    return AssertionError;
+  }(/*#__PURE__*/_wrapNativeSuper(Error), inspect.custom);
+  exports$h = AssertionError;
+  return exports$h;
+}
+
+var exports$g = {},
+  _dewExec$f = false;
+function dew$f() {
+  if (_dewExec$f) return exports$g;
+  _dewExec$f = true;
+  var toStr = Object.prototype.toString;
+  exports$g = function isArguments(value) {
+    var str = toStr.call(value);
+    var isArgs = str === "[object Arguments]";
+    if (!isArgs) {
+      isArgs = str !== "[object Array]" && value !== null && typeof value === "object" && typeof value.length === "number" && value.length >= 0 && toStr.call(value.callee) === "[object Function]";
+    }
+    return isArgs;
+  };
+  return exports$g;
+}
+
+var exports$f = {},
+  _dewExec$e = false;
+function dew$e() {
+  if (_dewExec$e) return exports$f;
+  _dewExec$e = true;
+  var keysShim;
+  if (!Object.keys) {
+    // modified from https://github.com/es-shims/es5-shim
+    var has = Object.prototype.hasOwnProperty;
+    var toStr = Object.prototype.toString;
+    var isArgs = dew$f(); // eslint-disable-line global-require
+    var isEnumerable = Object.prototype.propertyIsEnumerable;
+    var hasDontEnumBug = !isEnumerable.call({
+      toString: null
+    }, "toString");
+    var hasProtoEnumBug = isEnumerable.call(function () {}, "prototype");
+    var dontEnums = ["toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "constructor"];
+    var equalsConstructorPrototype = function (o) {
+      var ctor = o.constructor;
+      return ctor && ctor.prototype === o;
+    };
+    var excludedKeys = {
+      $applicationCache: true,
+      $console: true,
+      $external: true,
+      $frame: true,
+      $frameElement: true,
+      $frames: true,
+      $innerHeight: true,
+      $innerWidth: true,
+      $onmozfullscreenchange: true,
+      $onmozfullscreenerror: true,
+      $outerHeight: true,
+      $outerWidth: true,
+      $pageXOffset: true,
+      $pageYOffset: true,
+      $parent: true,
+      $scrollLeft: true,
+      $scrollTop: true,
+      $scrollX: true,
+      $scrollY: true,
+      $self: true,
+      $webkitIndexedDB: true,
+      $webkitStorageInfo: true,
+      $window: true
+    };
+    var hasAutomationEqualityBug = function () {
+      /* global window */
+      if (typeof window === "undefined") {
+        return false;
+      }
+      for (var k in window) {
+        try {
+          if (!excludedKeys["$" + k] && has.call(window, k) && window[k] !== null && typeof window[k] === "object") {
+            try {
+              equalsConstructorPrototype(window[k]);
+            } catch (e) {
+              return true;
+            }
+          }
+        } catch (e) {
+          return true;
+        }
+      }
+      return false;
+    }();
+    var equalsConstructorPrototypeIfNotBuggy = function (o) {
+      /* global window */
+      if (typeof window === "undefined" || !hasAutomationEqualityBug) {
+        return equalsConstructorPrototype(o);
+      }
+      try {
+        return equalsConstructorPrototype(o);
+      } catch (e) {
+        return false;
+      }
+    };
+    keysShim = function keys(object) {
+      var isObject = object !== null && typeof object === "object";
+      var isFunction = toStr.call(object) === "[object Function]";
+      var isArguments = isArgs(object);
+      var isString = isObject && toStr.call(object) === "[object String]";
+      var theKeys = [];
+      if (!isObject && !isFunction && !isArguments) {
+        throw new TypeError("Object.keys called on a non-object");
+      }
+      var skipProto = hasProtoEnumBug && isFunction;
+      if (isString && object.length > 0 && !has.call(object, 0)) {
+        for (var i = 0; i < object.length; ++i) {
+          theKeys.push(String(i));
+        }
+      }
+      if (isArguments && object.length > 0) {
+        for (var j = 0; j < object.length; ++j) {
+          theKeys.push(String(j));
+        }
+      } else {
+        for (var name in object) {
+          if (!(skipProto && name === "prototype") && has.call(object, name)) {
+            theKeys.push(String(name));
+          }
+        }
+      }
+      if (hasDontEnumBug) {
+        var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
+        for (var k = 0; k < dontEnums.length; ++k) {
+          if (!(skipConstructor && dontEnums[k] === "constructor") && has.call(object, dontEnums[k])) {
+            theKeys.push(dontEnums[k]);
+          }
+        }
+      }
+      return theKeys;
+    };
+  }
+  exports$f = keysShim;
+  return exports$f;
+}
+
+var exports$e = {},
+  _dewExec$d = false;
+function dew$d() {
+  if (_dewExec$d) return exports$e;
+  _dewExec$d = true;
+  var slice = Array.prototype.slice;
+  var isArgs = dew$f();
+  var origKeys = Object.keys;
+  var keysShim = origKeys ? function keys(o) {
+    return origKeys(o);
+  } : dew$e();
+  var originalKeys = Object.keys;
+  keysShim.shim = function shimObjectKeys() {
+    if (Object.keys) {
+      var keysWorksWithArguments = function () {
+        // Safari 5.0 bug
+        var args = Object.keys(arguments);
+        return args && args.length === arguments.length;
+      }(1, 2);
+      if (!keysWorksWithArguments) {
+        Object.keys = function keys(object) {
+          // eslint-disable-line func-name-matching
+          if (isArgs(object)) {
+            return originalKeys(slice.call(object));
+          }
+          return originalKeys(object);
+        };
+      }
+    } else {
+      Object.keys = keysShim;
+    }
+    return Object.keys || keysShim;
+  };
+  exports$e = keysShim;
+  return exports$e;
+}
+
+var exports$d = {},
+  _dewExec$c = false;
+function dew$c() {
+  if (_dewExec$c) return exports$d;
+  _dewExec$c = true;
+  // modified from https://github.com/es-shims/es6-shim
+  var objectKeys = dew$d();
+  var hasSymbols = dew$i()();
+  var callBound = dew$j();
+  var toObject = Object;
+  var $push = callBound("Array.prototype.push");
+  var $propIsEnumerable = callBound("Object.prototype.propertyIsEnumerable");
+  var originalGetSymbols = hasSymbols ? Object.getOwnPropertySymbols : null;
+
+  // eslint-disable-next-line no-unused-vars
+  exports$d = function assign(target, source1) {
+    if (target == null) {
+      throw new TypeError("target must be an object");
+    }
+    var to = toObject(target); // step 1
+    if (arguments.length === 1) {
+      return to; // step 2
+    }
+    for (var s = 1; s < arguments.length; ++s) {
+      var from = toObject(arguments[s]); // step 3.a.i
+
+      // step 3.a.ii:
+      var keys = objectKeys(from);
+      var getSymbols = hasSymbols && (Object.getOwnPropertySymbols || originalGetSymbols);
+      if (getSymbols) {
+        var syms = getSymbols(from);
+        for (var j = 0; j < syms.length; ++j) {
+          var key = syms[j];
+          if ($propIsEnumerable(from, key)) {
+            $push(keys, key);
+          }
+        }
+      }
+
+      // step 3.a.iii:
+      for (var i = 0; i < keys.length; ++i) {
+        var nextKey = keys[i];
+        if ($propIsEnumerable(from, nextKey)) {
+          // step 3.a.iii.2
+          var propValue = from[nextKey]; // step 3.a.iii.2.a
+          to[nextKey] = propValue; // step 3.a.iii.2.b
+        }
+      }
+    }
+    return to; // step 4
+  };
+  return exports$d;
+}
+
+var exports$c = {},
+  _dewExec$b = false;
+function dew$b() {
+  if (_dewExec$b) return exports$c;
+  _dewExec$b = true;
+  var implementation = dew$c();
+  var lacksProperEnumerationOrder = function () {
+    if (!Object.assign) {
+      return false;
+    }
+    /*
+     * v8, specifically in node 4.x, has a bug with incorrect property enumeration order
+     * note: this does not detect the bug unless there's 20 characters
+     */
+    var str = "abcdefghijklmnopqrst";
+    var letters = str.split("");
+    var map = {};
+    for (var i = 0; i < letters.length; ++i) {
+      map[letters[i]] = letters[i];
+    }
+    var obj = Object.assign({}, map);
+    var actual = "";
+    for (var k in obj) {
+      actual += k;
+    }
+    return str !== actual;
+  };
+  var assignHasPendingExceptions = function () {
+    if (!Object.assign || !Object.preventExtensions) {
+      return false;
+    }
+    /*
+     * Firefox 37 still has "pending exception" logic in its Object.assign implementation,
+     * which is 72% slower than our shim, and Firefox 40's native implementation.
+     */
+    var thrower = Object.preventExtensions({
+      1: 2
+    });
+    try {
+      Object.assign(thrower, "xy");
+    } catch (e) {
+      return thrower[1] === "y";
+    }
+    return false;
+  };
+  exports$c = function getPolyfill() {
+    if (!Object.assign) {
+      return implementation;
+    }
+    if (lacksProperEnumerationOrder()) {
+      return implementation;
+    }
+    if (assignHasPendingExceptions()) {
+      return implementation;
+    }
+    return Object.assign;
+  };
+  return exports$c;
+}
+
+var exports$b = {},
+  _dewExec$a = false;
+function dew$a() {
+  if (_dewExec$a) return exports$b;
+  _dewExec$a = true;
+  var numberIsNaN = function (value) {
+    return value !== value;
+  };
+  exports$b = function is(a, b) {
+    if (a === 0 && b === 0) {
+      return 1 / a === 1 / b;
+    }
+    if (a === b) {
+      return true;
+    }
+    if (numberIsNaN(a) && numberIsNaN(b)) {
+      return true;
+    }
+    return false;
+  };
+  return exports$b;
+}
+
+var exports$a = {},
+  _dewExec$9 = false;
+function dew$9() {
+  if (_dewExec$9) return exports$a;
+  _dewExec$9 = true;
+  var implementation = dew$a();
+  exports$a = function getPolyfill() {
+    return typeof Object.is === "function" ? Object.is : implementation;
+  };
+  return exports$a;
+}
+
+var exports$9 = {},
+  _dewExec$8 = false;
+function dew$8() {
+  if (_dewExec$8) return exports$9;
+  _dewExec$8 = true;
+  var keys = dew$d();
+  var hasSymbols = typeof Symbol === "function" && typeof Symbol("foo") === "symbol";
+  var toStr = Object.prototype.toString;
+  var concat = Array.prototype.concat;
+  var defineDataProperty = dew$k();
+  var isFunction = function (fn) {
+    return typeof fn === "function" && toStr.call(fn) === "[object Function]";
+  };
+  var supportsDescriptors = dew$l()();
+  var defineProperty = function (object, name, value, predicate) {
+    if (name in object) {
+      if (predicate === true) {
+        if (object[name] === value) {
+          return;
+        }
+      } else if (!isFunction(predicate) || !predicate()) {
+        return;
+      }
+    }
+    if (supportsDescriptors) {
+      defineDataProperty(object, name, value, true);
+    } else {
+      defineDataProperty(object, name, value);
+    }
+  };
+  var defineProperties = function (object, map) {
+    var predicates = arguments.length > 2 ? arguments[2] : {};
+    var props = keys(map);
+    if (hasSymbols) {
+      props = concat.call(props, Object.getOwnPropertySymbols(map));
+    }
+    for (var i = 0; i < props.length; i += 1) {
+      defineProperty(object, props[i], map[props[i]], predicates[props[i]]);
+    }
+  };
+  defineProperties.supportsDescriptors = !!supportsDescriptors;
+  exports$9 = defineProperties;
+  return exports$9;
+}
+
+var exports$8 = {},
+  _dewExec$7 = false;
+function dew$7() {
+  if (_dewExec$7) return exports$8;
+  _dewExec$7 = true;
+  var getPolyfill = dew$9();
+  var define = dew$8();
+  exports$8 = function shimObjectIs() {
+    var polyfill = getPolyfill();
+    define(Object, {
+      is: polyfill
+    }, {
+      is: function testObjectIs() {
+        return Object.is !== polyfill;
+      }
+    });
+    return polyfill;
+  };
+  return exports$8;
+}
+
+var exports$7 = {},
+  _dewExec$6 = false;
+function dew$6() {
+  if (_dewExec$6) return exports$7;
+  _dewExec$6 = true;
+  var define = dew$8();
+  var callBind = dew$m();
+  var implementation = dew$a();
+  var getPolyfill = dew$9();
+  var shim = dew$7();
+  var polyfill = callBind(getPolyfill(), Object);
+  define(polyfill, {
+    getPolyfill: getPolyfill,
+    implementation: implementation,
+    shim: shim
+  });
+  exports$7 = polyfill;
+  return exports$7;
+}
+
+var exports$6 = {},
+  _dewExec$5 = false;
+function dew$5() {
+  if (_dewExec$5) return exports$6;
+  _dewExec$5 = true;
+  /* http://www.ecma-international.org/ecma-262/6.0/#sec-number.isnan */
+
+  exports$6 = function isNaN(value) {
+    return value !== value;
+  };
+  return exports$6;
+}
+
+var exports$5 = {},
+  _dewExec$4 = false;
+function dew$4() {
+  if (_dewExec$4) return exports$5;
+  _dewExec$4 = true;
+  var implementation = dew$5();
+  exports$5 = function getPolyfill() {
+    if (Number.isNaN && Number.isNaN(NaN) && !Number.isNaN("a")) {
+      return Number.isNaN;
+    }
+    return implementation;
+  };
+  return exports$5;
+}
+
+var exports$4 = {},
+  _dewExec$3 = false;
+function dew$3() {
+  if (_dewExec$3) return exports$4;
+  _dewExec$3 = true;
+  var define = dew$8();
+  var getPolyfill = dew$4();
+
+  /* http://www.ecma-international.org/ecma-262/6.0/#sec-number.isnan */
+
+  exports$4 = function shimNumberIsNaN() {
+    var polyfill = getPolyfill();
+    define(Number, {
+      isNaN: polyfill
+    }, {
+      isNaN: function testIsNaN() {
+        return Number.isNaN !== polyfill;
+      }
+    });
+    return polyfill;
+  };
+  return exports$4;
+}
+
+var exports$3 = {},
+  _dewExec$2 = false;
+function dew$2() {
+  if (_dewExec$2) return exports$3;
+  _dewExec$2 = true;
+  var callBind = dew$m();
+  var define = dew$8();
+  var implementation = dew$5();
+  var getPolyfill = dew$4();
+  var shim = dew$3();
+  var polyfill = callBind(getPolyfill(), Number);
+
+  /* http://www.ecma-international.org/ecma-262/6.0/#sec-number.isnan */
+
+  define(polyfill, {
+    getPolyfill: getPolyfill,
+    implementation: implementation,
+    shim: shim
+  });
+  exports$3 = polyfill;
+  return exports$3;
+}
+
+var exports$2 = {},
+  _dewExec$1 = false;
+function dew$1() {
+  if (_dewExec$1) return exports$2;
+  _dewExec$1 = true;
+  function _slicedToArray(arr, i) {
+    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+  }
+  function _nonIterableRest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(o);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+  }
+  function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+    return arr2;
+  }
+  function _iterableToArrayLimit(r, l) {
+    var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+    if (null != t) {
+      var e,
+        n,
+        i,
+        u,
+        a = [],
+        f = !0,
+        o = !1;
+      try {
+        if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+      } catch (r) {
+        o = !0, n = r;
+      } finally {
+        try {
+          if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+        } finally {
+          if (o) throw n;
+        }
+      }
+      return a;
+    }
+  }
+  function _arrayWithHoles(arr) {
+    if (Array.isArray(arr)) return arr;
+  }
+  function _typeof(o) {
+    "@babel/helpers - typeof";
+
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+      return typeof o;
+    } : function (o) {
+      return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+    }, _typeof(o);
+  }
+  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 : dew$6();
+  var objectGetOwnPropertySymbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols : function () {
+    return [];
+  };
+  var numberIsNaN = Number.isNaN ? Number.isNaN : dew$2();
+  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 = exports$j.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 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);
+      var keys2 = getOwnNonIndexProperties(val2);
+      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);
+      var _keys2 = getOwnNonIndexProperties(val2);
+      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 _key2 = keys[i];
+      if (!innerDeepEqual(a[_key2], b[_key2], strict, memos)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function isDeepEqual(val1, val2) {
+    return innerDeepEqual(val1, val2, kLoose);
+  }
+  function isDeepStrictEqual(val1, val2) {
+    return innerDeepEqual(val1, val2, kStrict);
+  }
+  exports$2 = {
+    isDeepEqual: isDeepEqual,
+    isDeepStrictEqual: isDeepStrictEqual
+  };
+  return exports$2;
+}
+
+var exports$1 = {},
+  _dewExec = false;
+function dew() {
+  if (_dewExec) return exports$1;
+  _dewExec = true;
+  var process$1 = process;
+  function _typeof(o) {
+    "@babel/helpers - typeof";
+
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+      return typeof o;
+    } : function (o) {
+      return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+    }, _typeof(o);
+  }
+  function _createClass(Constructor, protoProps, staticProps) {
+    Object.defineProperty(Constructor, "prototype", {
+      writable: false
+    });
+    return Constructor;
+  }
+  function _classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+      throw new TypeError("Cannot call a class as a function");
+    }
+  }
+  var _require = dew$h(),
+    _require$codes = _require.codes,
+    ERR_AMBIGUOUS_ARGUMENT = _require$codes.ERR_AMBIGUOUS_ARGUMENT,
+    ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_ARG_VALUE = _require$codes.ERR_INVALID_ARG_VALUE,
+    ERR_INVALID_RETURN_VALUE = _require$codes.ERR_INVALID_RETURN_VALUE,
+    ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;
+  var AssertionError = dew$g();
+  var _require2 = exports$j,
+    inspect = _require2.inspect;
+  var _require$types = exports$j.types,
+    isPromise = _require$types.isPromise,
+    isRegExp = _require$types.isRegExp;
+  var objectAssign = dew$b()();
+  var objectIs = dew$9()();
+  var RegExpPrototypeTest = dew$j()("RegExp.prototype.test");
+  var isDeepEqual;
+  var isDeepStrictEqual;
+  function lazyLoadComparison() {
+    var comparison = dew$1();
+    isDeepEqual = comparison.isDeepEqual;
+    isDeepStrictEqual = comparison.isDeepStrictEqual;
+  }
+  var warned = false;
+
+  // The assert module provides functions that throw
+  // AssertionError's when particular conditions are not met. The
+  // assert module must conform to the following interface.
+
+  var assert = exports$1 = ok;
+  var NO_EXCEPTION_SENTINEL = {};
+
+  // All of the following functions must throw an AssertionError
+  // when a corresponding condition is not met, with a message that
+  // may be undefined if not provided. All assertion methods provide
+  // both the actual and expected values to the assertion error for
+  // display purposes.
+
+  function innerFail(obj) {
+    if (obj.message instanceof Error) throw obj.message;
+    throw new AssertionError(obj);
+  }
+  function fail(actual, expected, message, operator, stackStartFn) {
+    var argsLen = arguments.length;
+    var internalMessage;
+    if (argsLen === 0) {
+      internalMessage = "Failed";
+    } else if (argsLen === 1) {
+      message = actual;
+      actual = undefined;
+    } else {
+      if (warned === false) {
+        warned = true;
+        var warn = process$1.emitWarning ? process$1.emitWarning : console.warn.bind(console);
+        warn("assert.fail() with more than one argument is deprecated. " + "Please use assert.strictEqual() instead or only pass a message.", "DeprecationWarning", "DEP0094");
+      }
+      if (argsLen === 2) operator = "!=";
+    }
+    if (message instanceof Error) throw message;
+    var errArgs = {
+      actual: actual,
+      expected: expected,
+      operator: operator === undefined ? "fail" : operator,
+      stackStartFn: stackStartFn || fail
+    };
+    if (message !== undefined) {
+      errArgs.message = message;
+    }
+    var err = new AssertionError(errArgs);
+    if (internalMessage) {
+      err.message = internalMessage;
+      err.generatedMessage = true;
+    }
+    throw err;
+  }
+  assert.fail = fail;
+
+  // The AssertionError is defined in internal/error.
+  assert.AssertionError = AssertionError;
+  function innerOk(fn, argLen, value, message) {
+    if (!value) {
+      var generatedMessage = false;
+      if (argLen === 0) {
+        generatedMessage = true;
+        message = "No value argument passed to `assert.ok()`";
+      } else if (message instanceof Error) {
+        throw message;
+      }
+      var err = new AssertionError({
+        actual: value,
+        expected: true,
+        message: message,
+        operator: "==",
+        stackStartFn: fn
+      });
+      err.generatedMessage = generatedMessage;
+      throw err;
+    }
+  }
+
+  // Pure assertion tests whether a value is truthy, as determined
+  // by !!value.
+  function ok() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    innerOk.apply(void 0, [ok, args.length].concat(args));
+  }
+  assert.ok = ok;
+
+  // The equality assertion tests shallow, coercive equality with ==.
+  /* eslint-disable no-restricted-properties */
+  assert.equal = function equal(actual, expected, message) {
+    if (arguments.length < 2) {
+      throw new ERR_MISSING_ARGS("actual", "expected");
+    }
+    // eslint-disable-next-line eqeqeq
+    if (actual != expected) {
+      innerFail({
+        actual: actual,
+        expected: expected,
+        message: message,
+        operator: "==",
+        stackStartFn: equal
+      });
+    }
+  };
+
+  // The non-equality assertion tests for whether two objects are not
+  // equal with !=.
+  assert.notEqual = function notEqual(actual, expected, message) {
+    if (arguments.length < 2) {
+      throw new ERR_MISSING_ARGS("actual", "expected");
+    }
+    // eslint-disable-next-line eqeqeq
+    if (actual == expected) {
+      innerFail({
+        actual: actual,
+        expected: expected,
+        message: message,
+        operator: "!=",
+        stackStartFn: notEqual
+      });
+    }
+  };
+
+  // The equivalence assertion tests a deep equality relation.
+  assert.deepEqual = function deepEqual(actual, expected, message) {
+    if (arguments.length < 2) {
+      throw new ERR_MISSING_ARGS("actual", "expected");
+    }
+    if (isDeepEqual === undefined) lazyLoadComparison();
+    if (!isDeepEqual(actual, expected)) {
+      innerFail({
+        actual: actual,
+        expected: expected,
+        message: message,
+        operator: "deepEqual",
+        stackStartFn: deepEqual
+      });
+    }
+  };
+
+  // The non-equivalence assertion tests for any deep inequality.
+  assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+    if (arguments.length < 2) {
+      throw new ERR_MISSING_ARGS("actual", "expected");
+    }
+    if (isDeepEqual === undefined) lazyLoadComparison();
+    if (isDeepEqual(actual, expected)) {
+      innerFail({
+        actual: actual,
+        expected: expected,
+        message: message,
+        operator: "notDeepEqual",
+        stackStartFn: notDeepEqual
+      });
+    }
+  };
+  /* eslint-enable */
+
+  assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
+    if (arguments.length < 2) {
+      throw new ERR_MISSING_ARGS("actual", "expected");
+    }
+    if (isDeepEqual === undefined) lazyLoadComparison();
+    if (!isDeepStrictEqual(actual, expected)) {
+      innerFail({
+        actual: actual,
+        expected: expected,
+        message: message,
+        operator: "deepStrictEqual",
+        stackStartFn: deepStrictEqual
+      });
+    }
+  };
+  assert.notDeepStrictEqual = notDeepStrictEqual;
+  function notDeepStrictEqual(actual, expected, message) {
+    if (arguments.length < 2) {
+      throw new ERR_MISSING_ARGS("actual", "expected");
+    }
+    if (isDeepEqual === undefined) lazyLoadComparison();
+    if (isDeepStrictEqual(actual, expected)) {
+      innerFail({
+        actual: actual,
+        expected: expected,
+        message: message,
+        operator: "notDeepStrictEqual",
+        stackStartFn: notDeepStrictEqual
+      });
+    }
+  }
+  assert.strictEqual = function strictEqual(actual, expected, message) {
+    if (arguments.length < 2) {
+      throw new ERR_MISSING_ARGS("actual", "expected");
+    }
+    if (!objectIs(actual, expected)) {
+      innerFail({
+        actual: actual,
+        expected: expected,
+        message: message,
+        operator: "strictEqual",
+        stackStartFn: strictEqual
+      });
+    }
+  };
+  assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+    if (arguments.length < 2) {
+      throw new ERR_MISSING_ARGS("actual", "expected");
+    }
+    if (objectIs(actual, expected)) {
+      innerFail({
+        actual: actual,
+        expected: expected,
+        message: message,
+        operator: "notStrictEqual",
+        stackStartFn: notStrictEqual
+      });
+    }
+  };
+  var Comparison = /*#__PURE__*/_createClass(function Comparison(obj, keys, actual) {
+    var _this = this;
+    _classCallCheck(this, Comparison);
+    keys.forEach(function (key) {
+      if (key in obj) {
+        if (actual !== undefined && typeof actual[key] === "string" && isRegExp(obj[key]) && RegExpPrototypeTest(obj[key], actual[key])) {
+          _this[key] = actual[key];
+        } else {
+          _this[key] = obj[key];
+        }
+      }
+    });
+  });
+  function compareExceptionKey(actual, expected, key, message, keys, fn) {
+    if (!(key in actual) || !isDeepStrictEqual(actual[key], expected[key])) {
+      if (!message) {
+        // Create placeholder objects to create a nice output.
+        var a = new Comparison(actual, keys);
+        var b = new Comparison(expected, keys, actual);
+        var err = new AssertionError({
+          actual: a,
+          expected: b,
+          operator: "deepStrictEqual",
+          stackStartFn: fn
+        });
+        err.actual = actual;
+        err.expected = expected;
+        err.operator = fn.name;
+        throw err;
+      }
+      innerFail({
+        actual: actual,
+        expected: expected,
+        message: message,
+        operator: fn.name,
+        stackStartFn: fn
+      });
+    }
+  }
+  function expectedException(actual, expected, msg, fn) {
+    if (typeof expected !== "function") {
+      if (isRegExp(expected)) return RegExpPrototypeTest(expected, actual);
+      // assert.doesNotThrow does not accept objects.
+      if (arguments.length === 2) {
+        throw new ERR_INVALID_ARG_TYPE("expected", ["Function", "RegExp"], expected);
+      }
+
+      // Handle primitives properly.
+      if (_typeof(actual) !== "object" || actual === null) {
+        var err = new AssertionError({
+          actual: actual,
+          expected: expected,
+          message: msg,
+          operator: "deepStrictEqual",
+          stackStartFn: fn
+        });
+        err.operator = fn.name;
+        throw err;
+      }
+      var keys = Object.keys(expected);
+      // Special handle errors to make sure the name and the message are compared
+      // as well.
+      if (expected instanceof Error) {
+        keys.push("name", "message");
+      } else if (keys.length === 0) {
+        throw new ERR_INVALID_ARG_VALUE("error", expected, "may not be an empty object");
+      }
+      if (isDeepEqual === undefined) lazyLoadComparison();
+      keys.forEach(function (key) {
+        if (typeof actual[key] === "string" && isRegExp(expected[key]) && RegExpPrototypeTest(expected[key], actual[key])) {
+          return;
+        }
+        compareExceptionKey(actual, expected, key, msg, keys, fn);
+      });
+      return true;
+    }
+    // Guard instanceof against arrow functions as they don't have a prototype.
+    if (expected.prototype !== undefined && actual instanceof expected) {
+      return true;
+    }
+    if (Error.isPrototypeOf(expected)) {
+      return false;
+    }
+    return expected.call({}, actual) === true;
+  }
+  function getActual(fn) {
+    if (typeof fn !== "function") {
+      throw new ERR_INVALID_ARG_TYPE("fn", "Function", fn);
+    }
+    try {
+      fn();
+    } catch (e) {
+      return e;
+    }
+    return NO_EXCEPTION_SENTINEL;
+  }
+  function checkIsPromise(obj) {
+    // Accept native ES6 promises and promises that are implemented in a similar
+    // way. Do not accept thenables that use a function as `obj` and that have no
+    // `catch` handler.
+
+    // TODO: thenables are checked up until they have the correct methods,
+    // but according to documentation, the `then` method should receive
+    // the `fulfill` and `reject` arguments as well or it may be never resolved.
+
+    return isPromise(obj) || obj !== null && _typeof(obj) === "object" && typeof obj.then === "function" && typeof obj.catch === "function";
+  }
+  function waitForActual(promiseFn) {
+    return Promise.resolve().then(function () {
+      var resultPromise;
+      if (typeof promiseFn === "function") {
+        // Return a rejected promise if `promiseFn` throws synchronously.
+        resultPromise = promiseFn();
+        // Fail in case no promise is returned.
+        if (!checkIsPromise(resultPromise)) {
+          throw new ERR_INVALID_RETURN_VALUE("instance of Promise", "promiseFn", resultPromise);
+        }
+      } else if (checkIsPromise(promiseFn)) {
+        resultPromise = promiseFn;
+      } else {
+        throw new ERR_INVALID_ARG_TYPE("promiseFn", ["Function", "Promise"], promiseFn);
+      }
+      return Promise.resolve().then(function () {
+        return resultPromise;
+      }).then(function () {
+        return NO_EXCEPTION_SENTINEL;
+      }).catch(function (e) {
+        return e;
+      });
+    });
+  }
+  function expectsError(stackStartFn, actual, error, message) {
+    if (typeof error === "string") {
+      if (arguments.length === 4) {
+        throw new ERR_INVALID_ARG_TYPE("error", ["Object", "Error", "Function", "RegExp"], error);
+      }
+      if (_typeof(actual) === "object" && actual !== null) {
+        if (actual.message === error) {
+          throw new ERR_AMBIGUOUS_ARGUMENT("error/message", "The error message \"".concat(actual.message, "\" is identical to the message."));
+        }
+      } else if (actual === error) {
+        throw new ERR_AMBIGUOUS_ARGUMENT("error/message", "The error \"".concat(actual, "\" is identical to the message."));
+      }
+      message = error;
+      error = undefined;
+    } else if (error != null && _typeof(error) !== "object" && typeof error !== "function") {
+      throw new ERR_INVALID_ARG_TYPE("error", ["Object", "Error", "Function", "RegExp"], error);
+    }
+    if (actual === NO_EXCEPTION_SENTINEL) {
+      var details = "";
+      if (error && error.name) {
+        details += " (".concat(error.name, ")");
+      }
+      details += message ? ": ".concat(message) : ".";
+      var fnType = stackStartFn.name === "rejects" ? "rejection" : "exception";
+      innerFail({
+        actual: undefined,
+        expected: error,
+        operator: stackStartFn.name,
+        message: "Missing expected ".concat(fnType).concat(details),
+        stackStartFn: stackStartFn
+      });
+    }
+    if (error && !expectedException(actual, error, message, stackStartFn)) {
+      throw actual;
+    }
+  }
+  function expectsNoError(stackStartFn, actual, error, message) {
+    if (actual === NO_EXCEPTION_SENTINEL) return;
+    if (typeof error === "string") {
+      message = error;
+      error = undefined;
+    }
+    if (!error || expectedException(actual, error)) {
+      var details = message ? ": ".concat(message) : ".";
+      var fnType = stackStartFn.name === "doesNotReject" ? "rejection" : "exception";
+      innerFail({
+        actual: actual,
+        expected: error,
+        operator: stackStartFn.name,
+        message: "Got unwanted ".concat(fnType).concat(details, "\n") + "Actual message: \"".concat(actual && actual.message, "\""),
+        stackStartFn: stackStartFn
+      });
+    }
+    throw actual;
+  }
+  assert.throws = function throws(promiseFn) {
+    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      args[_key2 - 1] = arguments[_key2];
+    }
+    expectsError.apply(void 0, [throws, getActual(promiseFn)].concat(args));
+  };
+  assert.rejects = function rejects(promiseFn) {
+    for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+      args[_key3 - 1] = arguments[_key3];
+    }
+    return waitForActual(promiseFn).then(function (result) {
+      return expectsError.apply(void 0, [rejects, result].concat(args));
+    });
+  };
+  assert.doesNotThrow = function doesNotThrow(fn) {
+    for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+      args[_key4 - 1] = arguments[_key4];
+    }
+    expectsNoError.apply(void 0, [doesNotThrow, getActual(fn)].concat(args));
+  };
+  assert.doesNotReject = function doesNotReject(fn) {
+    for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {
+      args[_key5 - 1] = arguments[_key5];
+    }
+    return waitForActual(fn).then(function (result) {
+      return expectsNoError.apply(void 0, [doesNotReject, result].concat(args));
+    });
+  };
+  assert.ifError = function ifError(err) {
+    if (err !== null && err !== undefined) {
+      var message = "ifError got unwanted exception: ";
+      if (_typeof(err) === "object" && typeof err.message === "string") {
+        if (err.message.length === 0 && err.constructor) {
+          message += err.constructor.name;
+        } else {
+          message += err.message;
+        }
+      } else {
+        message += inspect(err);
+      }
+      var newErr = new AssertionError({
+        actual: err,
+        expected: null,
+        operator: "ifError",
+        message: message,
+        stackStartFn: ifError
+      });
+
+      // Make sure we actually have a stack trace!
+      var origStack = err.stack;
+      if (typeof origStack === "string") {
+        // This will remove any duplicated frames from the error frames taken
+        // from within `ifError` and add the original error frames to the newly
+        // created ones.
+        var tmp2 = origStack.split("\n");
+        tmp2.shift();
+        // Filter all frames existing in err.stack.
+        var tmp1 = newErr.stack.split("\n");
+        for (var i = 0; i < tmp2.length; i++) {
+          // Find the first occurrence of the frame.
+          var pos = tmp1.indexOf(tmp2[i]);
+          if (pos !== -1) {
+            // Only keep new frames.
+            tmp1 = tmp1.slice(0, pos);
+            break;
+          }
+        }
+        newErr.stack = "".concat(tmp1.join("\n"), "\n").concat(tmp2.join("\n"));
+      }
+      throw newErr;
+    }
+  };
+
+  // Currently in sync with Node.js lib/assert.js
+  // https://github.com/nodejs/node/commit/2a871df3dfb8ea663ef5e1f8f62701ec51384ecb
+  function internalMatch(string, regexp, message, fn, fnName) {
+    if (!isRegExp(regexp)) {
+      throw new ERR_INVALID_ARG_TYPE("regexp", "RegExp", regexp);
+    }
+    var match = fnName === "match";
+    if (typeof string !== "string" || RegExpPrototypeTest(regexp, string) !== match) {
+      if (message instanceof Error) {
+        throw message;
+      }
+      var generatedMessage = !message;
+
+      // 'The input was expected to not match the regular expression ' +
+      message = message || (typeof string !== "string" ? "The \"string\" argument must be of type string. Received type " + "".concat(_typeof(string), " (").concat(inspect(string), ")") : (match ? "The input did not match the regular expression " : "The input was expected to not match the regular expression ") + "".concat(inspect(regexp), ". Input:\n\n").concat(inspect(string), "\n"));
+      var err = new AssertionError({
+        actual: string,
+        expected: regexp,
+        message: message,
+        operator: fnName,
+        stackStartFn: fn
+      });
+      err.generatedMessage = generatedMessage;
+      throw err;
+    }
+  }
+  assert.match = function match(string, regexp, message) {
+    internalMatch(string, regexp, message, match, "match");
+  };
+  assert.doesNotMatch = function doesNotMatch(string, regexp, message) {
+    internalMatch(string, regexp, message, doesNotMatch, "doesNotMatch");
+  };
+
+  // Expose a strict only variant of assert
+  function strict() {
+    for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+      args[_key6] = arguments[_key6];
+    }
+    innerOk.apply(void 0, [strict, args.length].concat(args));
+  }
+  assert.strict = objectAssign(strict, assert, {
+    equal: assert.strictEqual,
+    deepEqual: assert.deepStrictEqual,
+    notEqual: assert.notStrictEqual,
+    notDeepEqual: assert.notDeepStrictEqual
+  });
+  assert.strict.strict = assert.strict;
+  return exports$1;
+}
+
+const exports = dew();
+
+var AssertionError = exports.AssertionError;
+var deepEqual = exports.deepEqual;
+var deepStrictEqual = exports.deepStrictEqual;
+var doesNotReject = exports.doesNotReject;
+var doesNotThrow = exports.doesNotThrow;
+var equal = exports.equal;
+var fail = exports.fail;
+var ifError = exports.ifError;
+var notDeepEqual = exports.notDeepEqual;
+var notDeepStrictEqual = exports.notDeepStrictEqual;
+var notEqual = exports.notEqual;
+var notStrictEqual = exports.notStrictEqual;
+var ok = exports.ok;
+var rejects = exports.rejects;
+var strict = exports.strict;
+var strictEqual = exports.strictEqual;
+var throws = exports.throws;
+
+export { AssertionError, deepEqual, deepStrictEqual, exports as default, doesNotReject, doesNotThrow, equal, fail, ifError, notDeepEqual, notDeepStrictEqual, notEqual, notStrictEqual, ok, rejects, strict, strictEqual, throws };