1 files changed, 814 insertions, 0 deletions

diff --git a/src/js/out/modules_dev/node/assert.js b/src/js/out/modules_dev/node/assert.js
new file mode 100644
index 000000000..30a829f4b
--- /dev/null
+++ b/src/js/out/modules_dev/node/assert.js
@@ -0,0 +1,814 @@
+var CallTracker = function() {
+  throw new Error("CallTracker is not supported yet");
+}, { Bun } = import.meta.primordials, isDeepEqual = Bun.deepEquals;
+var __commonJS = (cb, mod) => function() {
+  return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var require2 = (path) => import.meta.require(path), require_errors = __commonJS({
+  "assert/build/internal/errors.js"(exports, module2) {
+    function _typeof(obj) {
+      return typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? _typeof = function(obj2) {
+        return typeof obj2;
+      } : _typeof = function(obj2) {
+        return obj2 && typeof Symbol == "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      }, _typeof(obj);
+    }
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor))
+        throw new TypeError("Cannot call a class as a function");
+    }
+    function _possibleConstructorReturn(self, call) {
+      return call && (_typeof(call) === "object" || typeof call == "function") ? call : _assertThisInitialized(self);
+    }
+    function _assertThisInitialized(self) {
+      if (self === void 0)
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      return self;
+    }
+    function _getPrototypeOf(o) {
+      return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function(o2) {
+        return o2.__proto__ || Object.getPrototypeOf(o2);
+      }, _getPrototypeOf(o);
+    }
+    function _inherits(subClass, superClass) {
+      if (typeof superClass != "function" && superClass !== null)
+        throw new TypeError("Super expression must either be null or a function");
+      subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: { value: subClass, writable: !0, configurable: !0 }
+      }), superClass && _setPrototypeOf(subClass, superClass);
+    }
+    function _setPrototypeOf(o, p) {
+      return _setPrototypeOf = Object.setPrototypeOf || function(o2, p2) {
+        return o2.__proto__ = p2, o2;
+      }, _setPrototypeOf(o, p);
+    }
+    var codes = {}, assert, util;
+    function createErrorType(code, message, Base) {
+      Base || (Base = Error);
+      function getMessage(arg1, arg2, arg3) {
+        return typeof message == "string" ? message : message(arg1, arg2, arg3);
+      }
+      var NodeError = function(_Base) {
+        _inherits(NodeError2, _Base);
+        function NodeError2(arg1, arg2, arg3) {
+          var _this;
+          return _classCallCheck(this, NodeError2), _this = _possibleConstructorReturn(this, _getPrototypeOf(NodeError2).call(this, getMessage(arg1, arg2, arg3))), _this.code = code, _this;
+        }
+        return NodeError2;
+      }(Base);
+      codes[code] = NodeError;
+    }
+    function oneOf(expected, thing) {
+      if (Array.isArray(expected)) {
+        var len = expected.length;
+        return expected = expected.map(function(i) {
+          return String(i);
+        }), len > 2 ? "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(", "), ", or ") + expected[len - 1] : len === 2 ? "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]) : "of ".concat(thing, " ").concat(expected[0]);
+      } else
+        return "of ".concat(thing, " ").concat(String(expected));
+    }
+    function startsWith(str, search, pos) {
+      return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
+    }
+    function endsWith(str, search, this_len) {
+      return (this_len === void 0 || this_len > str.length) && (this_len = str.length), str.substring(this_len - search.length, this_len) === search;
+    }
+    function includes(str, search, start) {
+      return typeof start != "number" && (start = 0), start + search.length > str.length ? !1 : 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) {
+      assert === void 0 && (assert = require_assert()), assert(typeof name == "string", "'name' must be a string");
+      var determiner;
+      typeof expected == "string" && startsWith(expected, "not ") ? (determiner = "must not be", expected = expected.replace(/^not /, "")) : determiner = "must be";
+      var msg;
+      if (endsWith(name, " 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"));
+      }
+      return msg += ". Received type ".concat(_typeof(actual)), msg;
+    }, TypeError), createErrorType("ERR_INVALID_ARG_VALUE", function(name, value) {
+      var reason = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "is invalid";
+      util === void 0 && (util = require2("util"));
+      var inspected = util.inspect(value);
+      return inspected.length > 128 && (inspected = "".concat(inspected.slice(0, 128), "...")), "The argument '".concat(name, "' ").concat(reason, ". Received ").concat(inspected);
+    }, TypeError, RangeError), createErrorType("ERR_INVALID_RETURN_VALUE", function(input, name, value) {
+      var type;
+      return value && value.constructor && value.constructor.name ? type = "instance of ".concat(value.constructor.name) : type = "type ".concat(_typeof(value)), "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];
+      assert === void 0 && (assert = require_assert()), assert(args.length > 0, "At least one arg needs to be specified");
+      var msg = "The ", len = args.length;
+      switch (args = args.map(function(a) {
+        return '"'.concat(a, '"');
+      }), 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), module2.exports.codes = codes;
+  }
+}), require_assertion_error = __commonJS({
+  "assert/build/internal/assert/assertion_error.js"(exports, module2) {
+    function _objectSpread(target) {
+      for (var i = 1;i < arguments.length; i++) {
+        var source = arguments[i] != null ? arguments[i] : {}, ownKeys = Object.keys(source);
+        typeof Object.getOwnPropertySymbols == "function" && (ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        }))), ownKeys.forEach(function(key) {
+          _defineProperty(target, key, source[key]);
+        });
+      }
+      return target;
+    }
+    function _defineProperty(obj, key, value) {
+      return (key in obj) ? Object.defineProperty(obj, key, {
+        value,
+        enumerable: !0,
+        configurable: !0,
+        writable: !0
+      }) : obj[key] = value, 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 || !1, descriptor.configurable = !0, ("value" in descriptor) && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+    function _createClass(Constructor, protoProps, staticProps) {
+      return protoProps && _defineProperties(Constructor.prototype, protoProps), staticProps && _defineProperties(Constructor, staticProps), Constructor;
+    }
+    function _possibleConstructorReturn(self, call) {
+      return call && (_typeof(call) === "object" || typeof call == "function") ? call : _assertThisInitialized(self);
+    }
+    function _assertThisInitialized(self) {
+      if (self === void 0)
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+      return self;
+    }
+    function _inherits(subClass, superClass) {
+      if (typeof superClass != "function" && superClass !== null)
+        throw new TypeError("Super expression must either be null or a function");
+      subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: { value: subClass, writable: !0, configurable: !0 }
+      }), superClass && _setPrototypeOf(subClass, superClass);
+    }
+    function _wrapNativeSuper(Class) {
+      var _cache = typeof Map == "function" ? new Map : void 0;
+      return _wrapNativeSuper = function(Class2) {
+        if (Class2 === null || !_isNativeFunction(Class2))
+          return Class2;
+        if (typeof Class2 != "function")
+          throw new TypeError("Super expression must either be null or a function");
+        if (typeof _cache != "undefined") {
+          if (_cache.has(Class2))
+            return _cache.get(Class2);
+          _cache.set(Class2, Wrapper);
+        }
+        function Wrapper() {
+          return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
+        }
+        return Wrapper.prototype = Object.create(Class2.prototype, {
+          constructor: {
+            value: Wrapper,
+            enumerable: !1,
+            writable: !0,
+            configurable: !0
+          }
+        }), _setPrototypeOf(Wrapper, Class2);
+      }, _wrapNativeSuper(Class);
+    }
+    function isNativeReflectConstruct() {
+      if (typeof Reflect == "undefined" || !Reflect.construct || Reflect.construct.sham)
+        return !1;
+      if (typeof Proxy == "function")
+        return !0;
+      try {
+        return Date.prototype.toString.call(Reflect.construct(Date, [], function() {
+        })), !0;
+      } catch {
+        return !1;
+      }
+    }
+    function _construct(Parent, args, Class) {
+      return isNativeReflectConstruct() ? _construct = Reflect.construct : _construct = function(Parent2, args2, Class2) {
+        var a = [null];
+        a.push.apply(a, args2);
+        var Constructor = Function.bind.apply(Parent2, a), instance = new Constructor;
+        return Class2 && _setPrototypeOf(instance, Class2.prototype), instance;
+      }, _construct.apply(null, arguments);
+    }
+    function _isNativeFunction(fn) {
+      return Function.toString.call(fn).indexOf("[native code]") !== -1;
+    }
+    function _setPrototypeOf(o, p) {
+      return _setPrototypeOf = Object.setPrototypeOf || function(o2, p2) {
+        return o2.__proto__ = p2, o2;
+      }, _setPrototypeOf(o, p);
+    }
+    function _getPrototypeOf(o) {
+      return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function(o2) {
+        return o2.__proto__ || Object.getPrototypeOf(o2);
+      }, _getPrototypeOf(o);
+    }
+    function _typeof(obj) {
+      return typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? _typeof = function(obj2) {
+        return typeof obj2;
+      } : _typeof = function(obj2) {
+        return obj2 && typeof Symbol == "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      }, _typeof(obj);
+    }
+    var _require = require2("util"), inspect = _require.inspect, _require2 = require_errors(), ERR_INVALID_ARG_TYPE = _require2.codes.ERR_INVALID_ARG_TYPE;
+    function endsWith(str, search, this_len) {
+      return (this_len === void 0 || this_len > str.length) && (this_len = str.length), str.substring(this_len - search.length, this_len) === search;
+    }
+    function repeat(str, count) {
+      if (count = Math.floor(count), str.length == 0 || count == 0)
+        return "";
+      var maxCount = str.length * count;
+      for (count = Math.floor(Math.log(count) / Math.log(2));count; )
+        str += str, count--;
+      return str += str.substring(0, maxCount - str.length), str;
+    }
+    var blue = "", green = "", red = "", white = "", 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:"
+    }, kMaxShortLength = 10;
+    function copyError(source) {
+      var keys = Object.keys(source), target = Object.create(Object.getPrototypeOf(source));
+      return keys.forEach(function(key) {
+        target[key] = source[key];
+      }), Object.defineProperty(target, "message", {
+        value: source.message
+      }), target;
+    }
+    function inspectValue(val) {
+      return inspect(val, {
+        compact: !1,
+        customInspect: !1,
+        depth: 1000,
+        maxArrayLength: Infinity,
+        showHidden: !1,
+        breakLength: Infinity,
+        showProxy: !1,
+        sorted: !0,
+        getters: !0
+      });
+    }
+    function createErrDiff(actual, expected, operator) {
+      var other = "", res = "", lastPos = 0, end = "", skipped = !1, actualInspected = inspectValue(actual), actualLines = actualInspected.split(`
+`), expectedLines = inspectValue(expected).split(`
+`), i = 0, indicator = "";
+      if (operator === "strictEqual" && _typeof(actual) === "object" && _typeof(expected) === "object" && actual !== null && expected !== null && (operator = "strictEqualObject"), actualLines.length === 1 && expectedLines.length === 1 && actualLines[0] !== expectedLines[0]) {
+        var inputLength = actualLines[0].length + expectedLines[0].length;
+        if (inputLength <= kMaxShortLength) {
+          if ((_typeof(actual) !== "object" || actual === null) && (_typeof(expected) !== "object" || expected === null) && (actual !== 0 || expected !== 0))
+            return "".concat(kReadableOperator[operator], `
+
+`) + "".concat(actualLines[0], " !== ").concat(expectedLines[0], `
+`);
+        } else if (operator !== "strictEqualObject") {
+          var maxLength = process.stderr && process.stderr.isTTY ? process.stderr.columns : 80;
+          if (inputLength < maxLength) {
+            for (;actualLines[0][i] === expectedLines[0][i]; )
+              i++;
+            i > 2 && (indicator = `
+  `.concat(repeat(" ", i), "^"), i = 0);
+          }
+        }
+      }
+      for (var a = actualLines[actualLines.length - 1], b = expectedLines[expectedLines.length - 1];a === b && (i++ < 2 ? end = `
+  `.concat(a).concat(end) : other = a, actualLines.pop(), expectedLines.pop(), !(actualLines.length === 0 || expectedLines.length === 0)); )
+        a = actualLines[actualLines.length - 1], b = expectedLines[expectedLines.length - 1];
+      var maxLines = Math.max(actualLines.length, expectedLines.length);
+      if (maxLines === 0) {
+        var _actualLines = actualInspected.split(`
+`);
+        if (_actualLines.length > 30)
+          for (_actualLines[26] = "".concat(blue, "...").concat(white);_actualLines.length > 27; )
+            _actualLines.pop();
+        return "".concat(kReadableOperator.notIdentical, `
+
+`).concat(_actualLines.join(`
+`), `
+`);
+      }
+      i > 3 && (end = `
+`.concat(blue, "...").concat(white).concat(end), skipped = !0), other !== "" && (end = `
+  `.concat(other).concat(end), other = "");
+      var printedLines = 0, msg = kReadableOperator[operator] + `
+`.concat(green, "+ actual").concat(white, " ").concat(red, "- expected").concat(white), skippedMsg = " ".concat(blue, "...").concat(white, " Lines skipped");
+      for (i = 0;i < maxLines; i++) {
+        var cur = i - lastPos;
+        if (actualLines.length < i + 1)
+          cur > 1 && i > 2 && (cur > 4 ? (res += `
+`.concat(blue, "...").concat(white), skipped = !0) : cur > 3 && (res += `
+  `.concat(expectedLines[i - 2]), printedLines++), res += `
+  `.concat(expectedLines[i - 1]), printedLines++), lastPos = i, other += `
+`.concat(red, "-").concat(white, " ").concat(expectedLines[i]), printedLines++;
+        else if (expectedLines.length < i + 1)
+          cur > 1 && i > 2 && (cur > 4 ? (res += `
+`.concat(blue, "...").concat(white), skipped = !0) : cur > 3 && (res += `
+  `.concat(actualLines[i - 2]), printedLines++), res += `
+  `.concat(actualLines[i - 1]), printedLines++), lastPos = i, res += `
+`.concat(green, "+").concat(white, " ").concat(actualLines[i]), printedLines++;
+        else {
+          var expectedLine = expectedLines[i], actualLine = actualLines[i], divergingLines = actualLine !== expectedLine && (!endsWith(actualLine, ",") || actualLine.slice(0, -1) !== expectedLine);
+          divergingLines && endsWith(expectedLine, ",") && expectedLine.slice(0, -1) === actualLine && (divergingLines = !1, actualLine += ","), divergingLines ? (cur > 1 && i > 2 && (cur > 4 ? (res += `
+`.concat(blue, "...").concat(white), skipped = !0) : cur > 3 && (res += `
+  `.concat(actualLines[i - 2]), printedLines++), res += `
+  `.concat(actualLines[i - 1]), printedLines++), lastPos = i, res += `
+`.concat(green, "+").concat(white, " ").concat(actualLine), other += `
+`.concat(red, "-").concat(white, " ").concat(expectedLine), printedLines += 2) : (res += other, other = "", (cur === 1 || i === 0) && (res += `
+  `.concat(actualLine), printedLines++));
+        }
+        if (printedLines > 20 && i < maxLines - 2)
+          return "".concat(msg).concat(skippedMsg, `
+`).concat(res, `
+`).concat(blue, "...").concat(white).concat(other, `
+`) + "".concat(blue, "...").concat(white);
+      }
+      return "".concat(msg).concat(skipped ? skippedMsg : "", `
+`).concat(res).concat(other).concat(end).concat(indicator);
+    }
+    var AssertionError = function(_Error) {
+      _inherits(AssertionError2, _Error);
+      function AssertionError2(options) {
+        var _this;
+        if (_classCallCheck(this, AssertionError2), _typeof(options) !== "object" || options === null)
+          throw new ERR_INVALID_ARG_TYPE("options", "Object", options);
+        var { message, operator, stackStartFn, actual, expected } = options, limit = Error.stackTraceLimit;
+        if (Error.stackTraceLimit = 0, message != null)
+          _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError2).call(this, String(message)));
+        else if (process.stderr && process.stderr.isTTY && (process.stderr && process.stderr.getColorDepth && process.stderr.getColorDepth() !== 1 ? (blue = "", green = "", white = "", red = "") : (blue = "", green = "", white = "", red = "")), _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)), operator === "deepStrictEqual" || operator === "strictEqual")
+          _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError2).call(this, createErrDiff(actual, expected, operator)));
+        else if (operator === "notDeepStrictEqual" || operator === "notStrictEqual") {
+          var base = kReadableOperator[operator], res = inspectValue(actual).split(`
+`);
+          if (operator === "notStrictEqual" && _typeof(actual) === "object" && actual !== null && (base = kReadableOperator.notStrictEqualObject), res.length > 30)
+            for (res[26] = "".concat(blue, "...").concat(white);res.length > 27; )
+              res.pop();
+          res.length === 1 ? _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError2).call(this, "".concat(base, " ").concat(res[0]))) : _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError2).call(this, "".concat(base, `
+
+`).concat(res.join(`
+`), `
+`)));
+        } else {
+          var _res = inspectValue(actual), other = "", knownOperators = kReadableOperator[operator];
+          operator === "notDeepEqual" || operator === "notEqual" ? (_res = "".concat(kReadableOperator[operator], `
+
+`).concat(_res), _res.length > 1024 && (_res = "".concat(_res.slice(0, 1021), "..."))) : (other = "".concat(inspectValue(expected)), _res.length > 512 && (_res = "".concat(_res.slice(0, 509), "...")), other.length > 512 && (other = "".concat(other.slice(0, 509), "...")), operator === "deepEqual" || operator === "equal" ? _res = "".concat(knownOperators, `
+
+`).concat(_res, `
+
+should equal
+
+`) : other = " ".concat(operator, " ").concat(other)), _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError2).call(this, "".concat(_res).concat(other)));
+        }
+        return Error.stackTraceLimit = limit, _this.generatedMessage = !message, Object.defineProperty(_assertThisInitialized(_this), "name", {
+          value: "AssertionError [ERR_ASSERTION]",
+          enumerable: !1,
+          writable: !0,
+          configurable: !0
+        }), _this.code = "ERR_ASSERTION", _this.actual = actual, _this.expected = expected, _this.operator = operator, Error.captureStackTrace && Error.captureStackTrace(_assertThisInitialized(_this), stackStartFn), _this.stack, _this.name = "AssertionError", _possibleConstructorReturn(_this);
+      }
+      return _createClass(AssertionError2, [
+        {
+          key: "toString",
+          value: function() {
+            return "".concat(this.name, " [").concat(this.code, "]: ").concat(this.message);
+          }
+        },
+        {
+          key: inspect.custom,
+          value: function(recurseTimes, ctx) {
+            return inspect(this, _objectSpread({}, ctx, {
+              customInspect: !1,
+              depth: 0
+            }));
+          }
+        }
+      ]), AssertionError2;
+    }(_wrapNativeSuper(Error));
+    module2.exports = AssertionError;
+  }
+}), require_assert = __commonJS({
+  "assert/build/assert.js"(exports, module2) {
+    function _typeof(obj) {
+      return typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? _typeof = function(obj2) {
+        return typeof obj2;
+      } : _typeof = function(obj2) {
+        return obj2 && typeof Symbol == "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      }, _typeof(obj);
+    }
+    function _classCallCheck(instance, Constructor) {
+      if (!(instance instanceof Constructor))
+        throw new TypeError("Cannot call a class as a function");
+    }
+    var _require = require_errors(), _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, AssertionError = require_assertion_error(), _require2 = require2("util"), inspect = _require2.inspect, _require$types = require2("util").types, isPromise = _require$types.isPromise, isRegExp = _require$types.isRegExp, objectAssign = Object.assign, objectIs = Object.is, errorCache = new Map, warned = !1, assert = module2.exports = ok, NO_EXCEPTION_SENTINEL = {};
+    function innerFail(obj) {
+      throw obj.message instanceof Error ? obj.message : new AssertionError(obj);
+    }
+    function fail(actual, expected, message, operator, stackStartFn) {
+      var argsLen = arguments.length, internalMessage;
+      if (argsLen === 0)
+        internalMessage = "Failed";
+      else if (argsLen === 1)
+        message = actual, actual = void 0;
+      else {
+        if (warned === !1) {
+          warned = !0;
+          var warn = process.emitWarning ? process.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");
+        }
+        argsLen === 2 && (operator = "!=");
+      }
+      if (message instanceof Error)
+        throw message;
+      var errArgs = {
+        actual,
+        expected,
+        operator: operator === void 0 ? "fail" : operator,
+        stackStartFn: stackStartFn || fail
+      };
+      message !== void 0 && (errArgs.message = message);
+      var err = new AssertionError(errArgs);
+      throw internalMessage && (err.message = internalMessage, err.generatedMessage = !0), err;
+    }
+    assert.fail = fail, assert.AssertionError = AssertionError;
+    function innerOk(fn, argLen, value, message) {
+      if (!value) {
+        var generatedMessage = !1;
+        if (argLen === 0)
+          generatedMessage = !0, message = "No value argument passed to `assert.ok()`";
+        else if (message instanceof Error)
+          throw message;
+        var err = new AssertionError({
+          actual: value,
+          expected: !0,
+          message,
+          operator: "==",
+          stackStartFn: fn
+        });
+        throw err.generatedMessage = generatedMessage, err;
+      }
+    }
+    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, assert.equal = function equal(actual, expected, message) {
+      if (arguments.length < 2)
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      actual != expected && innerFail({
+        actual,
+        expected,
+        message,
+        operator: "==",
+        stackStartFn: equal
+      });
+    }, assert.notEqual = function notEqual(actual, expected, message) {
+      if (arguments.length < 2)
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      actual == expected && innerFail({
+        actual,
+        expected,
+        message,
+        operator: "!=",
+        stackStartFn: notEqual
+      });
+    }, assert.deepEqual = function deepEqual(actual, expected, message) {
+      if (arguments.length < 2)
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      isDeepEqual(actual, expected, !1) || innerFail({
+        actual,
+        expected,
+        message,
+        operator: "deepEqual",
+        stackStartFn: deepEqual
+      });
+    }, assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+      if (arguments.length < 2)
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      isDeepEqual(actual, expected, !1) && innerFail({
+        actual,
+        expected,
+        message,
+        operator: "notDeepEqual",
+        stackStartFn: notDeepEqual
+      });
+    }, assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
+      if (arguments.length < 2)
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      isDeepEqual(actual, expected, !0) || innerFail({
+        actual,
+        expected,
+        message,
+        operator: "deepStrictEqual",
+        stackStartFn: deepStrictEqual
+      });
+    }, assert.notDeepStrictEqual = notDeepStrictEqual;
+    function notDeepStrictEqual(actual, expected, message) {
+      if (arguments.length < 2)
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      isDeepEqual(actual, expected, !0) && innerFail({
+        actual,
+        expected,
+        message,
+        operator: "notDeepStrictEqual",
+        stackStartFn: notDeepStrictEqual
+      });
+    }
+    assert.strictEqual = function strictEqual(actual, expected, message) {
+      if (arguments.length < 2)
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      objectIs(actual, expected) || innerFail({
+        actual,
+        expected,
+        message,
+        operator: "strictEqual",
+        stackStartFn: strictEqual
+      });
+    }, assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+      if (arguments.length < 2)
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      objectIs(actual, expected) && innerFail({
+        actual,
+        expected,
+        message,
+        operator: "notStrictEqual",
+        stackStartFn: notStrictEqual
+      });
+    }, assert.match = function match(actual, expected, message) {
+      if (arguments.length < 2)
+        throw new ERR_MISSING_ARGS("actual", "expected");
+      if (!isRegExp(expected))
+        throw new ERR_INVALID_ARG_TYPE("expected", "RegExp", expected);
+      expected.test(actual) || innerFail({
+        actual,
+        expected,
+        message,
+        operator: "match",
+        stackStartFn: match
+      });
+    };
+    var Comparison = function Comparison2(obj, keys, actual) {
+      var _this = this;
+      _classCallCheck(this, Comparison2), keys.forEach(function(key) {
+        (key in obj) && (actual !== void 0 && typeof actual[key] == "string" && isRegExp(obj[key]) && obj[key].test(actual[key]) ? _this[key] = actual[key] : _this[key] = obj[key]);
+      });
+    };
+    function compareExceptionKey(actual, expected, key, message, keys, fn) {
+      if (!(key in actual) || !isDeepEqual(actual[key], expected[key], !0)) {
+        if (!message) {
+          var a = new Comparison(actual, keys), b = new Comparison(expected, keys, actual), err = new AssertionError({
+            actual: a,
+            expected: b,
+            operator: "deepStrictEqual",
+            stackStartFn: fn
+          });
+          throw err.actual = actual, err.expected = expected, err.operator = fn.name, err;
+        }
+        innerFail({
+          actual,
+          expected,
+          message,
+          operator: fn.name,
+          stackStartFn: fn
+        });
+      }
+    }
+    function expectedException(actual, expected, msg, fn) {
+      if (typeof expected != "function") {
+        if (isRegExp(expected))
+          return expected.test(actual);
+        if (arguments.length === 2)
+          throw new ERR_INVALID_ARG_TYPE("expected", ["Function", "RegExp"], expected);
+        if (_typeof(actual) !== "object" || actual === null) {
+          var err = new AssertionError({
+            actual,
+            expected,
+            message: msg,
+            operator: "deepStrictEqual",
+            stackStartFn: fn
+          });
+          throw err.operator = fn.name, err;
+        }
+        var keys = Object.keys(expected);
+        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");
+        return keys.forEach(function(key) {
+          return typeof actual[key] == "string" && isRegExp(expected[key]) && expected[key].test(actual[key]) || compareExceptionKey(actual, expected, key, msg, keys, fn);
+        }), !0;
+      }
+      return expected.prototype !== void 0 && actual instanceof expected ? !0 : Error.isPrototypeOf(expected) ? !1 : expected.call({}, actual) === !0;
+    }
+    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) {
+      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") {
+          if (resultPromise = promiseFn(), !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 = void 0;
+      } 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 = "";
+        error && error.name && (details += " (".concat(error.name, ")")), details += message ? ": ".concat(message) : ".";
+        var fnType = stackStartFn.name === "rejects" ? "rejection" : "exception";
+        innerFail({
+          actual: void 0,
+          expected: error,
+          operator: stackStartFn.name,
+          message: "Missing expected ".concat(fnType).concat(details),
+          stackStartFn
+        });
+      }
+      if (error && !expectedException(actual, error, message, stackStartFn))
+        throw actual;
+    }
+    function expectsNoError(stackStartFn, actual, error, message) {
+      if (actual !== NO_EXCEPTION_SENTINEL) {
+        if (typeof error == "string" && (message = error, error = void 0), !error || expectedException(actual, error)) {
+          var details = message ? ": ".concat(message) : ".", fnType = stackStartFn.name === "doesNotReject" ? "rejection" : "exception";
+          innerFail({
+            actual,
+            expected: error,
+            operator: stackStartFn.name,
+            message: "Got unwanted ".concat(fnType).concat(details, `
+`) + 'Actual message: "'.concat(actual && actual.message, '"'),
+            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) {
+        var message = "ifError got unwanted exception: ";
+        _typeof(err) === "object" && typeof err.message == "string" ? err.message.length === 0 && err.constructor ? message += err.constructor.name : message += err.message : message += inspect(err);
+        var newErr = new AssertionError({
+          actual: err,
+          expected: null,
+          operator: "ifError",
+          message,
+          stackStartFn: ifError
+        }), origStack = err.stack;
+        if (typeof origStack == "string") {
+          var tmp2 = origStack.split(`
+`);
+          tmp2.shift();
+          for (var tmp1 = newErr.stack.split(`
+`), i = 0;i < tmp2.length; i++) {
+            var pos = tmp1.indexOf(tmp2[i]);
+            if (pos !== -1) {
+              tmp1 = tmp1.slice(0, pos);
+              break;
+            }
+          }
+          newErr.stack = "".concat(tmp1.join(`
+`), `
+`).concat(tmp2.join(`
+`));
+        }
+        throw newErr;
+      }
+    };
+    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;
+  }
+}), assert_module = require_assert();
+assert_module[Symbol.for("CommonJS")] = 0;
+assert_module["CallTracker"] = CallTracker;
+var {
+  AssertionError,
+  assert,
+  deepEqual,
+  deepStrictEqual,
+  doesNotReject,
+  doesNotThrow,
+  equal,
+  fail,
+  ifError,
+  notDeepEqual,
+  notDeepStrictEqual,
+  notEqual,
+  notStrictEqual,
+  ok,
+  rejects,
+  strict,
+  strictEqual,
+  throws
+} = assert_module, assert_default = assert_module;
+export {
+  throws,
+  strictEqual,
+  strict,
+  rejects,
+  ok,
+  notStrictEqual,
+  notEqual,
+  notDeepStrictEqual,
+  notDeepEqual,
+  ifError,
+  fail,
+  equal,
+  doesNotThrow,
+  doesNotReject,
+  assert_default as default,
+  deepStrictEqual,
+  deepEqual,
+  assert,
+  AssertionError
+};
+
+//# debugId=2D8E8643C1F8FAB464756e2164756e21