@dxos/node-std 0.12.0-next-73daef452f1464b62efdbca75fb0067c1066f264 → 0.13.0

package/dist/lib/assert.mjs

@@ -0,0 +1,1613 @@
+import { n as __toESM, t as __commonJSMin } from "./chunk-rolldown-runtime.mjs";
+import { i as require_define_data_property, n as require_call_bind, r as require_has_property_descriptors, t as require_util } from "./chunk-util.mjs";
+//#region ../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/errors.js
+var require_errors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function _typeof(obj) {
+		if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") _typeof = function _typeof(obj) {
+			return typeof obj;
+		};
+		else _typeof = function _typeof(obj) {
+			return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+		};
+		return _typeof(obj);
+	}
+	function _classCallCheck(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _possibleConstructorReturn(self, call) {
+		if (call && (_typeof(call) === "object" || typeof call === "function")) return call;
+		return _assertThisInitialized(self);
+	}
+	function _assertThisInitialized(self) {
+		if (self === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return self;
+	}
+	function _getPrototypeOf(o) {
+		_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+			return o.__proto__ || Object.getPrototypeOf(o);
+		};
+		return _getPrototypeOf(o);
+	}
+	function _inherits(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function");
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) _setPrototypeOf(subClass, superClass);
+	}
+	function _setPrototypeOf(o, p) {
+		_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+			o.__proto__ = p;
+			return o;
+		};
+		return _setPrototypeOf(o, p);
+	}
+	var codes = {};
+	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);
+		}
+		codes[code] = /* @__PURE__ */ function(_Base) {
+			_inherits(NodeError, _Base);
+			function NodeError(arg1, arg2, arg3) {
+				var _this;
+				_classCallCheck(this, NodeError);
+				_this = _possibleConstructorReturn(this, _getPrototypeOf(NodeError).call(this, getMessage(arg1, arg2, arg3)));
+				_this.code = code;
+				return _this;
+			}
+			return NodeError;
+		}(Base);
+	}
+	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));
+	}
+	function startsWith(str, search, pos) {
+		return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
+	}
+	function endsWith(str, search, this_len) {
+		if (this_len === void 0 || this_len > str.length) this_len = str.length;
+		return str.substring(this_len - search.length, this_len) === search;
+	}
+	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 === void 0) assert = require_assert();
+		assert(typeof name === "string", "'name' must be a string");
+		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")) 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"));
+		}
+		msg += ". Received type ".concat(_typeof(actual));
+		return msg;
+	}, TypeError);
+	createErrorType("ERR_INVALID_ARG_VALUE", function(name, value) {
+		var reason = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "is invalid";
+		if (util === void 0) util = require_util();
+		var inspected = util.inspect(value);
+		if (inspected.length > 128) inspected = "".concat(inspected.slice(0, 128), "...");
+		return "The argument '".concat(name, "' ").concat(reason, ". Received ").concat(inspected);
+	}, TypeError, RangeError);
+	createErrorType("ERR_INVALID_RETURN_VALUE", function(input, name, value) {
+		var type;
+		if (value && value.constructor && value.constructor.name) type = "instance of ".concat(value.constructor.name);
+		else type = "type ".concat(_typeof(value));
+		return "Expected ".concat(input, " to be returned from the \"").concat(name, "\"") + " function but got ".concat(type, ".");
+	}, TypeError);
+	createErrorType("ERR_MISSING_ARGS", function() {
+		for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+		if (assert === void 0) assert = require_assert();
+		assert(args.length > 0, "At least one arg needs to be specified");
+		var msg = "The ";
+		var len = args.length;
+		args = args.map(function(a) {
+			return "\"".concat(a, "\"");
+		});
+		switch (len) {
+			case 1:
+				msg += "".concat(args[0], " argument");
+				break;
+			case 2:
+				msg += "".concat(args[0], " and ").concat(args[1], " arguments");
+				break;
+			default:
+				msg += args.slice(0, len - 1).join(", ");
+				msg += ", and ".concat(args[len - 1], " arguments");
+		}
+		return "".concat(msg, " must be specified");
+	}, TypeError);
+	module.exports.codes = codes;
+}));
+//#endregion
+//#region ../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/assert/assertion_error.js
+var require_assertion_error = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function _objectSpread(target) {
+		for (var i = 1; i < arguments.length; i++) {
+			var source = arguments[i] != null ? arguments[i] : {};
+			var ownKeys = Object.keys(source);
+			if (typeof Object.getOwnPropertySymbols === "function") ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+				return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+			}));
+			ownKeys.forEach(function(key) {
+				_defineProperty(target, key, source[key]);
+			});
+		}
+		return target;
+	}
+	function _defineProperty(obj, key, value) {
+		if (key in obj) Object.defineProperty(obj, key, {
+			value,
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
+		else obj[key] = value;
+		return obj;
+	}
+	function _classCallCheck(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	function _defineProperties(target, props) {
+		for (var i = 0; i < props.length; i++) {
+			var descriptor = props[i];
+			descriptor.enumerable = descriptor.enumerable || false;
+			descriptor.configurable = true;
+			if ("value" in descriptor) descriptor.writable = true;
+			Object.defineProperty(target, descriptor.key, descriptor);
+		}
+	}
+	function _createClass(Constructor, protoProps, staticProps) {
+		if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+		if (staticProps) _defineProperties(Constructor, staticProps);
+		return Constructor;
+	}
+	function _possibleConstructorReturn(self, call) {
+		if (call && (_typeof(call) === "object" || typeof call === "function")) return call;
+		return _assertThisInitialized(self);
+	}
+	function _assertThisInitialized(self) {
+		if (self === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+		return self;
+	}
+	function _inherits(subClass, superClass) {
+		if (typeof superClass !== "function" && superClass !== null) throw new TypeError("Super expression must either be null or a function");
+		subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: {
+			value: subClass,
+			writable: true,
+			configurable: true
+		} });
+		if (superClass) _setPrototypeOf(subClass, superClass);
+	}
+	function _wrapNativeSuper(Class) {
+		var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
+		_wrapNativeSuper = function _wrapNativeSuper(Class) {
+			if (Class === null || !_isNativeFunction(Class)) return Class;
+			if (typeof Class !== "function") throw new TypeError("Super expression must either be null or a function");
+			if (typeof _cache !== "undefined") {
+				if (_cache.has(Class)) return _cache.get(Class);
+				_cache.set(Class, Wrapper);
+			}
+			function Wrapper() {
+				return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+			}
+			Wrapper.prototype = Object.create(Class.prototype, { constructor: {
+				value: Wrapper,
+				enumerable: false,
+				writable: true,
+				configurable: true
+			} });
+			return _setPrototypeOf(Wrapper, Class);
+		};
+		return _wrapNativeSuper(Class);
+	}
+	function isNativeReflectConstruct() {
+		if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+		if (Reflect.construct.sham) return false;
+		if (typeof Proxy === "function") return true;
+		try {
+			Date.prototype.toString.call(Reflect.construct(Date, [], function() {}));
+			return true;
+		} catch (e) {
+			return false;
+		}
+	}
+	function _construct(Parent, args, Class) {
+		if (isNativeReflectConstruct()) _construct = Reflect.construct;
+		else _construct = function _construct(Parent, args, Class) {
+			var a = [null];
+			a.push.apply(a, args);
+			var instance = new (Function.bind.apply(Parent, a))();
+			if (Class) _setPrototypeOf(instance, Class.prototype);
+			return instance;
+		};
+		return _construct.apply(null, arguments);
+	}
+	function _isNativeFunction(fn) {
+		return Function.toString.call(fn).indexOf("[native code]") !== -1;
+	}
+	function _setPrototypeOf(o, p) {
+		_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+			o.__proto__ = p;
+			return o;
+		};
+		return _setPrototypeOf(o, p);
+	}
+	function _getPrototypeOf(o) {
+		_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+			return o.__proto__ || Object.getPrototypeOf(o);
+		};
+		return _getPrototypeOf(o);
+	}
+	function _typeof(obj) {
+		if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") _typeof = function _typeof(obj) {
+			return typeof obj;
+		};
+		else _typeof = function _typeof(obj) {
+			return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+		};
+		return _typeof(obj);
+	}
+	var inspect = require_util().inspect;
+	var ERR_INVALID_ARG_TYPE = require_errors().codes.ERR_INVALID_ARG_TYPE;
+	function endsWith(str, search, this_len) {
+		if (this_len === void 0 || this_len > str.length) this_len = str.length;
+		return str.substring(this_len - search.length, this_len) === search;
+	}
+	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:"
+	};
+	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) {
+		return inspect(val, {
+			compact: false,
+			customInspect: false,
+			depth: 1e3,
+			maxArrayLength: Infinity,
+			showHidden: false,
+			breakLength: Infinity,
+			showProxy: false,
+			sorted: true,
+			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 = "";
+		if (operator === "strictEqual" && _typeof(actual) === "object" && _typeof(expected) === "object" && actual !== null && expected !== null) operator = "strictEqualObject";
+		if (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], "\n\n") + "".concat(actualLines[0], " !== ").concat(expectedLines[0], "\n");
+			} else if (operator !== "strictEqualObject") {
+				if (inputLength < (process.stderr && process.stderr.isTTY ? process.stderr.columns : 80)) {
+					while (actualLines[0][i] === expectedLines[0][i]) i++;
+					if (i > 2) {
+						indicator = "\n  ".concat(repeat(" ", i), "^");
+						i = 0;
+					}
+				}
+			}
+		}
+		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);
+		if (maxLines === 0) {
+			var _actualLines = actualInspected.split("\n");
+			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++) {
+			var cur = i - lastPos;
+			if (actualLines.length < i + 1) {
+				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++;
+				}
+				lastPos = i;
+				other += "\n".concat(red, "-").concat(white, " ").concat(expectedLines[i]);
+				printedLines++;
+			} else if (expectedLines.length < i + 1) {
+				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++;
+				}
+				lastPos = i;
+				res += "\n".concat(green, "+").concat(white, " ").concat(actualLines[i]);
+				printedLines++;
+			} else {
+				var expectedLine = expectedLines[i];
+				var actualLine = actualLines[i];
+				var divergingLines = actualLine !== expectedLine && (!endsWith(actualLine, ",") || actualLine.slice(0, -1) !== expectedLine);
+				if (divergingLines && endsWith(expectedLine, ",") && expectedLine.slice(0, -1) === actualLine) {
+					divergingLines = false;
+					actualLine += ",";
+				}
+				if (divergingLines) {
+					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++;
+					}
+					lastPos = i;
+					res += "\n".concat(green, "+").concat(white, " ").concat(actualLine);
+					other += "\n".concat(red, "-").concat(white, " ").concat(expectedLine);
+					printedLines += 2;
+				} else {
+					res += other;
+					other = "";
+					if (cur === 1 || i === 0) {
+						res += "\n  ".concat(actualLine);
+						printedLines++;
+					}
+				}
+			}
+			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);
+	}
+	module.exports = /* @__PURE__ */ function(_Error) {
+		_inherits(AssertionError, _Error);
+		function AssertionError(options) {
+			var _this;
+			_classCallCheck(this, AssertionError);
+			if (_typeof(options) !== "object" || options === null) throw new ERR_INVALID_ARG_TYPE("options", "Object", options);
+			var message = options.message, operator = options.operator, stackStartFn = options.stackStartFn;
+			var actual = options.actual, expected = options.expected;
+			var limit = Error.stackTraceLimit;
+			Error.stackTraceLimit = 0;
+			if (message != null) _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, String(message)));
+			else {
+				if (process.stderr && process.stderr.isTTY) {
+					if (process.stderr && process.stderr.getColorDepth && process.stderr.getColorDepth() !== 1) {
+						blue = "\x1B[34m";
+						green = "\x1B[32m";
+						white = "\x1B[39m";
+						red = "\x1B[31m";
+					} else {
+						blue = "";
+						green = "";
+						white = "";
+						red = "";
+					}
+				}
+				if (_typeof(actual) === "object" && actual !== null && _typeof(expected) === "object" && expected !== null && "stack" in actual && actual instanceof Error && "stack" in expected && expected instanceof Error) {
+					actual = copyError(actual);
+					expected = copyError(expected);
+				}
+				if (operator === "deepStrictEqual" || operator === "strictEqual") _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, createErrDiff(actual, expected, operator)));
+				else if (operator === "notDeepStrictEqual" || operator === "notStrictEqual") {
+					var base = kReadableOperator[operator];
+					var res = inspectValue(actual).split("\n");
+					if (operator === "notStrictEqual" && _typeof(actual) === "object" && actual !== null) base = kReadableOperator.notStrictEqualObject;
+					if (res.length > 30) {
+						res[26] = "".concat(blue, "...").concat(white);
+						while (res.length > 27) res.pop();
+					}
+					if (res.length === 1) _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, "".concat(base, " ").concat(res[0])));
+					else _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, "".concat(base, "\n\n").concat(res.join("\n"), "\n")));
+				} else {
+					var _res = inspectValue(actual);
+					var other = "";
+					var knownOperators = kReadableOperator[operator];
+					if (operator === "notDeepEqual" || operator === "notEqual") {
+						_res = "".concat(kReadableOperator[operator], "\n\n").concat(_res);
+						if (_res.length > 1024) _res = "".concat(_res.slice(0, 1021), "...");
+					} else {
+						other = "".concat(inspectValue(expected));
+						if (_res.length > 512) _res = "".concat(_res.slice(0, 509), "...");
+						if (other.length > 512) other = "".concat(other.slice(0, 509), "...");
+						if (operator === "deepEqual" || operator === "equal") _res = "".concat(knownOperators, "\n\n").concat(_res, "\n\nshould equal\n\n");
+						else other = " ".concat(operator, " ").concat(other);
+					}
+					_this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, "".concat(_res).concat(other)));
+				}
+			}
+			Error.stackTraceLimit = limit;
+			_this.generatedMessage = !message;
+			Object.defineProperty(_assertThisInitialized(_this), "name", {
+				value: "AssertionError [ERR_ASSERTION]",
+				enumerable: false,
+				writable: true,
+				configurable: true
+			});
+			_this.code = "ERR_ASSERTION";
+			_this.actual = actual;
+			_this.expected = expected;
+			_this.operator = operator;
+			if (Error.captureStackTrace) Error.captureStackTrace(_assertThisInitialized(_this), stackStartFn);
+			_this.stack;
+			_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) {
+				return inspect(this, _objectSpread({}, ctx, {
+					customInspect: false,
+					depth: 0
+				}));
+			}
+		}]);
+		return AssertionError;
+	}(_wrapNativeSuper(Error));
+}));
+//#endregion
+//#region ../../../node_modules/.pnpm/es6-object-assign@1.1.0/node_modules/es6-object-assign/index.js
+/**
+* Code refactored from Mozilla Developer Network:
+* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign
+*/
+var require_es6_object_assign = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function assign(target, firstSource) {
+		if (target === void 0 || target === null) throw new TypeError("Cannot convert first argument to object");
+		var to = Object(target);
+		for (var i = 1; i < arguments.length; i++) {
+			var nextSource = arguments[i];
+			if (nextSource === void 0 || nextSource === null) continue;
+			var keysArray = Object.keys(Object(nextSource));
+			for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) {
+				var nextKey = keysArray[nextIndex];
+				var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
+				if (desc !== void 0 && desc.enumerable) to[nextKey] = nextSource[nextKey];
+			}
+		}
+		return to;
+	}
+	function polyfill() {
+		if (!Object.assign) Object.defineProperty(Object, "assign", {
+			enumerable: false,
+			configurable: true,
+			writable: true,
+			value: assign
+		});
+	}
+	module.exports = {
+		assign,
+		polyfill
+	};
+}));
+//#endregion
+//#region ../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/isArguments.js
+var require_isArguments = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var toStr = Object.prototype.toString;
+	module.exports = 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;
+	};
+}));
+//#endregion
+//#region ../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/implementation.js
+var require_implementation$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var keysShim;
+	if (!Object.keys) {
+		var has = Object.prototype.hasOwnProperty;
+		var toStr = Object.prototype.toString;
+		var isArgs = require_isArguments();
+		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() {
+			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) {
+			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;
+		};
+	}
+	module.exports = keysShim;
+}));
+//#endregion
+//#region ../../../node_modules/.pnpm/object-keys@1.1.1/node_modules/object-keys/index.js
+var require_object_keys = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var slice = Array.prototype.slice;
+	var isArgs = require_isArguments();
+	var origKeys = Object.keys;
+	var keysShim = origKeys ? function keys(o) {
+		return origKeys(o);
+	} : require_implementation$2();
+	var originalKeys = Object.keys;
+	keysShim.shim = function shimObjectKeys() {
+		if (Object.keys) {
+			if (!function() {
+				var args = Object.keys(arguments);
+				return args && args.length === arguments.length;
+			}(1, 2)) Object.keys = function keys(object) {
+				if (isArgs(object)) return originalKeys(slice.call(object));
+				return originalKeys(object);
+			};
+		} else Object.keys = keysShim;
+		return Object.keys || keysShim;
+	};
+	module.exports = keysShim;
+}));
+//#endregion
+//#region ../../../node_modules/.pnpm/define-properties@1.2.1/node_modules/define-properties/index.js
+var require_define_properties = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var keys = require_object_keys();
+	var hasSymbols = typeof Symbol === "function" && typeof Symbol("foo") === "symbol";
+	var toStr = Object.prototype.toString;
+	var concat = Array.prototype.concat;
+	var defineDataProperty = require_define_data_property();
+	var isFunction = function(fn) {
+		return typeof fn === "function" && toStr.call(fn) === "[object Function]";
+	};
+	var supportsDescriptors = require_has_property_descriptors()();
+	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;
+	module.exports = defineProperties;
+}));
+//#endregion
+//#region ../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/implementation.js
+var require_implementation$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var numberIsNaN = function(value) {
+		return value !== value;
+	};
+	module.exports = 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;
+	};
+}));
+//#endregion
+//#region ../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/polyfill.js
+var require_polyfill$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var implementation = require_implementation$1();
+	module.exports = function getPolyfill() {
+		return typeof Object.is === "function" ? Object.is : implementation;
+	};
+}));
+//#endregion
+//#region ../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/shim.js
+var require_shim$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var getPolyfill = require_polyfill$1();
+	var define = require_define_properties();
+	module.exports = function shimObjectIs() {
+		var polyfill = getPolyfill();
+		define(Object, { is: polyfill }, { is: function testObjectIs() {
+			return Object.is !== polyfill;
+		} });
+		return polyfill;
+	};
+}));
+//#endregion
+//#region ../../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/index.js
+var require_object_is = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var define = require_define_properties();
+	var callBind = require_call_bind();
+	var implementation = require_implementation$1();
+	var getPolyfill = require_polyfill$1();
+	var shim = require_shim$1();
+	var polyfill = callBind(getPolyfill(), Object);
+	define(polyfill, {
+		getPolyfill,
+		implementation,
+		shim
+	});
+	module.exports = polyfill;
+}));
+//#endregion
+//#region ../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/implementation.js
+var require_implementation = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function isNaN(value) {
+		return value !== value;
+	};
+}));
+//#endregion
+//#region ../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/polyfill.js
+var require_polyfill = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var implementation = require_implementation();
+	module.exports = function getPolyfill() {
+		if (Number.isNaN && !Number.isNaN("a")) return Number.isNaN;
+		return implementation;
+	};
+}));
+//#endregion
+//#region ../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/shim.js
+var require_shim = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var define = require_define_properties();
+	var getPolyfill = require_polyfill();
+	module.exports = function shimNumberIsNaN() {
+		var polyfill = getPolyfill();
+		define(Number, { isNaN: polyfill }, { isNaN: function testIsNaN() {
+			return Number.isNaN !== polyfill;
+		} });
+		return polyfill;
+	};
+}));
+//#endregion
+//#region ../../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/index.js
+var require_is_nan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var callBind = require_call_bind();
+	var define = require_define_properties();
+	var implementation = require_implementation();
+	var getPolyfill = require_polyfill();
+	var shim = require_shim();
+	var polyfill = callBind(getPolyfill(), Number);
+	define(polyfill, {
+		getPolyfill,
+		implementation,
+		shim
+	});
+	module.exports = polyfill;
+}));
+//#endregion
+//#region ../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/internal/util/comparisons.js
+var require_comparisons = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function _slicedToArray(arr, i) {
+		return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
+	}
+	function _nonIterableRest() {
+		throw new TypeError("Invalid attempt to destructure non-iterable instance");
+	}
+	function _iterableToArrayLimit(arr, i) {
+		var _arr = [];
+		var _n = true;
+		var _d = false;
+		var _e = void 0;
+		try {
+			for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
+				_arr.push(_s.value);
+				if (i && _arr.length === i) break;
+			}
+		} catch (err) {
+			_d = true;
+			_e = err;
+		} finally {
+			try {
+				if (!_n && _i["return"] != null) _i["return"]();
+			} finally {
+				if (_d) throw _e;
+			}
+		}
+		return _arr;
+	}
+	function _arrayWithHoles(arr) {
+		if (Array.isArray(arr)) return arr;
+	}
+	function _typeof(obj) {
+		if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") _typeof = function _typeof(obj) {
+			return typeof obj;
+		};
+		else _typeof = function _typeof(obj) {
+			return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+		};
+		return _typeof(obj);
+	}
+	var regexFlagsSupported = /a/g.flags !== void 0;
+	var arrayFromSet = function arrayFromSet(set) {
+		var array = [];
+		set.forEach(function(value) {
+			return array.push(value);
+		});
+		return array;
+	};
+	var arrayFromMap = function arrayFromMap(map) {
+		var array = [];
+		map.forEach(function(value, key) {
+			return array.push([key, value]);
+		});
+		return array;
+	};
+	var objectIs = Object.is ? Object.is : require_object_is();
+	var objectGetOwnPropertySymbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols : function() {
+		return [];
+	};
+	var numberIsNaN = Number.isNaN ? Number.isNaN : require_is_nan();
+	function uncurryThis(f) {
+		return f.call.bind(f);
+	}
+	var hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);
+	var propertyIsEnumerable = uncurryThis(Object.prototype.propertyIsEnumerable);
+	var objectToString = uncurryThis(Object.prototype.toString);
+	var _require$types = require_util().types;
+	var isAnyArrayBuffer = _require$types.isAnyArrayBuffer;
+	var isArrayBufferView = _require$types.isArrayBufferView;
+	var isDate = _require$types.isDate;
+	var isMap = _require$types.isMap;
+	var isRegExp = _require$types.isRegExp;
+	var isSet = _require$types.isSet;
+	var isNativeError = _require$types.isNativeError;
+	var isBoxedPrimitive = _require$types.isBoxedPrimitive;
+	var isNumberObject = _require$types.isNumberObject;
+	var isStringObject = _require$types.isStringObject;
+	var isBooleanObject = _require$types.isBooleanObject;
+	var isBigIntObject = _require$types.isBigIntObject;
+	var isSymbolObject = _require$types.isSymbolObject;
+	var isFloat32Array = _require$types.isFloat32Array;
+	var 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;
+		}
+		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)));
+	}
+	/*!
+	* The buffer module from node.js, for the browser.
+	*
+	* @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+	* @license  MIT
+	*/
+	function compare(a, b) {
+		if (a === b) return 0;
+		var x = a.length;
+		var y = b.length;
+		for (var i = 0, len = Math.min(x, y); i < len; ++i) if (a[i] !== b[i]) {
+			x = a[i];
+			y = b[i];
+			break;
+		}
+		if (x < y) return -1;
+		if (y < x) return 1;
+		return 0;
+	}
+	var ONLY_ENUMERABLE = void 0;
+	var kStrict = true;
+	var kLoose = false;
+	var kNoIterator = 0;
+	var kIsArray = 1;
+	var kIsSet = 2;
+	var kIsMap = 3;
+	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);
+	}
+	function innerDeepEqual(val1, val2, strict, memos) {
+		if (val1 === val2) {
+			if (val1 !== 0) return true;
+			return strict ? objectIs(val1, val2) : true;
+		}
+		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") return val1 == val2;
+				return false;
+			}
+			if (val2 === null || _typeof(val2) !== "object") return false;
+		}
+		var val1Tag = objectToString(val1);
+		if (val1Tag !== objectToString(val2)) return false;
+		if (Array.isArray(val1)) {
+			if (val1.length !== val2.length) return false;
+			var keys1 = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);
+			var keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);
+			if (keys1.length !== keys2.length) return false;
+			return keyCheck(val1, val2, strict, memos, kIsArray, keys1);
+		}
+		if (val1Tag === "[object Object]") {
+			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) {
+			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;
+			var _keys = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);
+			var _keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);
+			if (_keys.length !== _keys2.length) return false;
+			return keyCheck(val1, val2, strict, memos, kNoIterator, _keys);
+		} else if (isSet(val1)) {
+			if (!isSet(val2) || val1.size !== val2.size) return false;
+			return keyCheck(val1, val2, strict, memos, kIsSet);
+		} else if (isMap(val1)) {
+			if (!isMap(val2) || val1.size !== val2.size) return false;
+			return keyCheck(val1, val2, strict, memos, kIsMap);
+		} else if (isAnyArrayBuffer(val1)) {
+			if (!areEqualArrayBuffers(val1, val2)) return false;
+		} else if (isBoxedPrimitive(val1) && !isEqualBoxedPrimitive(val1, val2)) return false;
+		return keyCheck(val1, val2, strict, memos, kNoIterator);
+	}
+	function getEnumerables(val, keys) {
+		return keys.filter(function(k) {
+			return propertyIsEnumerable(val, k);
+		});
+	}
+	function keyCheck(val1, val2, strict, memos, iterationType, aKeys) {
+		if (arguments.length === 5) {
+			aKeys = Object.keys(val1);
+			var bKeys = Object.keys(val2);
+			if (aKeys.length !== bKeys.length) return false;
+		}
+		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;
+		if (memos === void 0) memos = {
+			val1: /* @__PURE__ */ new Map(),
+			val2: /* @__PURE__ */ new Map(),
+			position: 0
+		};
+		else {
+			var val2MemoA = memos.val1.get(val1);
+			if (val2MemoA !== void 0) {
+				var val2MemoB = memos.val2.get(val2);
+				if (val2MemoB !== void 0) 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) {
+		var setValues = arrayFromSet(set);
+		for (var i = 0; i < setValues.length; i++) {
+			var val2 = setValues[i];
+			if (innerDeepEqual(val1, val2, strict, memo)) {
+				set.delete(val2);
+				return true;
+			}
+		}
+		return false;
+	}
+	function findLooseMatchingPrimitives(prim) {
+		switch (_typeof(prim)) {
+			case "undefined": return null;
+			case "object": return;
+			case "symbol": return false;
+			case "string": prim = +prim;
+			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 === void 0 && !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) {
+		var set = null;
+		var aValues = arrayFromSet(a);
+		for (var i = 0; i < aValues.length; i++) {
+			var val = aValues[i];
+			if (_typeof(val) === "object" && val !== null) {
+				if (set === null) set = /* @__PURE__ */ new Set();
+				set.add(val);
+			} else if (!b.has(val)) {
+				if (strict) return false;
+				if (!setMightHaveLoosePrim(a, b, val)) return false;
+				if (set === null) set = /* @__PURE__ */ new Set();
+				set.add(val);
+			}
+		}
+		if (set !== null) {
+			var bValues = arrayFromSet(b);
+			for (var _i = 0; _i < bValues.length; _i++) {
+				var _val = bValues[_i];
+				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) {
+		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 = /* @__PURE__ */ new Set();
+				set.add(key);
+			} else {
+				var item2 = b.get(key);
+				if (item2 === void 0 && !b.has(key) || !innerDeepEqual(item1, item2, strict, memo)) {
+					if (strict) return false;
+					if (!mapMightHaveLoosePrim(a, b, key, item1, memo)) return false;
+					if (set === null) set = /* @__PURE__ */ 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) {
+		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 {
+			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;
+		}
+		for (i = 0; i < keys.length; i++) {
+			var _key = keys[i];
+			if (!innerDeepEqual(a[_key], b[_key], strict, memos)) return false;
+		}
+		return true;
+	}
+	function isDeepEqual(val1, val2) {
+		return innerDeepEqual(val1, val2, kLoose);
+	}
+	function isDeepStrictEqual(val1, val2) {
+		return innerDeepEqual(val1, val2, kStrict);
+	}
+	module.exports = {
+		isDeepEqual,
+		isDeepStrictEqual
+	};
+}));
+//#endregion
+//#region ../../../node_modules/.pnpm/assert@2.0.0/node_modules/assert/build/assert.js
+var require_assert = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function _typeof(obj) {
+		if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") _typeof = function _typeof(obj) {
+			return typeof obj;
+		};
+		else _typeof = function _typeof(obj) {
+			return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+		};
+		return _typeof(obj);
+	}
+	function _classCallCheck(instance, Constructor) {
+		if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+	}
+	var _require$codes = require_errors().codes;
+	var ERR_AMBIGUOUS_ARGUMENT = _require$codes.ERR_AMBIGUOUS_ARGUMENT;
+	var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;
+	var ERR_INVALID_ARG_VALUE = _require$codes.ERR_INVALID_ARG_VALUE;
+	var ERR_INVALID_RETURN_VALUE = _require$codes.ERR_INVALID_RETURN_VALUE;
+	var ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;
+	var AssertionError = require_assertion_error();
+	var inspect = require_util().inspect;
+	var _require$types = require_util().types;
+	var isPromise = _require$types.isPromise;
+	var isRegExp = _require$types.isRegExp;
+	var objectAssign = Object.assign ? Object.assign : require_es6_object_assign().assign;
+	var objectIs = Object.is ? Object.is : require_object_is();
+	var isDeepEqual;
+	var isDeepStrictEqual;
+	function lazyLoadComparison() {
+		var comparison = require_comparisons();
+		isDeepEqual = comparison.isDeepEqual;
+		isDeepStrictEqual = comparison.isDeepStrictEqual;
+	}
+	var warned = false;
+	var assert = module.exports = ok;
+	var NO_EXCEPTION_SENTINEL = {};
+	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 = void 0;
+		} else {
+			if (warned === false) {
+				warned = true;
+				(process.emitWarning ? process.emitWarning : console.warn.bind(console))("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,
+			expected,
+			operator: operator === void 0 ? "fail" : operator,
+			stackStartFn: stackStartFn || fail
+		};
+		if (message !== void 0) errArgs.message = message;
+		var err = new AssertionError(errArgs);
+		if (internalMessage) {
+			err.message = internalMessage;
+			err.generatedMessage = true;
+		}
+		throw err;
+	}
+	assert.fail = fail;
+	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,
+				operator: "==",
+				stackStartFn: fn
+			});
+			err.generatedMessage = generatedMessage;
+			throw 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");
+		if (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");
+		if (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");
+		if (isDeepEqual === void 0) lazyLoadComparison();
+		if (!isDeepEqual(actual, expected)) 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");
+		if (isDeepEqual === void 0) lazyLoadComparison();
+		if (isDeepEqual(actual, expected)) 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");
+		if (isDeepEqual === void 0) lazyLoadComparison();
+		if (!isDeepStrictEqual(actual, expected)) 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");
+		if (isDeepEqual === void 0) lazyLoadComparison();
+		if (isDeepStrictEqual(actual, expected)) 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");
+		if (!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");
+		if (objectIs(actual, expected)) innerFail({
+			actual,
+			expected,
+			message,
+			operator: "notStrictEqual",
+			stackStartFn: notStrictEqual
+		});
+	};
+	var Comparison = function Comparison(obj, keys, actual) {
+		var _this = this;
+		_classCallCheck(this, Comparison);
+		keys.forEach(function(key) {
+			if (key in obj) {
+				if (actual !== void 0 && typeof actual[key] === "string" && isRegExp(obj[key]) && obj[key].test(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) {
+				var err = new AssertionError({
+					actual: new Comparison(actual, keys),
+					expected: new Comparison(expected, keys, actual),
+					operator: "deepStrictEqual",
+					stackStartFn: fn
+				});
+				err.actual = actual;
+				err.expected = expected;
+				err.operator = fn.name;
+				throw 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
+				});
+				err.operator = fn.name;
+				throw 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");
+			if (isDeepEqual === void 0) lazyLoadComparison();
+			keys.forEach(function(key) {
+				if (typeof actual[key] === "string" && isRegExp(expected[key]) && expected[key].test(actual[key])) return;
+				compareExceptionKey(actual, expected, key, msg, keys, fn);
+			});
+			return true;
+		}
+		if (expected.prototype !== void 0 && 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) {
+		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") {
+				resultPromise = promiseFn();
+				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 = 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 = "";
+			if (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) return;
+		if (typeof error === "string") {
+			message = error;
+			error = void 0;
+		}
+		if (!error || expectedException(actual, error)) {
+			var details = message ? ": ".concat(message) : ".";
+			var fnType = stackStartFn.name === "doesNotReject" ? "rejection" : "exception";
+			innerFail({
+				actual,
+				expected: error,
+				operator: stackStartFn.name,
+				message: "Got unwanted ".concat(fnType).concat(details, "\n") + "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 && err !== void 0) {
+			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,
+				stackStartFn: ifError
+			});
+			var origStack = err.stack;
+			if (typeof origStack === "string") {
+				var tmp2 = origStack.split("\n");
+				tmp2.shift();
+				var tmp1 = newErr.stack.split("\n");
+				for (var 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("\n"), "\n").concat(tmp2.join("\n"));
+			}
+			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;
+}));
+var assert_default = (/* @__PURE__ */ __toESM(require_assert(), 1)).default;
+//#endregion
+export { assert_default as default };
+
+//# sourceMappingURL=assert.mjs.map